ppapi/tests/test_udp_socket.cc

   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 "ppapi/tests/test_udp_socket.h"
   6
   7 #include <vector>
   8
   9 #include "ppapi/cpp/pass_ref.h"
  10 #include "ppapi/cpp/tcp_socket.h"
  11 #include "ppapi/cpp/udp_socket.h"
  12 #include "ppapi/cpp/var.h"
  13 #include "ppapi/tests/test_utils.h"
  14 #include "ppapi/tests/testing_instance.h"
  15
  16 REGISTER_TEST_CASE(UDPSocket);
  17
  18 namespace {
  19
  20 const uint16_t kPortScanFrom = 1024;
  21 const uint16_t kPortScanTo = 4096;
  22
  23 pp::NetAddress ReplacePort(const pp::InstanceHandle& instance,
  24                            const pp::NetAddress& addr,
  25                            uint16_t port) {
  26   switch (addr.GetFamily()) {
  27     case PP_NETADDRESS_FAMILY_IPV4: {
  28       PP_NetAddress_IPv4 ipv4_addr;
  29       if (!addr.DescribeAsIPv4Address(&ipv4_addr))
  30         break;
  31       ipv4_addr.port = ConvertToNetEndian16(port);
  32       return pp::NetAddress(instance, ipv4_addr);
  33     }
  34     case PP_NETADDRESS_FAMILY_IPV6: {
  35       PP_NetAddress_IPv6 ipv6_addr;
  36       if (!addr.DescribeAsIPv6Address(&ipv6_addr))
  37         break;
  38       ipv6_addr.port = ConvertToNetEndian16(port);
  39       return pp::NetAddress(instance, ipv6_addr);
  40     }
  41     default: {
  42       PP_NOTREACHED();
  43     }
  44   }
  45   return pp::NetAddress();
  46 }
  47
  48 }  // namespace
  49
  50 TestUDPSocket::TestUDPSocket(TestingInstance* instance) : TestCase(instance) {
  51 }
  52
  53 bool TestUDPSocket::Init() {
  54   bool tcp_socket_is_available = pp::TCPSocket::IsAvailable();
  55   if (!tcp_socket_is_available)
  56     instance_->AppendError("PPB_TCPSocket interface not available");
  57
  58   bool udp_socket_is_available = pp::UDPSocket::IsAvailable();
  59   if (!udp_socket_is_available)
  60     instance_->AppendError("PPB_UDPSocket interface not available");
  61
  62   bool net_address_is_available = pp::NetAddress::IsAvailable();
  63   if (!net_address_is_available)
  64     instance_->AppendError("PPB_NetAddress interface not available");
  65
  66   std::string host;
  67   uint16_t port = 0;
  68   bool init_address =
  69       GetLocalHostPort(instance_->pp_instance(), &host, &port) &&
  70       ResolveHost(instance_->pp_instance(), host, port, &address_);
  71   if (!init_address)
  72     instance_->AppendError("Can't init address");
  73
  74   return tcp_socket_is_available &&
  75       udp_socket_is_available &&
  76       net_address_is_available &&
  77       init_address &&
  78       CheckTestingInterface() &&
  79       EnsureRunningOverHTTP();
  80 }
  81
  82 void TestUDPSocket::RunTests(const std::string& filter) {
  83   RUN_CALLBACK_TEST(TestUDPSocket, ReadWrite, filter);
  84   RUN_CALLBACK_TEST(TestUDPSocket, Broadcast, filter);
  85   RUN_CALLBACK_TEST(TestUDPSocket, SetOption, filter);
  86   RUN_CALLBACK_TEST(TestUDPSocket, ParallelSend, filter);
  87 }
  88
  89 std::string TestUDPSocket::GetLocalAddress(pp::NetAddress* address) {
  90   pp::TCPSocket socket(instance_);
  91   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  92   callback.WaitForResult(socket.Connect(address_, callback.GetCallback()));
  93   CHECK_CALLBACK_BEHAVIOR(callback);
  94   ASSERT_EQ(PP_OK, callback.result());
  95   *address = socket.GetLocalAddress();
  96   ASSERT_NE(0, address->pp_resource());
  97   socket.Close();
  98   PASS();
  99 }
 100
 101 std::string TestUDPSocket::SetBroadcastOptions(pp::UDPSocket* socket) {
 102   TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
 103   callback_1.WaitForResult(socket->SetOption(
 104       PP_UDPSOCKET_OPTION_ADDRESS_REUSE, pp::Var(true),
 105       callback_1.GetCallback()));
 106   CHECK_CALLBACK_BEHAVIOR(callback_1);
 107   ASSERT_EQ(PP_OK, callback_1.result());
 108
 109   TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
 110   callback_2.WaitForResult(socket->SetOption(
 111       PP_UDPSOCKET_OPTION_BROADCAST, pp::Var(true), callback_2.GetCallback()));
 112   CHECK_CALLBACK_BEHAVIOR(callback_2);
 113   ASSERT_EQ(PP_OK, callback_2.result());
 114
 115   PASS();
 116 }
 117
 118 std::string TestUDPSocket::BindUDPSocket(pp::UDPSocket* socket,
 119                                          const pp::NetAddress& address) {
 120   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 121   callback.WaitForResult(socket->Bind(address, callback.GetCallback()));
 122   CHECK_CALLBACK_BEHAVIOR(callback);
 123   ASSERT_EQ(PP_OK, callback.result());
 124   PASS();
 125 }
 126
 127 std::string TestUDPSocket::LookupPortAndBindUDPSocket(
 128     pp::UDPSocket* socket,
 129     pp::NetAddress* address) {
 130   pp::NetAddress base_address;
 131   ASSERT_SUBTEST_SUCCESS(GetLocalAddress(&base_address));
 132
 133   bool is_free_port_found = false;
 134   for (uint16_t port = kPortScanFrom; port < kPortScanTo; ++port) {
 135     pp::NetAddress new_address = ReplacePort(instance_, base_address, port);
 136     ASSERT_NE(0, new_address.pp_resource());
 137     if (BindUDPSocket(socket, new_address).empty()) {
 138       is_free_port_found = true;
 139       break;
 140     }
 141   }
 142   if (!is_free_port_found)
 143     return "Can't find available port";
 144
 145   *address = socket->GetBoundAddress();
 146   ASSERT_NE(0, address->pp_resource());
 147
 148   PASS();
 149 }
 150
 151 std::string TestUDPSocket::ReadSocket(pp::UDPSocket* socket,
 152                                       pp::NetAddress* address,
 153                                       size_t size,
 154                                       std::string* message) {
 155   std::vector<char> buffer(size);
 156   TestCompletionCallbackWithOutput<pp::NetAddress> callback(
 157       instance_->pp_instance(), callback_type());
 158   callback.WaitForResult(
 159       socket->RecvFrom(&buffer[0], size, callback.GetCallback()));
 160   CHECK_CALLBACK_BEHAVIOR(callback);
 161   ASSERT_FALSE(callback.result() < 0);
 162   ASSERT_EQ(size, static_cast<size_t>(callback.result()));
 163   *address = callback.output();
 164   message->assign(buffer.begin(), buffer.end());
 165   PASS();
 166 }
 167
 168 std::string TestUDPSocket::PassMessage(pp::UDPSocket* target,
 169                                        pp::UDPSocket* source,
 170                                        const pp::NetAddress& target_address,
 171                                        const std::string& message,
 172                                        pp::NetAddress* recvfrom_address) {
 173   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 174   int32_t rv = source->SendTo(message.c_str(), message.size(),
 175                               target_address,
 176                               callback.GetCallback());
 177   std::string str;
 178   ASSERT_SUBTEST_SUCCESS(ReadSocket(target, recvfrom_address, message.size(),
 179                                     &str));
 180
 181   callback.WaitForResult(rv);
 182   CHECK_CALLBACK_BEHAVIOR(callback);
 183   ASSERT_FALSE(callback.result() < 0);
 184   ASSERT_EQ(message.size(), static_cast<size_t>(callback.result()));
 185   ASSERT_EQ(message, str);
 186   PASS();
 187 }
 188
 189 std::string TestUDPSocket::TestReadWrite() {
 190   pp::UDPSocket server_socket(instance_), client_socket(instance_);
 191   pp::NetAddress server_address, client_address;
 192
 193   ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&server_socket,
 194                                                     &server_address));
 195   ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&client_socket,
 196                                                     &client_address));
 197   const std::string message = "Simple message that will be sent via UDP";
 198   pp::NetAddress recvfrom_address;
 199   ASSERT_SUBTEST_SUCCESS(PassMessage(&server_socket, &client_socket,
 200                                      server_address, message,
 201                                      &recvfrom_address));
 202   ASSERT_TRUE(EqualNetAddress(recvfrom_address, client_address));
 203
 204   server_socket.Close();
 205   client_socket.Close();
 206
 207   if (server_socket.GetBoundAddress().pp_resource() != 0)
 208     return "PPB_UDPSocket::GetBoundAddress: expected failure";
 209
 210   PASS();
 211 }
 212
 213 std::string TestUDPSocket::TestBroadcast() {
 214   pp::UDPSocket server1(instance_), server2(instance_);
 215
 216   ASSERT_SUBTEST_SUCCESS(SetBroadcastOptions(&server1));
 217   ASSERT_SUBTEST_SUCCESS(SetBroadcastOptions(&server2));
 218
 219   PP_NetAddress_IPv4 any_ipv4_address = { 0, { 0, 0, 0, 0 } };
 220   pp::NetAddress any_address(instance_, any_ipv4_address);
 221   ASSERT_SUBTEST_SUCCESS(BindUDPSocket(&server1, any_address));
 222   // Fill port field of |server_address|.
 223   pp::NetAddress server_address = server1.GetBoundAddress();
 224   ASSERT_NE(0, server_address.pp_resource());
 225   ASSERT_SUBTEST_SUCCESS(BindUDPSocket(&server2, server_address));
 226
 227   PP_NetAddress_IPv4 server_ipv4_address;
 228   ASSERT_TRUE(server_address.DescribeAsIPv4Address(&server_ipv4_address));
 229
 230   PP_NetAddress_IPv4 broadcast_ipv4_address = {
 231     server_ipv4_address.port, { 0xff, 0xff, 0xff, 0xff }
 232   };
 233   pp::NetAddress broadcast_address(instance_, broadcast_ipv4_address);
 234
 235   std::string message;
 236   const std::string first_message = "first message";
 237   const std::string second_message = "second_message";
 238
 239   pp::NetAddress recvfrom_address;
 240   ASSERT_SUBTEST_SUCCESS(PassMessage(&server1, &server2, broadcast_address,
 241                                      first_message, &recvfrom_address));
 242   // |first_message| was also received by |server2|.
 243   ASSERT_SUBTEST_SUCCESS(ReadSocket(&server2, &recvfrom_address,
 244                                     first_message.size(), &message));
 245   ASSERT_EQ(first_message, message);
 246
 247   ASSERT_SUBTEST_SUCCESS(PassMessage(&server2, &server1, broadcast_address,
 248                                      second_message, &recvfrom_address));
 249   // |second_message| was also received by |server1|.
 250   ASSERT_SUBTEST_SUCCESS(ReadSocket(&server1, &recvfrom_address,
 251                                     second_message.size(), &message));
 252   ASSERT_EQ(second_message, message);
 253
 254   server1.Close();
 255   server2.Close();
 256   PASS();
 257 }
 258
 259 std::string TestUDPSocket::TestSetOption() {
 260   pp::UDPSocket socket(instance_);
 261
 262   ASSERT_SUBTEST_SUCCESS(SetBroadcastOptions(&socket));
 263
 264   // Try to pass incorrect option value's type.
 265   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 266   callback.WaitForResult(socket.SetOption(
 267       PP_UDPSOCKET_OPTION_ADDRESS_REUSE, pp::Var(1), callback.GetCallback()));
 268   CHECK_CALLBACK_BEHAVIOR(callback);
 269   ASSERT_EQ(PP_ERROR_BADARGUMENT, callback.result());
 270
 271   callback.WaitForResult(socket.SetOption(
 272       PP_UDPSOCKET_OPTION_BROADCAST, pp::Var(false), callback.GetCallback()));
 273   CHECK_CALLBACK_BEHAVIOR(callback);
 274   ASSERT_EQ(PP_OK, callback.result());
 275
 276   callback.WaitForResult(socket.SetOption(
 277       PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE, pp::Var(4096),
 278       callback.GetCallback()));
 279   CHECK_CALLBACK_BEHAVIOR(callback);
 280   ASSERT_EQ(PP_OK, callback.result());
 281
 282   callback.WaitForResult(socket.SetOption(
 283       PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE, pp::Var(512),
 284       callback.GetCallback()));
 285   CHECK_CALLBACK_BEHAVIOR(callback);
 286   ASSERT_EQ(PP_OK, callback.result());
 287
 288   pp::NetAddress address;
 289   ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&socket, &address));
 290
 291   // ADDRESS_REUSE won't take effect after the socket is bound.
 292   callback.WaitForResult(socket.SetOption(
 293       PP_UDPSOCKET_OPTION_ADDRESS_REUSE, pp::Var(true),
 294       callback.GetCallback()));
 295   CHECK_CALLBACK_BEHAVIOR(callback);
 296   ASSERT_EQ(PP_ERROR_FAILED, callback.result());
 297
 298   // BROADCAST, SEND_BUFFER_SIZE and RECV_BUFFER_SIZE can be set after the
 299   // socket is bound.
 300   callback.WaitForResult(socket.SetOption(
 301       PP_UDPSOCKET_OPTION_BROADCAST, pp::Var(true), callback.GetCallback()));
 302   CHECK_CALLBACK_BEHAVIOR(callback);
 303   ASSERT_EQ(PP_OK, callback.result());
 304
 305   callback.WaitForResult(socket.SetOption(
 306       PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE, pp::Var(2048),
 307       callback.GetCallback()));
 308   CHECK_CALLBACK_BEHAVIOR(callback);
 309   ASSERT_EQ(PP_OK, callback.result());
 310
 311   callback.WaitForResult(socket.SetOption(
 312       PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE, pp::Var(1024),
 313       callback.GetCallback()));
 314   CHECK_CALLBACK_BEHAVIOR(callback);
 315   ASSERT_EQ(PP_OK, callback.result());
 316
 317   PASS();
 318 }
 319
 320 std::string TestUDPSocket::TestParallelSend() {
 321   // This test only makes sense when callbacks are optional.
 322   if (callback_type() != PP_OPTIONAL)
 323     PASS();
 324
 325   pp::UDPSocket server_socket(instance_), client_socket(instance_);
 326   pp::NetAddress server_address, client_address;
 327
 328   ASSERT_SUBTEST_SUCCESS(
 329       LookupPortAndBindUDPSocket(&server_socket, &server_address));
 330   ASSERT_SUBTEST_SUCCESS(
 331       LookupPortAndBindUDPSocket(&client_socket, &client_address));
 332   const std::string message = "Simple message that will be sent via UDP";
 333   pp::NetAddress recvfrom_address;
 334
 335   const size_t kParallelSends = 10;
 336   std::vector<TestCompletionCallback*> sendto_callbacks(kParallelSends);
 337   std::vector<int32_t> sendto_results(kParallelSends);
 338   size_t pending = 0;
 339   for (size_t i = 0; i < kParallelSends; i++) {
 340     sendto_callbacks[i] =
 341         new TestCompletionCallback(instance_->pp_instance(), callback_type());
 342     sendto_results[i] =
 343         client_socket.SendTo(message.c_str(),
 344                              message.size(),
 345                              server_address,
 346                              sendto_callbacks[i]->GetCallback());
 347
 348     if (sendto_results[i] == PP_ERROR_INPROGRESS) {
 349       // Run a pending send to completion to free a slot for the current send.
 350       ASSERT_GT(i, pending);
 351       sendto_callbacks[pending]->WaitForResult(sendto_results[pending]);
 352       CHECK_CALLBACK_BEHAVIOR(*sendto_callbacks[pending]);
 353       ASSERT_EQ(message.size(),
 354                 static_cast<size_t>(sendto_callbacks[pending]->result()));
 355       pending++;
 356       // Try to send the message again.
 357       sendto_results[i] =
 358           client_socket.SendTo(message.c_str(),
 359                                message.size(),
 360                                server_address,
 361                                sendto_callbacks[i]->GetCallback());
 362       ASSERT_NE(PP_ERROR_INPROGRESS, sendto_results[i]);
 363     }
 364   }
 365
 366   // Finish all pending sends.
 367   for (size_t i = pending; i < kParallelSends; i++) {
 368     sendto_callbacks[i]->WaitForResult(sendto_results[i]);
 369     CHECK_CALLBACK_BEHAVIOR(*sendto_callbacks[i]);
 370     ASSERT_EQ(message.size(),
 371               static_cast<size_t>(sendto_callbacks[i]->result()));
 372   }
 373
 374   for (size_t i = 0; i < kParallelSends; ++i)
 375     delete sendto_callbacks[i];
 376
 377   for (size_t i = 0; i < kParallelSends; i++) {
 378     std::string str;
 379     ASSERT_SUBTEST_SUCCESS(
 380         ReadSocket(&server_socket, &recvfrom_address, message.size(), &str));
 381     ASSERT_EQ(message, str);
 382   }
 383
 384   server_socket.Close();
 385   client_socket.Close();
 386
 387   PASS();
 388 }