OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 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 | 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/socks5_client_socket.h" | 5 #include "net/socket/socks5_client_socket.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <map> | 8 #include <map> |
9 | 9 |
10 #include "net/base/address_list.h" | 10 #include "net/base/address_list.h" |
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
108 0x01, // Command (CONNECT) | 108 0x01, // Command (CONNECT) |
109 0x00, // Reserved. | 109 0x00, // Reserved. |
110 0x03, // Address type (DOMAINNAME). | 110 0x03, // Address type (DOMAINNAME). |
111 0x09, // Length of domain (9) | 111 0x09, // Length of domain (9) |
112 // Domain string: | 112 // Domain string: |
113 'l', 'o', 'c', 'a', 'l', 'h', 'o', 's', 't', | 113 'l', 'o', 'c', 'a', 'l', 'h', 'o', 's', 't', |
114 0x00, 0x50, // 16-bit port (80) | 114 0x00, 0x50, // 16-bit port (80) |
115 }; | 115 }; |
116 | 116 |
117 MockWrite data_writes[] = { | 117 MockWrite data_writes[] = { |
118 MockWrite(true, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength), | 118 MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength), |
119 MockWrite(true, kOkRequest, arraysize(kOkRequest)), | 119 MockWrite(ASYNC, kOkRequest, arraysize(kOkRequest)), |
120 MockWrite(true, payload_write.data(), payload_write.size()) }; | 120 MockWrite(ASYNC, payload_write.data(), payload_write.size()) }; |
121 MockRead data_reads[] = { | 121 MockRead data_reads[] = { |
122 MockRead(true, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength), | 122 MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength), |
123 MockRead(true, kSOCKS5OkResponse, kSOCKS5OkResponseLength), | 123 MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength), |
124 MockRead(true, payload_read.data(), payload_read.size()) }; | 124 MockRead(ASYNC, payload_read.data(), payload_read.size()) }; |
125 | 125 |
126 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 126 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
127 data_writes, arraysize(data_writes), | 127 data_writes, arraysize(data_writes), |
128 "localhost", 80, &net_log_)); | 128 "localhost", 80, &net_log_)); |
129 | 129 |
130 // At this state the TCP connection is completed but not the SOCKS handshake. | 130 // At this state the TCP connection is completed but not the SOCKS handshake. |
131 EXPECT_TRUE(tcp_sock_->IsConnected()); | 131 EXPECT_TRUE(tcp_sock_->IsConnected()); |
132 EXPECT_FALSE(user_sock_->IsConnected()); | 132 EXPECT_FALSE(user_sock_->IsConnected()); |
133 | 133 |
134 int rv = user_sock_->Connect(callback_.callback()); | 134 int rv = user_sock_->Connect(callback_.callback()); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
178 0x03, // ATYPE | 178 0x03, // ATYPE |
179 }; | 179 }; |
180 | 180 |
181 std::string request(kSOCKS5DomainRequest, arraysize(kSOCKS5DomainRequest)); | 181 std::string request(kSOCKS5DomainRequest, arraysize(kSOCKS5DomainRequest)); |
182 request.push_back(hostname.size()); | 182 request.push_back(hostname.size()); |
183 request.append(hostname); | 183 request.append(hostname); |
184 request.append(reinterpret_cast<const char*>(&kNwPort), sizeof(kNwPort)); | 184 request.append(reinterpret_cast<const char*>(&kNwPort), sizeof(kNwPort)); |
185 | 185 |
186 for (int i = 0; i < 2; ++i) { | 186 for (int i = 0; i < 2; ++i) { |
187 MockWrite data_writes[] = { | 187 MockWrite data_writes[] = { |
188 MockWrite(false, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength), | 188 MockWrite(SYNCHRONOUS, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength), |
189 MockWrite(false, request.data(), request.size()) | 189 MockWrite(SYNCHRONOUS, request.data(), request.size()) |
190 }; | 190 }; |
191 MockRead data_reads[] = { | 191 MockRead data_reads[] = { |
192 MockRead(false, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength), | 192 MockRead(SYNCHRONOUS, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength), |
193 MockRead(false, kSOCKS5OkResponse, kSOCKS5OkResponseLength) | 193 MockRead(SYNCHRONOUS, kSOCKS5OkResponse, kSOCKS5OkResponseLength) |
194 }; | 194 }; |
195 | 195 |
196 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 196 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
197 data_writes, arraysize(data_writes), | 197 data_writes, arraysize(data_writes), |
198 hostname, 80, NULL)); | 198 hostname, 80, NULL)); |
199 | 199 |
200 int rv = user_sock_->Connect(callback_.callback()); | 200 int rv = user_sock_->Connect(callback_.callback()); |
201 EXPECT_EQ(OK, rv); | 201 EXPECT_EQ(OK, rv); |
202 EXPECT_TRUE(user_sock_->IsConnected()); | 202 EXPECT_TRUE(user_sock_->IsConnected()); |
203 | 203 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
238 // Domain string: | 238 // Domain string: |
239 'w', 'w', 'w', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'c', 'o', 'm', | 239 'w', 'w', 'w', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'c', 'o', 'm', |
240 0x00, 0x50, // 16-bit port (80) | 240 0x00, 0x50, // 16-bit port (80) |
241 }; | 241 }; |
242 | 242 |
243 // Test for partial greet request write | 243 // Test for partial greet request write |
244 { | 244 { |
245 const char partial1[] = { 0x05, 0x01 }; | 245 const char partial1[] = { 0x05, 0x01 }; |
246 const char partial2[] = { 0x00 }; | 246 const char partial2[] = { 0x00 }; |
247 MockWrite data_writes[] = { | 247 MockWrite data_writes[] = { |
248 MockWrite(true, arraysize(partial1)), | 248 MockWrite(ASYNC, arraysize(partial1)), |
249 MockWrite(true, partial2, arraysize(partial2)), | 249 MockWrite(ASYNC, partial2, arraysize(partial2)), |
250 MockWrite(true, kOkRequest, arraysize(kOkRequest)) }; | 250 MockWrite(ASYNC, kOkRequest, arraysize(kOkRequest)) }; |
251 MockRead data_reads[] = { | 251 MockRead data_reads[] = { |
252 MockRead(true, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength), | 252 MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength), |
253 MockRead(true, kSOCKS5OkResponse, kSOCKS5OkResponseLength) }; | 253 MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength) }; |
254 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 254 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
255 data_writes, arraysize(data_writes), | 255 data_writes, arraysize(data_writes), |
256 hostname, 80, &net_log_)); | 256 hostname, 80, &net_log_)); |
257 int rv = user_sock_->Connect(callback_.callback()); | 257 int rv = user_sock_->Connect(callback_.callback()); |
258 EXPECT_EQ(ERR_IO_PENDING, rv); | 258 EXPECT_EQ(ERR_IO_PENDING, rv); |
259 | 259 |
260 net::CapturingNetLog::EntryList net_log_entries; | 260 net::CapturingNetLog::EntryList net_log_entries; |
261 net_log_.GetEntries(&net_log_entries); | 261 net_log_.GetEntries(&net_log_entries); |
262 EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0, | 262 EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0, |
263 NetLog::TYPE_SOCKS5_CONNECT)); | 263 NetLog::TYPE_SOCKS5_CONNECT)); |
264 | 264 |
265 rv = callback_.WaitForResult(); | 265 rv = callback_.WaitForResult(); |
266 EXPECT_EQ(OK, rv); | 266 EXPECT_EQ(OK, rv); |
267 EXPECT_TRUE(user_sock_->IsConnected()); | 267 EXPECT_TRUE(user_sock_->IsConnected()); |
268 | 268 |
269 net_log_.GetEntries(&net_log_entries); | 269 net_log_.GetEntries(&net_log_entries); |
270 EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1, | 270 EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1, |
271 NetLog::TYPE_SOCKS5_CONNECT)); | 271 NetLog::TYPE_SOCKS5_CONNECT)); |
272 } | 272 } |
273 | 273 |
274 // Test for partial greet response read | 274 // Test for partial greet response read |
275 { | 275 { |
276 const char partial1[] = { 0x05 }; | 276 const char partial1[] = { 0x05 }; |
277 const char partial2[] = { 0x00 }; | 277 const char partial2[] = { 0x00 }; |
278 MockWrite data_writes[] = { | 278 MockWrite data_writes[] = { |
279 MockWrite(true, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength), | 279 MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength), |
280 MockWrite(true, kOkRequest, arraysize(kOkRequest)) }; | 280 MockWrite(ASYNC, kOkRequest, arraysize(kOkRequest)) }; |
281 MockRead data_reads[] = { | 281 MockRead data_reads[] = { |
282 MockRead(true, partial1, arraysize(partial1)), | 282 MockRead(ASYNC, partial1, arraysize(partial1)), |
283 MockRead(true, partial2, arraysize(partial2)), | 283 MockRead(ASYNC, partial2, arraysize(partial2)), |
284 MockRead(true, kSOCKS5OkResponse, kSOCKS5OkResponseLength) }; | 284 MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength) }; |
285 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 285 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
286 data_writes, arraysize(data_writes), | 286 data_writes, arraysize(data_writes), |
287 hostname, 80, &net_log_)); | 287 hostname, 80, &net_log_)); |
288 int rv = user_sock_->Connect(callback_.callback()); | 288 int rv = user_sock_->Connect(callback_.callback()); |
289 EXPECT_EQ(ERR_IO_PENDING, rv); | 289 EXPECT_EQ(ERR_IO_PENDING, rv); |
290 | 290 |
291 net::CapturingNetLog::EntryList net_log_entries; | 291 net::CapturingNetLog::EntryList net_log_entries; |
292 net_log_.GetEntries(&net_log_entries); | 292 net_log_.GetEntries(&net_log_entries); |
293 EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0, | 293 EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0, |
294 NetLog::TYPE_SOCKS5_CONNECT)); | 294 NetLog::TYPE_SOCKS5_CONNECT)); |
295 rv = callback_.WaitForResult(); | 295 rv = callback_.WaitForResult(); |
296 EXPECT_EQ(OK, rv); | 296 EXPECT_EQ(OK, rv); |
297 EXPECT_TRUE(user_sock_->IsConnected()); | 297 EXPECT_TRUE(user_sock_->IsConnected()); |
298 net_log_.GetEntries(&net_log_entries); | 298 net_log_.GetEntries(&net_log_entries); |
299 EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1, | 299 EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1, |
300 NetLog::TYPE_SOCKS5_CONNECT)); | 300 NetLog::TYPE_SOCKS5_CONNECT)); |
301 } | 301 } |
302 | 302 |
303 // Test for partial handshake request write. | 303 // Test for partial handshake request write. |
304 { | 304 { |
305 const int kSplitPoint = 3; // Break handshake write into two parts. | 305 const int kSplitPoint = 3; // Break handshake write into two parts. |
306 MockWrite data_writes[] = { | 306 MockWrite data_writes[] = { |
307 MockWrite(true, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength), | 307 MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength), |
308 MockWrite(true, kOkRequest, kSplitPoint), | 308 MockWrite(ASYNC, kOkRequest, kSplitPoint), |
309 MockWrite(true, kOkRequest + kSplitPoint, | 309 MockWrite(ASYNC, kOkRequest + kSplitPoint, |
310 arraysize(kOkRequest) - kSplitPoint) | 310 arraysize(kOkRequest) - kSplitPoint) |
311 }; | 311 }; |
312 MockRead data_reads[] = { | 312 MockRead data_reads[] = { |
313 MockRead(true, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength), | 313 MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength), |
314 MockRead(true, kSOCKS5OkResponse, kSOCKS5OkResponseLength) }; | 314 MockRead(ASYNC, kSOCKS5OkResponse, kSOCKS5OkResponseLength) }; |
315 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 315 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
316 data_writes, arraysize(data_writes), | 316 data_writes, arraysize(data_writes), |
317 hostname, 80, &net_log_)); | 317 hostname, 80, &net_log_)); |
318 int rv = user_sock_->Connect(callback_.callback()); | 318 int rv = user_sock_->Connect(callback_.callback()); |
319 EXPECT_EQ(ERR_IO_PENDING, rv); | 319 EXPECT_EQ(ERR_IO_PENDING, rv); |
320 net::CapturingNetLog::EntryList net_log_entries; | 320 net::CapturingNetLog::EntryList net_log_entries; |
321 net_log_.GetEntries(&net_log_entries); | 321 net_log_.GetEntries(&net_log_entries); |
322 EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0, | 322 EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0, |
323 NetLog::TYPE_SOCKS5_CONNECT)); | 323 NetLog::TYPE_SOCKS5_CONNECT)); |
324 rv = callback_.WaitForResult(); | 324 rv = callback_.WaitForResult(); |
325 EXPECT_EQ(OK, rv); | 325 EXPECT_EQ(OK, rv); |
326 EXPECT_TRUE(user_sock_->IsConnected()); | 326 EXPECT_TRUE(user_sock_->IsConnected()); |
327 net_log_.GetEntries(&net_log_entries); | 327 net_log_.GetEntries(&net_log_entries); |
328 EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1, | 328 EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1, |
329 NetLog::TYPE_SOCKS5_CONNECT)); | 329 NetLog::TYPE_SOCKS5_CONNECT)); |
330 } | 330 } |
331 | 331 |
332 // Test for partial handshake response read | 332 // Test for partial handshake response read |
333 { | 333 { |
334 const int kSplitPoint = 6; // Break the handshake read into two parts. | 334 const int kSplitPoint = 6; // Break the handshake read into two parts. |
335 MockWrite data_writes[] = { | 335 MockWrite data_writes[] = { |
336 MockWrite(true, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength), | 336 MockWrite(ASYNC, kSOCKS5GreetRequest, kSOCKS5GreetRequestLength), |
337 MockWrite(true, kOkRequest, arraysize(kOkRequest)) | 337 MockWrite(ASYNC, kOkRequest, arraysize(kOkRequest)) |
338 }; | 338 }; |
339 MockRead data_reads[] = { | 339 MockRead data_reads[] = { |
340 MockRead(true, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength), | 340 MockRead(ASYNC, kSOCKS5GreetResponse, kSOCKS5GreetResponseLength), |
341 MockRead(true, kSOCKS5OkResponse, kSplitPoint), | 341 MockRead(ASYNC, kSOCKS5OkResponse, kSplitPoint), |
342 MockRead(true, kSOCKS5OkResponse + kSplitPoint, | 342 MockRead(ASYNC, kSOCKS5OkResponse + kSplitPoint, |
343 kSOCKS5OkResponseLength - kSplitPoint) | 343 kSOCKS5OkResponseLength - kSplitPoint) |
344 }; | 344 }; |
345 | 345 |
346 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), | 346 user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads), |
347 data_writes, arraysize(data_writes), | 347 data_writes, arraysize(data_writes), |
348 hostname, 80, &net_log_)); | 348 hostname, 80, &net_log_)); |
349 int rv = user_sock_->Connect(callback_.callback()); | 349 int rv = user_sock_->Connect(callback_.callback()); |
350 EXPECT_EQ(ERR_IO_PENDING, rv); | 350 EXPECT_EQ(ERR_IO_PENDING, rv); |
351 net::CapturingNetLog::EntryList net_log_entries; | 351 net::CapturingNetLog::EntryList net_log_entries; |
352 net_log_.GetEntries(&net_log_entries); | 352 net_log_.GetEntries(&net_log_entries); |
353 EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0, | 353 EXPECT_TRUE(LogContainsBeginEvent(net_log_entries, 0, |
354 NetLog::TYPE_SOCKS5_CONNECT)); | 354 NetLog::TYPE_SOCKS5_CONNECT)); |
355 rv = callback_.WaitForResult(); | 355 rv = callback_.WaitForResult(); |
356 EXPECT_EQ(OK, rv); | 356 EXPECT_EQ(OK, rv); |
357 EXPECT_TRUE(user_sock_->IsConnected()); | 357 EXPECT_TRUE(user_sock_->IsConnected()); |
358 net_log_.GetEntries(&net_log_entries); | 358 net_log_.GetEntries(&net_log_entries); |
359 EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1, | 359 EXPECT_TRUE(LogContainsEndEvent(net_log_entries, -1, |
360 NetLog::TYPE_SOCKS5_CONNECT)); | 360 NetLog::TYPE_SOCKS5_CONNECT)); |
361 } | 361 } |
362 } | 362 } |
363 | 363 |
364 } // namespace | 364 } // namespace |
365 | 365 |
366 } // namespace net | 366 } // namespace net |
OLD | NEW |