OLD | NEW |
| (Empty) |
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 "net/socket/tcp_socket.h" | |
6 | |
7 #include <string.h> | |
8 | |
9 #include <string> | |
10 #include <vector> | |
11 | |
12 #include "base/basictypes.h" | |
13 #include "base/memory/ref_counted.h" | |
14 #include "base/memory/scoped_ptr.h" | |
15 #include "net/base/address_list.h" | |
16 #include "net/base/io_buffer.h" | |
17 #include "net/base/ip_endpoint.h" | |
18 #include "net/base/net_errors.h" | |
19 #include "net/base/test_completion_callback.h" | |
20 #include "net/socket/tcp_client_socket.h" | |
21 #include "testing/gtest/include/gtest/gtest.h" | |
22 #include "testing/platform_test.h" | |
23 | |
24 namespace net { | |
25 | |
26 namespace { | |
27 const int kListenBacklog = 5; | |
28 | |
29 class TCPSocketTest : public PlatformTest { | |
30 protected: | |
31 TCPSocketTest() : socket_(NULL, NetLog::Source()) { | |
32 } | |
33 | |
34 void SetUpListenIPv4() { | |
35 IPEndPoint address; | |
36 ParseAddress("127.0.0.1", 0, &address); | |
37 | |
38 ASSERT_EQ(OK, socket_.Open(ADDRESS_FAMILY_IPV4)); | |
39 ASSERT_EQ(OK, socket_.Bind(address)); | |
40 ASSERT_EQ(OK, socket_.Listen(kListenBacklog)); | |
41 ASSERT_EQ(OK, socket_.GetLocalAddress(&local_address_)); | |
42 } | |
43 | |
44 void SetUpListenIPv6(bool* success) { | |
45 *success = false; | |
46 IPEndPoint address; | |
47 ParseAddress("::1", 0, &address); | |
48 | |
49 if (socket_.Open(ADDRESS_FAMILY_IPV6) != OK || | |
50 socket_.Bind(address) != OK || | |
51 socket_.Listen(kListenBacklog) != OK) { | |
52 LOG(ERROR) << "Failed to listen on ::1 - probably because IPv6 is " | |
53 "disabled. Skipping the test"; | |
54 return; | |
55 } | |
56 ASSERT_EQ(OK, socket_.GetLocalAddress(&local_address_)); | |
57 *success = true; | |
58 } | |
59 | |
60 void ParseAddress(const std::string& ip_str, | |
61 uint16 port, | |
62 IPEndPoint* address) { | |
63 IPAddressNumber ip_number; | |
64 bool rv = ParseIPLiteralToNumber(ip_str, &ip_number); | |
65 if (!rv) | |
66 return; | |
67 *address = IPEndPoint(ip_number, port); | |
68 } | |
69 | |
70 void TestAcceptAsync() { | |
71 TestCompletionCallback accept_callback; | |
72 scoped_ptr<TCPSocket> accepted_socket; | |
73 IPEndPoint accepted_address; | |
74 ASSERT_EQ(ERR_IO_PENDING, | |
75 socket_.Accept(&accepted_socket, &accepted_address, | |
76 accept_callback.callback())); | |
77 | |
78 TestCompletionCallback connect_callback; | |
79 TCPClientSocket connecting_socket(local_address_list(), | |
80 NULL, NetLog::Source()); | |
81 connecting_socket.Connect(connect_callback.callback()); | |
82 | |
83 EXPECT_EQ(OK, connect_callback.WaitForResult()); | |
84 EXPECT_EQ(OK, accept_callback.WaitForResult()); | |
85 | |
86 EXPECT_TRUE(accepted_socket.get()); | |
87 | |
88 // Both sockets should be on the loopback network interface. | |
89 EXPECT_EQ(accepted_address.address(), local_address_.address()); | |
90 } | |
91 | |
92 AddressList local_address_list() const { | |
93 return AddressList(local_address_); | |
94 } | |
95 | |
96 TCPSocket socket_; | |
97 IPEndPoint local_address_; | |
98 }; | |
99 | |
100 // Test listening and accepting with a socket bound to an IPv4 address. | |
101 TEST_F(TCPSocketTest, Accept) { | |
102 ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4()); | |
103 | |
104 TestCompletionCallback connect_callback; | |
105 // TODO(yzshen): Switch to use TCPSocket when it supports client socket | |
106 // operations. | |
107 TCPClientSocket connecting_socket(local_address_list(), | |
108 NULL, NetLog::Source()); | |
109 connecting_socket.Connect(connect_callback.callback()); | |
110 | |
111 TestCompletionCallback accept_callback; | |
112 scoped_ptr<TCPSocket> accepted_socket; | |
113 IPEndPoint accepted_address; | |
114 int result = socket_.Accept(&accepted_socket, &accepted_address, | |
115 accept_callback.callback()); | |
116 if (result == ERR_IO_PENDING) | |
117 result = accept_callback.WaitForResult(); | |
118 ASSERT_EQ(OK, result); | |
119 | |
120 EXPECT_TRUE(accepted_socket.get()); | |
121 | |
122 // Both sockets should be on the loopback network interface. | |
123 EXPECT_EQ(accepted_address.address(), local_address_.address()); | |
124 | |
125 EXPECT_EQ(OK, connect_callback.WaitForResult()); | |
126 } | |
127 | |
128 // Test Accept() callback. | |
129 TEST_F(TCPSocketTest, AcceptAsync) { | |
130 ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4()); | |
131 TestAcceptAsync(); | |
132 } | |
133 | |
134 #if defined(OS_WIN) | |
135 // Test Accept() for AdoptListenSocket. | |
136 TEST_F(TCPSocketTest, AcceptForAdoptedListenSocket) { | |
137 // Create a socket to be used with AdoptListenSocket. | |
138 SOCKET existing_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); | |
139 ASSERT_EQ(OK, socket_.AdoptListenSocket(existing_socket)); | |
140 | |
141 IPEndPoint address; | |
142 ParseAddress("127.0.0.1", 0, &address); | |
143 SockaddrStorage storage; | |
144 ASSERT_TRUE(address.ToSockAddr(storage.addr, &storage.addr_len)); | |
145 ASSERT_EQ(0, bind(existing_socket, storage.addr, storage.addr_len)); | |
146 | |
147 ASSERT_EQ(OK, socket_.Listen(kListenBacklog)); | |
148 ASSERT_EQ(OK, socket_.GetLocalAddress(&local_address_)); | |
149 | |
150 TestAcceptAsync(); | |
151 } | |
152 #endif | |
153 | |
154 // Accept two connections simultaneously. | |
155 TEST_F(TCPSocketTest, Accept2Connections) { | |
156 ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4()); | |
157 | |
158 TestCompletionCallback accept_callback; | |
159 scoped_ptr<TCPSocket> accepted_socket; | |
160 IPEndPoint accepted_address; | |
161 | |
162 ASSERT_EQ(ERR_IO_PENDING, | |
163 socket_.Accept(&accepted_socket, &accepted_address, | |
164 accept_callback.callback())); | |
165 | |
166 TestCompletionCallback connect_callback; | |
167 TCPClientSocket connecting_socket(local_address_list(), | |
168 NULL, NetLog::Source()); | |
169 connecting_socket.Connect(connect_callback.callback()); | |
170 | |
171 TestCompletionCallback connect_callback2; | |
172 TCPClientSocket connecting_socket2(local_address_list(), | |
173 NULL, NetLog::Source()); | |
174 connecting_socket2.Connect(connect_callback2.callback()); | |
175 | |
176 EXPECT_EQ(OK, accept_callback.WaitForResult()); | |
177 | |
178 TestCompletionCallback accept_callback2; | |
179 scoped_ptr<TCPSocket> accepted_socket2; | |
180 IPEndPoint accepted_address2; | |
181 | |
182 int result = socket_.Accept(&accepted_socket2, &accepted_address2, | |
183 accept_callback2.callback()); | |
184 if (result == ERR_IO_PENDING) | |
185 result = accept_callback2.WaitForResult(); | |
186 ASSERT_EQ(OK, result); | |
187 | |
188 EXPECT_EQ(OK, connect_callback.WaitForResult()); | |
189 EXPECT_EQ(OK, connect_callback2.WaitForResult()); | |
190 | |
191 EXPECT_TRUE(accepted_socket.get()); | |
192 EXPECT_TRUE(accepted_socket2.get()); | |
193 EXPECT_NE(accepted_socket.get(), accepted_socket2.get()); | |
194 | |
195 EXPECT_EQ(accepted_address.address(), local_address_.address()); | |
196 EXPECT_EQ(accepted_address2.address(), local_address_.address()); | |
197 } | |
198 | |
199 // Test listening and accepting with a socket bound to an IPv6 address. | |
200 TEST_F(TCPSocketTest, AcceptIPv6) { | |
201 bool initialized = false; | |
202 ASSERT_NO_FATAL_FAILURE(SetUpListenIPv6(&initialized)); | |
203 if (!initialized) | |
204 return; | |
205 | |
206 TestCompletionCallback connect_callback; | |
207 TCPClientSocket connecting_socket(local_address_list(), | |
208 NULL, NetLog::Source()); | |
209 connecting_socket.Connect(connect_callback.callback()); | |
210 | |
211 TestCompletionCallback accept_callback; | |
212 scoped_ptr<TCPSocket> accepted_socket; | |
213 IPEndPoint accepted_address; | |
214 int result = socket_.Accept(&accepted_socket, &accepted_address, | |
215 accept_callback.callback()); | |
216 if (result == ERR_IO_PENDING) | |
217 result = accept_callback.WaitForResult(); | |
218 ASSERT_EQ(OK, result); | |
219 | |
220 EXPECT_TRUE(accepted_socket.get()); | |
221 | |
222 // Both sockets should be on the loopback network interface. | |
223 EXPECT_EQ(accepted_address.address(), local_address_.address()); | |
224 | |
225 EXPECT_EQ(OK, connect_callback.WaitForResult()); | |
226 } | |
227 | |
228 TEST_F(TCPSocketTest, ReadWrite) { | |
229 ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4()); | |
230 | |
231 TestCompletionCallback connect_callback; | |
232 TCPSocket connecting_socket(NULL, NetLog::Source()); | |
233 int result = connecting_socket.Open(ADDRESS_FAMILY_IPV4); | |
234 ASSERT_EQ(OK, result); | |
235 connecting_socket.Connect(local_address_, connect_callback.callback()); | |
236 | |
237 TestCompletionCallback accept_callback; | |
238 scoped_ptr<TCPSocket> accepted_socket; | |
239 IPEndPoint accepted_address; | |
240 result = socket_.Accept(&accepted_socket, &accepted_address, | |
241 accept_callback.callback()); | |
242 ASSERT_EQ(OK, accept_callback.GetResult(result)); | |
243 | |
244 ASSERT_TRUE(accepted_socket.get()); | |
245 | |
246 // Both sockets should be on the loopback network interface. | |
247 EXPECT_EQ(accepted_address.address(), local_address_.address()); | |
248 | |
249 EXPECT_EQ(OK, connect_callback.WaitForResult()); | |
250 | |
251 const std::string message("test message"); | |
252 std::vector<char> buffer(message.size()); | |
253 | |
254 size_t bytes_written = 0; | |
255 while (bytes_written < message.size()) { | |
256 scoped_refptr<IOBufferWithSize> write_buffer( | |
257 new IOBufferWithSize(message.size() - bytes_written)); | |
258 memmove(write_buffer->data(), message.data() + bytes_written, | |
259 message.size() - bytes_written); | |
260 | |
261 TestCompletionCallback write_callback; | |
262 int write_result = accepted_socket->Write( | |
263 write_buffer.get(), write_buffer->size(), write_callback.callback()); | |
264 write_result = write_callback.GetResult(write_result); | |
265 ASSERT_TRUE(write_result >= 0); | |
266 bytes_written += write_result; | |
267 ASSERT_TRUE(bytes_written <= message.size()); | |
268 } | |
269 | |
270 size_t bytes_read = 0; | |
271 while (bytes_read < message.size()) { | |
272 scoped_refptr<IOBufferWithSize> read_buffer( | |
273 new IOBufferWithSize(message.size() - bytes_read)); | |
274 TestCompletionCallback read_callback; | |
275 int read_result = connecting_socket.Read( | |
276 read_buffer.get(), read_buffer->size(), read_callback.callback()); | |
277 read_result = read_callback.GetResult(read_result); | |
278 ASSERT_TRUE(read_result >= 0); | |
279 ASSERT_TRUE(bytes_read + read_result <= message.size()); | |
280 memmove(&buffer[bytes_read], read_buffer->data(), read_result); | |
281 bytes_read += read_result; | |
282 } | |
283 | |
284 std::string received_message(buffer.begin(), buffer.end()); | |
285 ASSERT_EQ(message, received_message); | |
286 } | |
287 | |
288 } // namespace | |
289 } // namespace net | |
OLD | NEW |