test_udp_socket_private.cc 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261
  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. #include <cstring>
  5. #include <vector>
  6. #include "ppapi/cpp/module.h"
  7. #include "ppapi/cpp/private/net_address_private.h"
  8. #include "ppapi/cpp/private/tcp_socket_private.h"
  9. #include "ppapi/cpp/var.h"
  10. #include "ppapi/tests/test_udp_socket_private.h"
  11. #include "ppapi/tests/test_utils.h"
  12. #include "ppapi/tests/testing_instance.h"
  13. REGISTER_TEST_CASE(UDPSocketPrivate);
  14. namespace {
  15. const uint16_t kPortScanFrom = 1024;
  16. const uint16_t kPortScanTo = 4096;
  17. } // namespace
  18. TestUDPSocketPrivate::TestUDPSocketPrivate(
  19. TestingInstance* instance)
  20. : TestCase(instance) {
  21. }
  22. bool TestUDPSocketPrivate::Init() {
  23. bool tcp_socket_private_is_available = pp::TCPSocketPrivate::IsAvailable();
  24. if (!tcp_socket_private_is_available)
  25. instance_->AppendError("PPB_TCPSocket_Private interface not available");
  26. bool udp_socket_private_is_available = pp::UDPSocketPrivate::IsAvailable();
  27. if (!udp_socket_private_is_available)
  28. instance_->AppendError("PPB_UDPSocket_Private interface not available");
  29. bool net_address_private_is_available = pp::NetAddressPrivate::IsAvailable();
  30. if (!net_address_private_is_available)
  31. instance_->AppendError("PPB_NetAddress_Private interface not available");
  32. bool init_host_port = GetLocalHostPort(instance_->pp_instance(),
  33. &host_, &port_);
  34. if (!init_host_port)
  35. instance_->AppendError("Can't init host and port");
  36. return tcp_socket_private_is_available &&
  37. udp_socket_private_is_available &&
  38. net_address_private_is_available &&
  39. init_host_port &&
  40. CheckTestingInterface() &&
  41. EnsureRunningOverHTTP();
  42. }
  43. void TestUDPSocketPrivate::RunTests(const std::string& filter) {
  44. RUN_CALLBACK_TEST(TestUDPSocketPrivate, Connect, filter);
  45. RUN_CALLBACK_TEST(TestUDPSocketPrivate, ConnectFailure, filter);
  46. RUN_CALLBACK_TEST(TestUDPSocketPrivate, Broadcast, filter);
  47. RUN_CALLBACK_TEST(TestUDPSocketPrivate, SetSocketFeatureErrors, filter);
  48. }
  49. std::string TestUDPSocketPrivate::GetLocalAddress(
  50. PP_NetAddress_Private* address) {
  51. pp::TCPSocketPrivate socket(instance_);
  52. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  53. callback.WaitForResult(
  54. socket.Connect(host_.c_str(), port_, callback.GetCallback()));
  55. CHECK_CALLBACK_BEHAVIOR(callback);
  56. ASSERT_EQ(PP_OK, callback.result());
  57. ASSERT_TRUE(socket.GetLocalAddress(address));
  58. socket.Disconnect();
  59. PASS();
  60. }
  61. std::string TestUDPSocketPrivate::SetBroadcastOptions(
  62. pp::UDPSocketPrivate* socket) {
  63. int32_t rv = socket->SetSocketFeature(
  64. PP_UDPSOCKETFEATURE_PRIVATE_ADDRESS_REUSE, pp::Var(true));
  65. if (rv != PP_OK)
  66. return ReportError("PPB_UDPSocket_Private::SetSocketFeature", rv);
  67. rv = socket->SetSocketFeature(PP_UDPSOCKETFEATURE_PRIVATE_BROADCAST,
  68. pp::Var(true));
  69. if (rv != PP_OK)
  70. return ReportError("PPB_UDPSocket_Private::SetSocketFeature", rv);
  71. PASS();
  72. }
  73. std::string TestUDPSocketPrivate::BindUDPSocket(
  74. pp::UDPSocketPrivate* socket,
  75. PP_NetAddress_Private* address) {
  76. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  77. callback.WaitForResult(socket->Bind(address, callback.GetCallback()));
  78. CHECK_CALLBACK_BEHAVIOR(callback);
  79. ASSERT_EQ(PP_OK, callback.result());
  80. PASS();
  81. }
  82. std::string TestUDPSocketPrivate::LookupPortAndBindUDPSocket(
  83. pp::UDPSocketPrivate* socket,
  84. PP_NetAddress_Private *address) {
  85. PP_NetAddress_Private base_address;
  86. ASSERT_SUBTEST_SUCCESS(GetLocalAddress(&base_address));
  87. bool is_free_port_found = false;
  88. for (uint16_t port = kPortScanFrom; port < kPortScanTo; ++port) {
  89. if (!pp::NetAddressPrivate::ReplacePort(base_address, port, address))
  90. return "PPB_NetAddress_Private::ReplacePort: Failed";
  91. if (BindUDPSocket(socket, address).empty()) {
  92. is_free_port_found = true;
  93. break;
  94. }
  95. }
  96. if (!is_free_port_found)
  97. return "Can't find available port";
  98. if (!socket->GetBoundAddress(address))
  99. return "PPB_UDPSocket_Private::GetBoundAddress: Failed";
  100. PASS();
  101. }
  102. std::string TestUDPSocketPrivate::BindUDPSocketFailure(
  103. pp::UDPSocketPrivate* socket,
  104. PP_NetAddress_Private *address) {
  105. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  106. callback.WaitForResult(socket->Bind(address, callback.GetCallback()));
  107. CHECK_CALLBACK_BEHAVIOR(callback);
  108. ASSERT_NE(PP_OK, callback.result());
  109. ASSERT_FALSE(socket->GetBoundAddress(address));
  110. PASS();
  111. }
  112. std::string TestUDPSocketPrivate::ReadSocket(pp::UDPSocketPrivate* socket,
  113. PP_NetAddress_Private* address,
  114. size_t size,
  115. std::string* message) {
  116. std::vector<char> buffer(size);
  117. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  118. callback.WaitForResult(
  119. socket->RecvFrom(&buffer[0], static_cast<int32_t>(size),
  120. callback.GetCallback()));
  121. CHECK_CALLBACK_BEHAVIOR(callback);
  122. ASSERT_FALSE(callback.result() < 0);
  123. ASSERT_EQ(size, static_cast<size_t>(callback.result()));
  124. message->assign(buffer.begin(), buffer.end());
  125. PASS();
  126. }
  127. std::string TestUDPSocketPrivate::PassMessage(pp::UDPSocketPrivate* target,
  128. pp::UDPSocketPrivate* source,
  129. PP_NetAddress_Private* address,
  130. const std::string& message) {
  131. TestCompletionCallback callback(instance_->pp_instance(), callback_type());
  132. int32_t rv = source->SendTo(message.c_str(),
  133. static_cast<int32_t>(message.size()), address,
  134. callback.GetCallback());
  135. std::string str;
  136. ASSERT_SUBTEST_SUCCESS(ReadSocket(target, address, message.size(), &str));
  137. callback.WaitForResult(rv);
  138. CHECK_CALLBACK_BEHAVIOR(callback);
  139. ASSERT_FALSE(callback.result() < 0);
  140. ASSERT_EQ(message.size(), static_cast<size_t>(callback.result()));
  141. ASSERT_EQ(message, str);
  142. PASS();
  143. }
  144. std::string TestUDPSocketPrivate::TestConnect() {
  145. pp::UDPSocketPrivate server_socket(instance_), client_socket(instance_);
  146. PP_NetAddress_Private server_address, client_address;
  147. ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&server_socket,
  148. &server_address));
  149. ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&client_socket,
  150. &client_address));
  151. const std::string message = "Simple message that will be sent via UDP";
  152. ASSERT_SUBTEST_SUCCESS(PassMessage(&server_socket, &client_socket,
  153. &server_address,
  154. message));
  155. PP_NetAddress_Private recv_from_address;
  156. ASSERT_TRUE(server_socket.GetRecvFromAddress(&recv_from_address));
  157. ASSERT_TRUE(pp::NetAddressPrivate::AreEqual(recv_from_address,
  158. client_address));
  159. server_socket.Close();
  160. client_socket.Close();
  161. if (server_socket.GetBoundAddress(&server_address))
  162. return "PPB_UDPSocket_Private::GetBoundAddress: expected Failure";
  163. PASS();
  164. }
  165. std::string TestUDPSocketPrivate::TestConnectFailure() {
  166. pp::UDPSocketPrivate socket(instance_);
  167. PP_NetAddress_Private invalid_address = {};
  168. std::string error_message = BindUDPSocketFailure(&socket, &invalid_address);
  169. if (!error_message.empty())
  170. return error_message;
  171. PASS();
  172. }
  173. std::string TestUDPSocketPrivate::TestBroadcast() {
  174. const uint8_t broadcast_ip[4] = { 0xff, 0xff, 0xff, 0xff };
  175. pp::UDPSocketPrivate server1(instance_), server2(instance_);
  176. ASSERT_SUBTEST_SUCCESS(SetBroadcastOptions(&server1));
  177. ASSERT_SUBTEST_SUCCESS(SetBroadcastOptions(&server2));
  178. PP_NetAddress_Private server_address;
  179. ASSERT_TRUE(pp::NetAddressPrivate::GetAnyAddress(false, &server_address));
  180. ASSERT_SUBTEST_SUCCESS(BindUDPSocket(&server1, &server_address));
  181. // Fill port field of |server_address|.
  182. ASSERT_TRUE(server1.GetBoundAddress(&server_address));
  183. ASSERT_SUBTEST_SUCCESS(BindUDPSocket(&server2, &server_address));
  184. const uint16_t port = pp::NetAddressPrivate::GetPort(server_address);
  185. PP_NetAddress_Private broadcast_address;
  186. ASSERT_TRUE(pp::NetAddressPrivate::CreateFromIPv4Address(
  187. broadcast_ip, port, &broadcast_address));
  188. std::string message;
  189. const std::string first_message = "first message";
  190. const std::string second_message = "second_message";
  191. ASSERT_SUBTEST_SUCCESS(PassMessage(&server1, &server2,
  192. &broadcast_address,
  193. first_message));
  194. // |first_message| also arrived to |server2|.
  195. ASSERT_SUBTEST_SUCCESS(ReadSocket(&server2, &broadcast_address,
  196. first_message.size(), &message));
  197. ASSERT_EQ(first_message, message);
  198. ASSERT_SUBTEST_SUCCESS(PassMessage(&server2, &server1,
  199. &broadcast_address,
  200. second_message));
  201. // |second_message| also arrived to |server1|.
  202. ASSERT_SUBTEST_SUCCESS(ReadSocket(&server1, &broadcast_address,
  203. second_message.size(), &message));
  204. ASSERT_EQ(second_message, message);
  205. server1.Close();
  206. server2.Close();
  207. PASS();
  208. }
  209. std::string TestUDPSocketPrivate::TestSetSocketFeatureErrors() {
  210. pp::UDPSocketPrivate socket(instance_);
  211. // Try to pass incorrect feature name.
  212. int32_t rv = socket.SetSocketFeature(PP_UDPSOCKETFEATURE_PRIVATE_COUNT,
  213. pp::Var(true));
  214. ASSERT_EQ(PP_ERROR_BADARGUMENT, rv);
  215. // Try to pass incorrect feature value's type.
  216. rv = socket.SetSocketFeature(PP_UDPSOCKETFEATURE_PRIVATE_ADDRESS_REUSE,
  217. pp::Var(1));
  218. ASSERT_EQ(PP_ERROR_BADARGUMENT, rv);
  219. PASS();
  220. }