OLD | NEW |
1 // Copyright (c) 2009 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2009 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/socket/socks_client_socket.h" | 5 #include "net/socket/socks_client_socket.h" |
6 | 6 |
7 #include "net/base/address_list.h" | 7 #include "net/base/address_list.h" |
8 #include "net/base/load_log.h" | 8 #include "net/base/net_log.h" |
9 #include "net/base/load_log_unittest.h" | 9 #include "net/base/net_log_unittest.h" |
10 #include "net/base/mock_host_resolver.h" | 10 #include "net/base/mock_host_resolver.h" |
11 #include "net/base/test_completion_callback.h" | 11 #include "net/base/test_completion_callback.h" |
12 #include "net/base/winsock_init.h" | 12 #include "net/base/winsock_init.h" |
13 #include "net/socket/client_socket_factory.h" | 13 #include "net/socket/client_socket_factory.h" |
14 #include "net/socket/tcp_client_socket.h" | 14 #include "net/socket/tcp_client_socket.h" |
15 #include "net/socket/socket_test_util.h" | 15 #include "net/socket/socket_test_util.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
17 #include "testing/platform_test.h" | 17 #include "testing/platform_test.h" |
18 | 18 |
19 //----------------------------------------------------------------------------- | 19 //----------------------------------------------------------------------------- |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
85 // We use this in the test "DisconnectWhileHostResolveInProgress" to make | 85 // We use this in the test "DisconnectWhileHostResolveInProgress" to make |
86 // sure that the outstanding resolve request gets cancelled. | 86 // sure that the outstanding resolve request gets cancelled. |
87 class HangingHostResolver : public HostResolver { | 87 class HangingHostResolver : public HostResolver { |
88 public: | 88 public: |
89 HangingHostResolver() : outstanding_request_(NULL) {} | 89 HangingHostResolver() : outstanding_request_(NULL) {} |
90 | 90 |
91 virtual int Resolve(const RequestInfo& info, | 91 virtual int Resolve(const RequestInfo& info, |
92 AddressList* addresses, | 92 AddressList* addresses, |
93 CompletionCallback* callback, | 93 CompletionCallback* callback, |
94 RequestHandle* out_req, | 94 RequestHandle* out_req, |
95 LoadLog* load_log) { | 95 const BoundNetLog& net_log) { |
96 EXPECT_FALSE(HasOutstandingRequest()); | 96 EXPECT_FALSE(HasOutstandingRequest()); |
97 outstanding_request_ = reinterpret_cast<RequestHandle>(1); | 97 outstanding_request_ = reinterpret_cast<RequestHandle>(1); |
98 *out_req = outstanding_request_; | 98 *out_req = outstanding_request_; |
99 return ERR_IO_PENDING; | 99 return ERR_IO_PENDING; |
100 } | 100 } |
101 | 101 |
102 virtual void CancelRequest(RequestHandle req) { | 102 virtual void CancelRequest(RequestHandle req) { |
103 EXPECT_TRUE(HasOutstandingRequest()); | 103 EXPECT_TRUE(HasOutstandingRequest()); |
104 EXPECT_EQ(outstanding_request_, req); | 104 EXPECT_EQ(outstanding_request_, req); |
105 outstanding_request_ = NULL; | 105 outstanding_request_ = NULL; |
(...skipping 25 matching lines...) Expand all Loading... |
131 MockRead(true, payload_read.data(), payload_read.size()) }; | 131 MockRead(true, payload_read.data(), payload_read.size()) }; |
132 | 132 |
133 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 133 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
134 data_writes, arraysize(data_writes), | 134 data_writes, arraysize(data_writes), |
135 host_resolver_, "localhost", 80)); | 135 host_resolver_, "localhost", 80)); |
136 | 136 |
137 // At this state the TCP connection is completed but not the SOCKS handshake. | 137 // At this state the TCP connection is completed but not the SOCKS handshake. |
138 EXPECT_TRUE(tcp_sock_->IsConnected()); | 138 EXPECT_TRUE(tcp_sock_->IsConnected()); |
139 EXPECT_FALSE(user_sock_->IsConnected()); | 139 EXPECT_FALSE(user_sock_->IsConnected()); |
140 | 140 |
141 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 141 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
142 int rv = user_sock_->Connect(&callback_, log); | 142 int rv = user_sock_->Connect(&callback_, log.bound()); |
143 EXPECT_EQ(ERR_IO_PENDING, rv); | 143 EXPECT_EQ(ERR_IO_PENDING, rv); |
144 EXPECT_TRUE( | 144 EXPECT_TRUE( |
145 LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT)); | 145 LogContainsBeginEvent(log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT)); |
146 EXPECT_FALSE(user_sock_->IsConnected()); | 146 EXPECT_FALSE(user_sock_->IsConnected()); |
147 rv = callback_.WaitForResult(); | 147 rv = callback_.WaitForResult(); |
148 | 148 |
149 EXPECT_EQ(OK, rv); | 149 EXPECT_EQ(OK, rv); |
150 EXPECT_TRUE(user_sock_->IsConnected()); | 150 EXPECT_TRUE(user_sock_->IsConnected()); |
151 EXPECT_EQ(SOCKSClientSocket::kSOCKS4, user_sock_->socks_version_); | 151 EXPECT_EQ(SOCKSClientSocket::kSOCKS4, user_sock_->socks_version_); |
152 EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT)); | 152 EXPECT_TRUE(LogContainsEndEvent( |
| 153 log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT)); |
153 | 154 |
154 scoped_refptr<IOBuffer> buffer = new IOBuffer(payload_write.size()); | 155 scoped_refptr<IOBuffer> buffer = new IOBuffer(payload_write.size()); |
155 memcpy(buffer->data(), payload_write.data(), payload_write.size()); | 156 memcpy(buffer->data(), payload_write.data(), payload_write.size()); |
156 rv = user_sock_->Write(buffer, payload_write.size(), &callback_); | 157 rv = user_sock_->Write(buffer, payload_write.size(), &callback_); |
157 EXPECT_EQ(ERR_IO_PENDING, rv); | 158 EXPECT_EQ(ERR_IO_PENDING, rv); |
158 rv = callback_.WaitForResult(); | 159 rv = callback_.WaitForResult(); |
159 EXPECT_EQ(static_cast<int>(payload_write.size()), rv); | 160 EXPECT_EQ(static_cast<int>(payload_write.size()), rv); |
160 | 161 |
161 buffer = new IOBuffer(payload_read.size()); | 162 buffer = new IOBuffer(payload_read.size()); |
162 rv = user_sock_->Read(buffer, payload_read.size(), &callback_); | 163 rv = user_sock_->Read(buffer, payload_read.size(), &callback_); |
(...skipping 30 matching lines...) Expand all Loading... |
193 | 194 |
194 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) { | 195 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) { |
195 MockWrite data_writes[] = { | 196 MockWrite data_writes[] = { |
196 MockWrite(false, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; | 197 MockWrite(false, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; |
197 MockRead data_reads[] = { | 198 MockRead data_reads[] = { |
198 MockRead(false, tests[i].fail_reply, arraysize(tests[i].fail_reply)) }; | 199 MockRead(false, tests[i].fail_reply, arraysize(tests[i].fail_reply)) }; |
199 | 200 |
200 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 201 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
201 data_writes, arraysize(data_writes), | 202 data_writes, arraysize(data_writes), |
202 host_resolver_, "localhost", 80)); | 203 host_resolver_, "localhost", 80)); |
203 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 204 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
204 | 205 |
205 int rv = user_sock_->Connect(&callback_, log); | 206 int rv = user_sock_->Connect(&callback_, log.bound()); |
206 EXPECT_EQ(ERR_IO_PENDING, rv); | 207 EXPECT_EQ(ERR_IO_PENDING, rv); |
207 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT)); | 208 EXPECT_TRUE(LogContainsBeginEvent( |
| 209 log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT)); |
208 rv = callback_.WaitForResult(); | 210 rv = callback_.WaitForResult(); |
209 EXPECT_EQ(tests[i].fail_code, rv); | 211 EXPECT_EQ(tests[i].fail_code, rv); |
210 EXPECT_FALSE(user_sock_->IsConnected()); | 212 EXPECT_FALSE(user_sock_->IsConnected()); |
211 EXPECT_TRUE(tcp_sock_->IsConnected()); | 213 EXPECT_TRUE(tcp_sock_->IsConnected()); |
212 EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT)); | 214 EXPECT_TRUE(LogContainsEndEvent( |
| 215 log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT)); |
213 } | 216 } |
214 } | 217 } |
215 | 218 |
216 // Tests scenario when the server sends the handshake response in | 219 // Tests scenario when the server sends the handshake response in |
217 // more than one packet. | 220 // more than one packet. |
218 TEST_F(SOCKSClientSocketTest, PartialServerReads) { | 221 TEST_F(SOCKSClientSocketTest, PartialServerReads) { |
219 const char kSOCKSPartialReply1[] = { 0x00 }; | 222 const char kSOCKSPartialReply1[] = { 0x00 }; |
220 const char kSOCKSPartialReply2[] = { 0x5A, 0x00, 0x00, 0, 0, 0, 0 }; | 223 const char kSOCKSPartialReply2[] = { 0x5A, 0x00, 0x00, 0, 0, 0, 0 }; |
221 | 224 |
222 MockWrite data_writes[] = { | 225 MockWrite data_writes[] = { |
223 MockWrite(true, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; | 226 MockWrite(true, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; |
224 MockRead data_reads[] = { | 227 MockRead data_reads[] = { |
225 MockRead(true, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)), | 228 MockRead(true, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)), |
226 MockRead(true, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) }; | 229 MockRead(true, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) }; |
227 | 230 |
228 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 231 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
229 data_writes, arraysize(data_writes), | 232 data_writes, arraysize(data_writes), |
230 host_resolver_, "localhost", 80)); | 233 host_resolver_, "localhost", 80)); |
231 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 234 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
232 | 235 |
233 int rv = user_sock_->Connect(&callback_, log); | 236 |
| 237 int rv = user_sock_->Connect(&callback_, log.bound()); |
234 EXPECT_EQ(ERR_IO_PENDING, rv); | 238 EXPECT_EQ(ERR_IO_PENDING, rv); |
235 EXPECT_TRUE(LogContainsBeginEvent( | 239 EXPECT_TRUE(LogContainsBeginEvent( |
236 *log, 0, LoadLog::TYPE_SOCKS_CONNECT)); | 240 log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT)); |
237 rv = callback_.WaitForResult(); | 241 rv = callback_.WaitForResult(); |
238 EXPECT_EQ(OK, rv); | 242 EXPECT_EQ(OK, rv); |
239 EXPECT_TRUE(user_sock_->IsConnected()); | 243 EXPECT_TRUE(user_sock_->IsConnected()); |
240 EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT)); | 244 EXPECT_TRUE(LogContainsEndEvent( |
| 245 log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT)); |
241 } | 246 } |
242 | 247 |
243 // Tests scenario when the client sends the handshake request in | 248 // Tests scenario when the client sends the handshake request in |
244 // more than one packet. | 249 // more than one packet. |
245 TEST_F(SOCKSClientSocketTest, PartialClientWrites) { | 250 TEST_F(SOCKSClientSocketTest, PartialClientWrites) { |
246 const char kSOCKSPartialRequest1[] = { 0x04, 0x01 }; | 251 const char kSOCKSPartialRequest1[] = { 0x04, 0x01 }; |
247 const char kSOCKSPartialRequest2[] = { 0x00, 0x50, 127, 0, 0, 1, 0 }; | 252 const char kSOCKSPartialRequest2[] = { 0x00, 0x50, 127, 0, 0, 1, 0 }; |
248 | 253 |
249 MockWrite data_writes[] = { | 254 MockWrite data_writes[] = { |
250 MockWrite(true, arraysize(kSOCKSPartialRequest1)), | 255 MockWrite(true, arraysize(kSOCKSPartialRequest1)), |
251 // simulate some empty writes | 256 // simulate some empty writes |
252 MockWrite(true, 0), | 257 MockWrite(true, 0), |
253 MockWrite(true, 0), | 258 MockWrite(true, 0), |
254 MockWrite(true, kSOCKSPartialRequest2, | 259 MockWrite(true, kSOCKSPartialRequest2, |
255 arraysize(kSOCKSPartialRequest2)) }; | 260 arraysize(kSOCKSPartialRequest2)) }; |
256 MockRead data_reads[] = { | 261 MockRead data_reads[] = { |
257 MockRead(true, kSOCKSOkReply, arraysize(kSOCKSOkReply)) }; | 262 MockRead(true, kSOCKSOkReply, arraysize(kSOCKSOkReply)) }; |
258 | 263 |
259 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 264 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
260 data_writes, arraysize(data_writes), | 265 data_writes, arraysize(data_writes), |
261 host_resolver_, "localhost", 80)); | 266 host_resolver_, "localhost", 80)); |
262 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 267 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
263 | 268 |
264 int rv = user_sock_->Connect(&callback_, log); | 269 int rv = user_sock_->Connect(&callback_, log.bound()); |
265 EXPECT_EQ(ERR_IO_PENDING, rv); | 270 EXPECT_EQ(ERR_IO_PENDING, rv); |
266 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT)); | 271 EXPECT_TRUE(LogContainsBeginEvent( |
| 272 log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT)); |
267 rv = callback_.WaitForResult(); | 273 rv = callback_.WaitForResult(); |
268 EXPECT_EQ(OK, rv); | 274 EXPECT_EQ(OK, rv); |
269 EXPECT_TRUE(user_sock_->IsConnected()); | 275 EXPECT_TRUE(user_sock_->IsConnected()); |
270 EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT)); | 276 EXPECT_TRUE(LogContainsEndEvent( |
| 277 log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT)); |
271 } | 278 } |
272 | 279 |
273 // Tests the case when the server sends a smaller sized handshake data | 280 // Tests the case when the server sends a smaller sized handshake data |
274 // and closes the connection. | 281 // and closes the connection. |
275 TEST_F(SOCKSClientSocketTest, FailedSocketRead) { | 282 TEST_F(SOCKSClientSocketTest, FailedSocketRead) { |
276 MockWrite data_writes[] = { | 283 MockWrite data_writes[] = { |
277 MockWrite(true, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; | 284 MockWrite(true, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) }; |
278 MockRead data_reads[] = { | 285 MockRead data_reads[] = { |
279 MockRead(true, kSOCKSOkReply, arraysize(kSOCKSOkReply) - 2), | 286 MockRead(true, kSOCKSOkReply, arraysize(kSOCKSOkReply) - 2), |
280 // close connection unexpectedly | 287 // close connection unexpectedly |
281 MockRead(false, 0) }; | 288 MockRead(false, 0) }; |
282 | 289 |
283 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 290 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
284 data_writes, arraysize(data_writes), | 291 data_writes, arraysize(data_writes), |
285 host_resolver_, "localhost", 80)); | 292 host_resolver_, "localhost", 80)); |
286 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 293 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
287 | 294 |
288 int rv = user_sock_->Connect(&callback_, log); | 295 |
| 296 int rv = user_sock_->Connect(&callback_, log.bound()); |
289 EXPECT_EQ(ERR_IO_PENDING, rv); | 297 EXPECT_EQ(ERR_IO_PENDING, rv); |
290 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT)); | 298 EXPECT_TRUE(LogContainsBeginEvent( |
| 299 log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT)); |
291 rv = callback_.WaitForResult(); | 300 rv = callback_.WaitForResult(); |
292 EXPECT_EQ(ERR_CONNECTION_CLOSED, rv); | 301 EXPECT_EQ(ERR_CONNECTION_CLOSED, rv); |
293 EXPECT_FALSE(user_sock_->IsConnected()); | 302 EXPECT_FALSE(user_sock_->IsConnected()); |
294 EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT)); | 303 EXPECT_TRUE(LogContainsEndEvent( |
| 304 log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT)); |
295 } | 305 } |
296 | 306 |
297 // Tries to connect to an unknown DNS and on failure should revert to SOCKS4A. | 307 // Tries to connect to an unknown DNS and on failure should revert to SOCKS4A. |
298 TEST_F(SOCKSClientSocketTest, SOCKS4AFailedDNS) { | 308 TEST_F(SOCKSClientSocketTest, SOCKS4AFailedDNS) { |
299 const char hostname[] = "unresolved.ipv4.address"; | 309 const char hostname[] = "unresolved.ipv4.address"; |
300 | 310 |
301 host_resolver_->rules()->AddSimulatedFailure(hostname); | 311 host_resolver_->rules()->AddSimulatedFailure(hostname); |
302 | 312 |
303 std::string request(kSOCKS4aInitialRequest, | 313 std::string request(kSOCKS4aInitialRequest, |
304 arraysize(kSOCKS4aInitialRequest)); | 314 arraysize(kSOCKS4aInitialRequest)); |
305 request.append(hostname, arraysize(hostname)); | 315 request.append(hostname, arraysize(hostname)); |
306 | 316 |
307 MockWrite data_writes[] = { | 317 MockWrite data_writes[] = { |
308 MockWrite(false, request.data(), request.size()) }; | 318 MockWrite(false, request.data(), request.size()) }; |
309 MockRead data_reads[] = { | 319 MockRead data_reads[] = { |
310 MockRead(false, kSOCKSOkReply, arraysize(kSOCKSOkReply)) }; | 320 MockRead(false, kSOCKSOkReply, arraysize(kSOCKSOkReply)) }; |
311 | 321 |
312 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 322 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
313 data_writes, arraysize(data_writes), | 323 data_writes, arraysize(data_writes), |
314 host_resolver_, hostname, 80)); | 324 host_resolver_, hostname, 80)); |
315 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 325 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
316 | 326 |
317 int rv = user_sock_->Connect(&callback_, log); | 327 int rv = user_sock_->Connect(&callback_, log.bound()); |
318 EXPECT_EQ(ERR_IO_PENDING, rv); | 328 EXPECT_EQ(ERR_IO_PENDING, rv); |
319 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT)); | 329 EXPECT_TRUE(LogContainsBeginEvent( |
| 330 log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT)); |
320 rv = callback_.WaitForResult(); | 331 rv = callback_.WaitForResult(); |
321 EXPECT_EQ(OK, rv); | 332 EXPECT_EQ(OK, rv); |
322 EXPECT_TRUE(user_sock_->IsConnected()); | 333 EXPECT_TRUE(user_sock_->IsConnected()); |
323 EXPECT_EQ(SOCKSClientSocket::kSOCKS4a, user_sock_->socks_version_); | 334 EXPECT_EQ(SOCKSClientSocket::kSOCKS4a, user_sock_->socks_version_); |
324 EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT)); | 335 EXPECT_TRUE(LogContainsEndEvent( |
| 336 log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT)); |
325 } | 337 } |
326 | 338 |
327 // Tries to connect to a domain that resolves to IPv6. | 339 // Tries to connect to a domain that resolves to IPv6. |
328 // Should revert to SOCKS4a. | 340 // Should revert to SOCKS4a. |
329 TEST_F(SOCKSClientSocketTest, SOCKS4AIfDomainInIPv6) { | 341 TEST_F(SOCKSClientSocketTest, SOCKS4AIfDomainInIPv6) { |
330 const char hostname[] = "an.ipv6.address"; | 342 const char hostname[] = "an.ipv6.address"; |
331 | 343 |
332 host_resolver_->rules()->AddIPv6Rule(hostname, "2001:db8:8714:3a90::12"); | 344 host_resolver_->rules()->AddIPv6Rule(hostname, "2001:db8:8714:3a90::12"); |
333 | 345 |
334 std::string request(kSOCKS4aInitialRequest, | 346 std::string request(kSOCKS4aInitialRequest, |
335 arraysize(kSOCKS4aInitialRequest)); | 347 arraysize(kSOCKS4aInitialRequest)); |
336 request.append(hostname, arraysize(hostname)); | 348 request.append(hostname, arraysize(hostname)); |
337 | 349 |
338 MockWrite data_writes[] = { | 350 MockWrite data_writes[] = { |
339 MockWrite(false, request.data(), request.size()) }; | 351 MockWrite(false, request.data(), request.size()) }; |
340 MockRead data_reads[] = { | 352 MockRead data_reads[] = { |
341 MockRead(false, kSOCKSOkReply, arraysize(kSOCKSOkReply)) }; | 353 MockRead(false, kSOCKSOkReply, arraysize(kSOCKSOkReply)) }; |
342 | 354 |
343 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 355 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
344 data_writes, arraysize(data_writes), | 356 data_writes, arraysize(data_writes), |
345 host_resolver_, hostname, 80)); | 357 host_resolver_, hostname, 80)); |
346 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 358 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
347 | 359 |
348 int rv = user_sock_->Connect(&callback_, log); | 360 int rv = user_sock_->Connect(&callback_, log.bound()); |
349 EXPECT_EQ(ERR_IO_PENDING, rv); | 361 EXPECT_EQ(ERR_IO_PENDING, rv); |
350 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKS_CONNECT)); | 362 EXPECT_TRUE(LogContainsBeginEvent( |
| 363 log.entries(), 0, NetLog::TYPE_SOCKS_CONNECT)); |
351 rv = callback_.WaitForResult(); | 364 rv = callback_.WaitForResult(); |
352 EXPECT_EQ(OK, rv); | 365 EXPECT_EQ(OK, rv); |
353 EXPECT_TRUE(user_sock_->IsConnected()); | 366 EXPECT_TRUE(user_sock_->IsConnected()); |
354 EXPECT_EQ(SOCKSClientSocket::kSOCKS4a, user_sock_->socks_version_); | 367 EXPECT_EQ(SOCKSClientSocket::kSOCKS4a, user_sock_->socks_version_); |
355 EXPECT_TRUE(LogContainsEndEvent(*log, -1, LoadLog::TYPE_SOCKS_CONNECT)); | 368 EXPECT_TRUE(LogContainsEndEvent( |
| 369 log.entries(), -1, NetLog::TYPE_SOCKS_CONNECT)); |
356 } | 370 } |
357 | 371 |
358 // Calls Disconnect() while a host resolve is in progress. The outstanding host | 372 // Calls Disconnect() while a host resolve is in progress. The outstanding host |
359 // resolve should be cancelled. | 373 // resolve should be cancelled. |
360 TEST_F(SOCKSClientSocketTest, DisconnectWhileHostResolveInProgress) { | 374 TEST_F(SOCKSClientSocketTest, DisconnectWhileHostResolveInProgress) { |
361 scoped_refptr<HangingHostResolver> hanging_resolver = | 375 scoped_refptr<HangingHostResolver> hanging_resolver = |
362 new HangingHostResolver(); | 376 new HangingHostResolver(); |
363 | 377 |
364 // Doesn't matter what the socket data is, we will never use it -- garbage. | 378 // Doesn't matter what the socket data is, we will never use it -- garbage. |
365 MockWrite data_writes[] = { MockWrite(false, "", 0) }; | 379 MockWrite data_writes[] = { MockWrite(false, "", 0) }; |
(...skipping 16 matching lines...) Expand all Loading... |
382 // Disconnect the SOCKS socket -- this should cancel the outstanding resolve. | 396 // Disconnect the SOCKS socket -- this should cancel the outstanding resolve. |
383 user_sock_->Disconnect(); | 397 user_sock_->Disconnect(); |
384 | 398 |
385 EXPECT_FALSE(hanging_resolver->HasOutstandingRequest()); | 399 EXPECT_FALSE(hanging_resolver->HasOutstandingRequest()); |
386 | 400 |
387 EXPECT_FALSE(user_sock_->IsConnected()); | 401 EXPECT_FALSE(user_sock_->IsConnected()); |
388 EXPECT_FALSE(user_sock_->IsConnectedAndIdle()); | 402 EXPECT_FALSE(user_sock_->IsConnectedAndIdle()); |
389 } | 403 } |
390 | 404 |
391 } // namespace net | 405 } // namespace net |
OLD | NEW |