1 // Copyright (c) 2011 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 "net/udp/udp_client_socket.h" 6 #include "net/udp/udp_server_socket.h" 7 8 #include "base/basictypes.h" 9 #include "base/metrics/histogram.h" 10 #include "net/base/io_buffer.h" 11 #include "net/base/ip_endpoint.h" 12 #include "net/base/net_errors.h" 13 #include "net/base/net_test_suite.h" 14 #include "net/base/net_util.h" 15 #include "net/base/sys_addrinfo.h" 16 #include "net/base/test_completion_callback.h" 17 #include "testing/gtest/include/gtest/gtest.h" 18 #include "testing/platform_test.h" 19 20 namespace net { 21 22 namespace { 23 24 class UDPSocketTest : public PlatformTest { 25 public: 26 UDPSocketTest() 27 : buffer_(new IOBufferWithSize(kMaxRead)) { 28 } 29 30 // Blocks until data is read from the socket. 31 std::string RecvFromSocket(UDPServerSocket* socket) { 32 TestCompletionCallback callback; 33 34 int rv = socket->RecvFrom(buffer_, kMaxRead, &recv_from_address_, 35 &callback); 36 if (rv == ERR_IO_PENDING) 37 rv = callback.WaitForResult(); 38 if (rv < 0) 39 return ""; // error! 40 return std::string(buffer_->data(), rv); 41 } 42 43 // Loop until |msg| has been written to the socket or until an 44 // error occurs. 45 // If |address| is specified, then it is used for the destination 46 // to send to. Otherwise, will send to the last socket this server 47 // received from. 48 int SendToSocket(UDPServerSocket* socket, std::string msg) { 49 return SendToSocket(socket, msg, recv_from_address_); 50 } 51 52 int SendToSocket(UDPServerSocket* socket, 53 std::string msg, 54 const IPEndPoint& address) { 55 TestCompletionCallback callback; 56 57 int length = msg.length(); 58 scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg)); 59 scoped_refptr<DrainableIOBuffer> buffer( 60 new DrainableIOBuffer(io_buffer, length)); 61 62 int bytes_sent = 0; 63 while (buffer->BytesRemaining()) { 64 int rv = socket->SendTo(buffer, buffer->BytesRemaining(), 65 address, &callback); 66 if (rv == ERR_IO_PENDING) 67 rv = callback.WaitForResult(); 68 if (rv <= 0) 69 return bytes_sent > 0 ? bytes_sent : rv; 70 bytes_sent += rv; 71 buffer->DidConsume(rv); 72 } 73 return bytes_sent; 74 } 75 76 std::string ReadSocket(UDPClientSocket* socket) { 77 TestCompletionCallback callback; 78 79 int rv = socket->Read(buffer_, kMaxRead, &callback); 80 if (rv == ERR_IO_PENDING) 81 rv = callback.WaitForResult(); 82 if (rv < 0) 83 return ""; // error! 84 return std::string(buffer_->data(), rv); 85 } 86 87 // Loop until |msg| has been written to the socket or until an 88 // error occurs. 89 int WriteSocket(UDPClientSocket* socket, std::string msg) { 90 TestCompletionCallback callback; 91 92 int length = msg.length(); 93 scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg)); 94 scoped_refptr<DrainableIOBuffer> buffer( 95 new DrainableIOBuffer(io_buffer, length)); 96 97 int bytes_sent = 0; 98 while (buffer->BytesRemaining()) { 99 int rv = socket->Write(buffer, buffer->BytesRemaining(), &callback); 100 if (rv == ERR_IO_PENDING) 101 rv = callback.WaitForResult(); 102 if (rv <= 0) 103 return bytes_sent > 0 ? bytes_sent : rv; 104 bytes_sent += rv; 105 buffer->DidConsume(rv); 106 } 107 return bytes_sent; 108 } 109 110 protected: 111 static const int kMaxRead = 1024; 112 scoped_refptr<IOBufferWithSize> buffer_; 113 IPEndPoint recv_from_address_; 114 }; 115 116 // Creates and address from an ip/port and returns it in |address|. 117 void CreateUDPAddress(std::string ip_str, int port, IPEndPoint* address) { 118 IPAddressNumber ip_number; 119 bool rv = ParseIPLiteralToNumber(ip_str, &ip_number); 120 if (!rv) 121 return; 122 *address = IPEndPoint(ip_number, port); 123 } 124 125 TEST_F(UDPSocketTest, Connect) { 126 const int kPort = 9999; 127 std::string simple_message("hello world!"); 128 129 // Setup the server to listen. 130 IPEndPoint bind_address; 131 CreateUDPAddress("0.0.0.0", kPort, &bind_address); 132 UDPServerSocket server(NULL, NetLog::Source()); 133 int rv = server.Listen(bind_address); 134 EXPECT_EQ(OK, rv); 135 136 // Setup the client. 137 IPEndPoint server_address; 138 CreateUDPAddress("127.0.0.1", kPort, &server_address); 139 UDPClientSocket client(NULL, NetLog::Source()); 140 rv = client.Connect(server_address); 141 EXPECT_EQ(OK, rv); 142 143 // Client sends to the server. 144 rv = WriteSocket(&client, simple_message); 145 EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv)); 146 147 // Server waits for message. 148 std::string str = RecvFromSocket(&server); 149 DCHECK(simple_message == str); 150 151 // Server echoes reply. 152 rv = SendToSocket(&server, simple_message); 153 EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv)); 154 155 // Client waits for response. 156 str = ReadSocket(&client); 157 DCHECK(simple_message == str); 158 } 159 160 // In this test, we verify that connect() on a socket will have the effect 161 // of filtering reads on this socket only to data read from the destination 162 // we connected to. 163 // 164 // The purpose of this test is that some documentation indicates that connect 165 // binds the client's sends to send to a particular server endpoint, but does 166 // not bind the client's reads to only be from that endpoint, and that we need 167 // to always use recvfrom() to disambiguate. 168 TEST_F(UDPSocketTest, VerifyConnectBindsAddr) { 169 const int kPort1 = 9999; 170 const int kPort2 = 10000; 171 std::string simple_message("hello world!"); 172 std::string foreign_message("BAD MESSAGE TO GET!!"); 173 174 // Setup the first server to listen. 175 IPEndPoint bind_address; 176 CreateUDPAddress("0.0.0.0", kPort1, &bind_address); 177 UDPServerSocket server1(NULL, NetLog::Source()); 178 int rv = server1.Listen(bind_address); 179 EXPECT_EQ(OK, rv); 180 181 // Setup the second server to listen. 182 CreateUDPAddress("0.0.0.0", kPort2, &bind_address); 183 UDPServerSocket server2(NULL, NetLog::Source()); 184 rv = server2.Listen(bind_address); 185 EXPECT_EQ(OK, rv); 186 187 // Setup the client, connected to server 1. 188 IPEndPoint server_address; 189 CreateUDPAddress("127.0.0.1", kPort1, &server_address); 190 UDPClientSocket client(NULL, NetLog::Source()); 191 rv = client.Connect(server_address); 192 EXPECT_EQ(OK, rv); 193 194 // Client sends to server1. 195 rv = WriteSocket(&client, simple_message); 196 EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv)); 197 198 // Server1 waits for message. 199 std::string str = RecvFromSocket(&server1); 200 DCHECK(simple_message == str); 201 202 // Get the client's address. 203 IPEndPoint client_address; 204 rv = client.GetLocalAddress(&client_address); 205 EXPECT_EQ(OK, rv); 206 207 // Server2 sends reply. 208 rv = SendToSocket(&server2, foreign_message, 209 client_address); 210 EXPECT_EQ(foreign_message.length(), static_cast<size_t>(rv)); 211 212 // Server1 sends reply. 213 rv = SendToSocket(&server1, simple_message, 214 client_address); 215 EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv)); 216 217 // Client waits for response. 218 str = ReadSocket(&client); 219 DCHECK(simple_message == str); 220 } 221 222 TEST_F(UDPSocketTest, ClientGetLocalPeerAddresses) { 223 struct TestData { 224 std::string remote_address; 225 std::string local_address; 226 bool may_fail; 227 } tests[] = { 228 { "127.0.00.1", "127.0.0.1", false }, 229 { "192.168.1.1", "127.0.0.1", false }, 230 { "::1", "::1", true }, 231 { "2001:db8:0::42", "::1", true }, 232 }; 233 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) { 234 SCOPED_TRACE(std::string("Connecting from ") + tests[i].local_address + 235 std::string(" to ") + tests[i].remote_address); 236 237 net::IPAddressNumber ip_number; 238 net::ParseIPLiteralToNumber(tests[i].remote_address, &ip_number); 239 net::IPEndPoint remote_address(ip_number, 80); 240 net::ParseIPLiteralToNumber(tests[i].local_address, &ip_number); 241 net::IPEndPoint local_address(ip_number, 80); 242 243 UDPClientSocket client(NULL, NetLog::Source()); 244 int rv = client.Connect(remote_address); 245 if (tests[i].may_fail && rv == ERR_ADDRESS_UNREACHABLE) { 246 // Connect() may return ERR_ADDRESS_UNREACHABLE for IPv6 247 // addresses if IPv6 is not configured. 248 continue; 249 } 250 251 EXPECT_LE(ERR_IO_PENDING, rv); 252 253 IPEndPoint fetched_local_address; 254 rv = client.GetLocalAddress(&fetched_local_address); 255 EXPECT_EQ(OK, rv); 256 257 // TODO(mbelshe): figure out how to verify the IP and port. 258 // The port is dynamically generated by the udp stack. 259 // The IP is the real IP of the client, not necessarily 260 // loopback. 261 //EXPECT_EQ(local_address.address(), fetched_local_address.address()); 262 263 IPEndPoint fetched_remote_address; 264 rv = client.GetPeerAddress(&fetched_remote_address); 265 EXPECT_EQ(OK, rv); 266 267 EXPECT_EQ(remote_address, fetched_remote_address); 268 } 269 } 270 271 TEST_F(UDPSocketTest, ServerGetLocalAddress) { 272 IPEndPoint bind_address; 273 CreateUDPAddress("127.0.0.1", 0, &bind_address); 274 UDPServerSocket server(NULL, NetLog::Source()); 275 int rv = server.Listen(bind_address); 276 EXPECT_EQ(OK, rv); 277 278 IPEndPoint local_address; 279 rv = server.GetLocalAddress(&local_address); 280 EXPECT_EQ(rv, 0); 281 282 // Verify that port was allocated. 283 EXPECT_GT(local_address.port(), 0); 284 EXPECT_EQ(local_address.address(), bind_address.address()); 285 } 286 287 TEST_F(UDPSocketTest, ServerGetPeerAddress) { 288 IPEndPoint bind_address; 289 CreateUDPAddress("127.0.0.1", 0, &bind_address); 290 UDPServerSocket server(NULL, NetLog::Source()); 291 int rv = server.Listen(bind_address); 292 EXPECT_EQ(OK, rv); 293 294 IPEndPoint peer_address; 295 rv = server.GetPeerAddress(&peer_address); 296 EXPECT_EQ(rv, ERR_SOCKET_NOT_CONNECTED); 297 } 298 299 // Close the socket while read is pending. 300 TEST_F(UDPSocketTest, CloseWithPendingRead) { 301 IPEndPoint bind_address; 302 CreateUDPAddress("127.0.0.1", 0, &bind_address); 303 UDPServerSocket server(NULL, NetLog::Source()); 304 int rv = server.Listen(bind_address); 305 EXPECT_EQ(OK, rv); 306 307 TestCompletionCallback callback; 308 IPEndPoint from; 309 rv = server.RecvFrom(buffer_, kMaxRead, &from, &callback); 310 EXPECT_EQ(rv, ERR_IO_PENDING); 311 312 server.Close(); 313 314 EXPECT_FALSE(callback.have_result()); 315 } 316 317 } // namespace 318 319 } // namespace net 320
