OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 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/ftp/ftp_network_transaction.h" | 5 #include "net/ftp/ftp_network_transaction.h" |
6 | 6 |
7 #include "build/build_config.h" | 7 #include "build/build_config.h" |
8 | 8 |
9 #include "base/compiler_specific.h" | 9 #include "base/compiler_specific.h" |
10 #include "base/memory/ref_counted.h" | 10 #include "base/memory/ref_counted.h" |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
50 PRE_CWD_PASV, | 50 PRE_CWD_PASV, |
51 PRE_CWD, | 51 PRE_CWD, |
52 PRE_QUIT, | 52 PRE_QUIT, |
53 PRE_NOPASV, | 53 PRE_NOPASV, |
54 QUIT | 54 QUIT |
55 }; | 55 }; |
56 | 56 |
57 FtpSocketDataProvider() | 57 FtpSocketDataProvider() |
58 : failure_injection_state_(NONE), | 58 : failure_injection_state_(NONE), |
59 multiline_welcome_(false), | 59 multiline_welcome_(false), |
| 60 use_epsv_(true), |
60 data_type_('I') { | 61 data_type_('I') { |
61 Init(); | 62 Init(); |
62 } | 63 } |
63 | 64 |
64 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 65 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
65 if (InjectFault()) | 66 if (InjectFault()) |
66 return MockWriteResult(ASYNC, data.length()); | 67 return MockWriteResult(ASYNC, data.length()); |
67 switch (state()) { | 68 switch (state()) { |
68 case PRE_USER: | 69 case PRE_USER: |
69 return Verify("USER anonymous\r\n", data, PRE_PASSWD, | 70 return Verify("USER anonymous\r\n", data, PRE_PASSWD, |
70 "331 Password needed\r\n"); | 71 "331 Password needed\r\n"); |
71 case PRE_PASSWD: | 72 case PRE_PASSWD: |
72 { | 73 { |
73 const char* response_one = "230 Welcome\r\n"; | 74 const char* response_one = "230 Welcome\r\n"; |
74 const char* response_multi = "230- One\r\n230- Two\r\n230 Three\r\n"; | 75 const char* response_multi = "230- One\r\n230- Two\r\n230 Three\r\n"; |
75 return Verify("PASS chrome@example.com\r\n", data, PRE_SYST, | 76 return Verify("PASS chrome@example.com\r\n", data, PRE_SYST, |
76 multiline_welcome_ ? response_multi : response_one); | 77 multiline_welcome_ ? response_multi : response_one); |
77 } | 78 } |
78 case PRE_SYST: | 79 case PRE_SYST: |
79 return Verify("SYST\r\n", data, PRE_PWD, "215 UNIX\r\n"); | 80 return Verify("SYST\r\n", data, PRE_PWD, "215 UNIX\r\n"); |
80 case PRE_PWD: | 81 case PRE_PWD: |
81 return Verify("PWD\r\n", data, PRE_TYPE, | 82 return Verify("PWD\r\n", data, PRE_TYPE, |
82 "257 \"/\" is your current location\r\n"); | 83 "257 \"/\" is your current location\r\n"); |
83 case PRE_TYPE: | 84 case PRE_TYPE: |
84 return Verify(std::string("TYPE ") + data_type_ + "\r\n", data, | 85 return Verify(std::string("TYPE ") + data_type_ + "\r\n", data, |
85 PRE_EPSV, "200 TYPE set successfully\r\n"); | 86 use_epsv_ ? PRE_EPSV : PRE_PASV, |
| 87 "200 TYPE set successfully\r\n"); |
86 case PRE_EPSV: | 88 case PRE_EPSV: |
87 return Verify("EPSV\r\n", data, PRE_SIZE, | 89 return Verify("EPSV\r\n", data, PRE_SIZE, |
88 "227 Entering Extended Passive Mode (|||31744|)\r\n"); | 90 "227 Entering Extended Passive Mode (|||31744|)\r\n"); |
89 case PRE_CWD_EPSV: | 91 case PRE_CWD_EPSV: |
90 return Verify("EPSV\r\n", data, PRE_CWD, | 92 return Verify("EPSV\r\n", data, PRE_CWD, |
91 "227 Entering Extended Passive Mode (|||31744|)\r\n"); | 93 "227 Entering Extended Passive Mode (|||31744|)\r\n"); |
92 case PRE_RETR_EPSV: | 94 case PRE_RETR_EPSV: |
93 return Verify("EPSV\r\n", data, PRE_RETR, | 95 return Verify("EPSV\r\n", data, PRE_RETR, |
94 "227 Entering Extended Passive Mode (|||31744|)\r\n"); | 96 "227 Entering Extended Passive Mode (|||31744|)\r\n"); |
95 case PRE_CWD_PASV: | 97 case PRE_CWD_PASV: |
96 return Verify("PASV\r\n", data, PRE_CWD, | 98 return Verify("PASV\r\n", data, PRE_CWD, |
97 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | 99 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); |
98 case PRE_RETR_PASV: | 100 case PRE_RETR_PASV: |
99 return Verify("PASV\r\n", data, PRE_RETR, | 101 return Verify("PASV\r\n", data, PRE_RETR, |
100 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | 102 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); |
| 103 case PRE_PASV: |
| 104 return Verify("PASV\r\n", data, PRE_SIZE, |
| 105 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); |
101 case PRE_NOPASV: | 106 case PRE_NOPASV: |
102 // Use unallocated 599 FTP error code to make sure it falls into the | 107 // Use unallocated 599 FTP error code to make sure it falls into the |
103 // generic ERR_FTP_FAILED bucket. | 108 // generic ERR_FTP_FAILED bucket. |
104 return Verify("PASV\r\n", data, PRE_QUIT, | 109 return Verify("PASV\r\n", data, PRE_QUIT, |
105 "599 fail\r\n"); | 110 "599 fail\r\n"); |
106 case PRE_QUIT: | 111 case PRE_QUIT: |
107 return Verify("QUIT\r\n", data, QUIT, "221 Goodbye.\r\n"); | 112 return Verify("QUIT\r\n", data, QUIT, "221 Goodbye.\r\n"); |
108 default: | 113 default: |
109 NOTREACHED() << "State not handled " << state(); | 114 NOTREACHED() << "State not handled " << state(); |
110 return MockWriteResult(ASYNC, ERR_UNEXPECTED); | 115 return MockWriteResult(ASYNC, ERR_UNEXPECTED); |
(...skipping 12 matching lines...) Expand all Loading... |
123 | 128 |
124 State state() const { | 129 State state() const { |
125 return state_; | 130 return state_; |
126 } | 131 } |
127 | 132 |
128 virtual void Reset() OVERRIDE { | 133 virtual void Reset() OVERRIDE { |
129 DynamicSocketDataProvider::Reset(); | 134 DynamicSocketDataProvider::Reset(); |
130 Init(); | 135 Init(); |
131 } | 136 } |
132 | 137 |
133 void set_multiline_welcome(bool multiline) { | 138 void set_multiline_welcome(bool multiline) { multiline_welcome_ = multiline; } |
134 multiline_welcome_ = multiline; | |
135 } | |
136 | 139 |
137 void set_data_type(char data_type) { | 140 bool use_epsv() const { return use_epsv_; } |
138 data_type_ = data_type; | 141 void set_use_epsv(bool use_epsv) { use_epsv_ = use_epsv; } |
139 } | 142 |
| 143 void set_data_type(char data_type) { data_type_ = data_type; } |
140 | 144 |
141 protected: | 145 protected: |
142 void Init() { | 146 void Init() { |
143 state_ = PRE_USER; | 147 state_ = PRE_USER; |
144 SimulateRead("220 host TestFTPd\r\n"); | 148 SimulateRead("220 host TestFTPd\r\n"); |
145 } | 149 } |
146 | 150 |
147 // If protocol fault injection has been requested, adjusts state and mocked | 151 // If protocol fault injection has been requested, adjusts state and mocked |
148 // read and returns true. | 152 // read and returns true. |
149 bool InjectFault() { | 153 bool InjectFault() { |
(...skipping 29 matching lines...) Expand all Loading... |
179 | 183 |
180 private: | 184 private: |
181 State state_; | 185 State state_; |
182 State failure_injection_state_; | 186 State failure_injection_state_; |
183 State failure_injection_next_state_; | 187 State failure_injection_next_state_; |
184 const char* fault_response_; | 188 const char* fault_response_; |
185 | 189 |
186 // If true, we will send multiple 230 lines as response after PASS. | 190 // If true, we will send multiple 230 lines as response after PASS. |
187 bool multiline_welcome_; | 191 bool multiline_welcome_; |
188 | 192 |
| 193 // If true, we will use EPSV command. |
| 194 bool use_epsv_; |
| 195 |
189 // Data type to be used for TYPE command. | 196 // Data type to be used for TYPE command. |
190 char data_type_; | 197 char data_type_; |
191 | 198 |
192 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProvider); | 199 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProvider); |
193 }; | 200 }; |
194 | 201 |
195 class FtpSocketDataProviderDirectoryListing : public FtpSocketDataProvider { | 202 class FtpSocketDataProviderDirectoryListing : public FtpSocketDataProvider { |
196 public: | 203 public: |
197 FtpSocketDataProviderDirectoryListing() { | 204 FtpSocketDataProviderDirectoryListing() { |
198 } | 205 } |
199 | 206 |
200 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 207 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
201 if (InjectFault()) | 208 if (InjectFault()) |
202 return MockWriteResult(ASYNC, data.length()); | 209 return MockWriteResult(ASYNC, data.length()); |
203 switch (state()) { | 210 switch (state()) { |
204 case PRE_SIZE: | 211 case PRE_SIZE: |
205 return Verify("SIZE /\r\n", data, PRE_CWD_EPSV, | 212 return Verify("SIZE /\r\n", data, |
| 213 use_epsv() ? PRE_CWD_EPSV : PRE_CWD_PASV, |
206 "550 I can only retrieve regular files\r\n"); | 214 "550 I can only retrieve regular files\r\n"); |
207 case PRE_CWD: | 215 case PRE_CWD: |
208 return Verify("CWD /\r\n", data, PRE_LIST, "200 OK\r\n"); | 216 return Verify("CWD /\r\n", data, PRE_LIST, "200 OK\r\n"); |
209 case PRE_LIST: | 217 case PRE_LIST: |
210 return Verify("LIST -l\r\n", data, PRE_QUIT, "200 OK\r\n"); | 218 return Verify("LIST -l\r\n", data, PRE_QUIT, "200 OK\r\n"); |
211 default: | 219 default: |
212 return FtpSocketDataProvider::OnWrite(data); | 220 return FtpSocketDataProvider::OnWrite(data); |
213 } | 221 } |
214 } | 222 } |
215 | 223 |
216 private: | 224 private: |
217 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListing); | 225 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListing); |
218 }; | 226 }; |
219 | 227 |
220 class FtpSocketDataProviderDirectoryListingWithPasvFallback | 228 class FtpSocketDataProviderDirectoryListingWithPasvFallback |
221 : public FtpSocketDataProviderDirectoryListing { | 229 : public FtpSocketDataProviderDirectoryListing { |
222 public: | 230 public: |
223 FtpSocketDataProviderDirectoryListingWithPasvFallback() { | 231 FtpSocketDataProviderDirectoryListingWithPasvFallback() { |
224 } | 232 } |
225 | 233 |
226 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 234 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
227 if (InjectFault()) | 235 if (InjectFault()) |
228 return MockWriteResult(ASYNC, data.length()); | 236 return MockWriteResult(ASYNC, data.length()); |
229 switch (state()) { | 237 switch (state()) { |
230 case PRE_EPSV: | 238 case PRE_EPSV: |
231 return Verify("EPSV\r\n", data, PRE_PASV, | 239 return Verify("EPSV\r\n", data, PRE_PASV, |
232 "500 no EPSV for you\r\n"); | 240 "500 no EPSV for you\r\n"); |
233 case PRE_PASV: | |
234 return Verify("PASV\r\n", data, PRE_SIZE, | |
235 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | |
236 case PRE_SIZE: | 241 case PRE_SIZE: |
237 return Verify("SIZE /\r\n", data, PRE_CWD_PASV, | 242 return Verify("SIZE /\r\n", data, PRE_CWD_PASV, |
238 "550 I can only retrieve regular files\r\n"); | 243 "550 I can only retrieve regular files\r\n"); |
239 default: | 244 default: |
240 return FtpSocketDataProviderDirectoryListing::OnWrite(data); | 245 return FtpSocketDataProviderDirectoryListing::OnWrite(data); |
241 } | 246 } |
242 } | 247 } |
243 | 248 |
244 private: | 249 private: |
245 DISALLOW_COPY_AND_ASSIGN( | 250 DISALLOW_COPY_AND_ASSIGN( |
(...skipping 30 matching lines...) Expand all Loading... |
276 if (InjectFault()) | 281 if (InjectFault()) |
277 return MockWriteResult(ASYNC, data.length()); | 282 return MockWriteResult(ASYNC, data.length()); |
278 switch (state()) { | 283 switch (state()) { |
279 case PRE_SYST: | 284 case PRE_SYST: |
280 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); | 285 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); |
281 case PRE_PWD: | 286 case PRE_PWD: |
282 return Verify("PWD\r\n", data, PRE_TYPE, | 287 return Verify("PWD\r\n", data, PRE_TYPE, |
283 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); | 288 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); |
284 case PRE_EPSV: | 289 case PRE_EPSV: |
285 return Verify("EPSV\r\n", data, PRE_PASV, "500 Invalid command\r\n"); | 290 return Verify("EPSV\r\n", data, PRE_PASV, "500 Invalid command\r\n"); |
286 case PRE_PASV: | |
287 return Verify("PASV\r\n", data, PRE_SIZE, | |
288 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | |
289 case PRE_SIZE: | 291 case PRE_SIZE: |
290 return Verify("SIZE ANONYMOUS_ROOT:[000000]dir\r\n", data, PRE_CWD_PASV, | 292 return Verify("SIZE ANONYMOUS_ROOT:[000000]dir\r\n", data, PRE_CWD_PASV, |
291 "550 I can only retrieve regular files\r\n"); | 293 "550 I can only retrieve regular files\r\n"); |
292 case PRE_CWD: | 294 case PRE_CWD: |
293 return Verify("CWD ANONYMOUS_ROOT:[dir]\r\n", data, PRE_LIST, | 295 return Verify("CWD ANONYMOUS_ROOT:[dir]\r\n", data, PRE_LIST, |
294 "200 OK\r\n"); | 296 "200 OK\r\n"); |
295 case PRE_LIST: | 297 case PRE_LIST: |
296 return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n"); | 298 return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n"); |
297 default: | 299 default: |
298 return FtpSocketDataProvider::OnWrite(data); | 300 return FtpSocketDataProvider::OnWrite(data); |
(...skipping 15 matching lines...) Expand all Loading... |
314 return MockWriteResult(ASYNC, data.length()); | 316 return MockWriteResult(ASYNC, data.length()); |
315 switch (state()) { | 317 switch (state()) { |
316 case PRE_SYST: | 318 case PRE_SYST: |
317 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); | 319 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); |
318 case PRE_PWD: | 320 case PRE_PWD: |
319 return Verify("PWD\r\n", data, PRE_TYPE, | 321 return Verify("PWD\r\n", data, PRE_TYPE, |
320 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); | 322 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); |
321 case PRE_EPSV: | 323 case PRE_EPSV: |
322 return Verify("EPSV\r\n", data, PRE_PASV, | 324 return Verify("EPSV\r\n", data, PRE_PASV, |
323 "500 EPSV command unknown\r\n"); | 325 "500 EPSV command unknown\r\n"); |
324 case PRE_PASV: | |
325 return Verify("PASV\r\n", data, PRE_SIZE, | |
326 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | |
327 case PRE_SIZE: | 326 case PRE_SIZE: |
328 return Verify("SIZE ANONYMOUS_ROOT\r\n", data, PRE_CWD_PASV, | 327 return Verify("SIZE ANONYMOUS_ROOT\r\n", data, PRE_CWD_PASV, |
329 "550 I can only retrieve regular files\r\n"); | 328 "550 I can only retrieve regular files\r\n"); |
330 case PRE_CWD: | 329 case PRE_CWD: |
331 return Verify("CWD ANONYMOUS_ROOT:[000000]\r\n", data, PRE_LIST, | 330 return Verify("CWD ANONYMOUS_ROOT:[000000]\r\n", data, PRE_LIST, |
332 "200 OK\r\n"); | 331 "200 OK\r\n"); |
333 case PRE_LIST: | 332 case PRE_LIST: |
334 return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n"); | 333 return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n"); |
335 default: | 334 default: |
336 return FtpSocketDataProvider::OnWrite(data); | 335 return FtpSocketDataProvider::OnWrite(data); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
372 } | 371 } |
373 | 372 |
374 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 373 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
375 if (InjectFault()) | 374 if (InjectFault()) |
376 return MockWriteResult(ASYNC, data.length()); | 375 return MockWriteResult(ASYNC, data.length()); |
377 switch (state()) { | 376 switch (state()) { |
378 case PRE_SIZE: | 377 case PRE_SIZE: |
379 return Verify("SIZE /file\r\n", data, PRE_CWD, | 378 return Verify("SIZE /file\r\n", data, PRE_CWD, |
380 "213 18\r\n"); | 379 "213 18\r\n"); |
381 case PRE_CWD: | 380 case PRE_CWD: |
382 return Verify("CWD /file\r\n", data, PRE_RETR_EPSV, | 381 return Verify("CWD /file\r\n", data, |
| 382 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, |
383 "550 Not a directory\r\n"); | 383 "550 Not a directory\r\n"); |
384 case PRE_RETR: | 384 case PRE_RETR: |
385 return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n"); | 385 return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n"); |
386 default: | 386 default: |
387 return FtpSocketDataProvider::OnWrite(data); | 387 return FtpSocketDataProvider::OnWrite(data); |
388 } | 388 } |
389 } | 389 } |
390 | 390 |
391 private: | 391 private: |
392 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownload); | 392 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownload); |
393 }; | 393 }; |
394 | 394 |
395 class FtpSocketDataProviderFileNotFound : public FtpSocketDataProvider { | 395 class FtpSocketDataProviderFileNotFound : public FtpSocketDataProvider { |
396 public: | 396 public: |
397 FtpSocketDataProviderFileNotFound() { | 397 FtpSocketDataProviderFileNotFound() { |
398 } | 398 } |
399 | 399 |
400 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 400 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
401 if (InjectFault()) | 401 if (InjectFault()) |
402 return MockWriteResult(ASYNC, data.length()); | 402 return MockWriteResult(ASYNC, data.length()); |
403 switch (state()) { | 403 switch (state()) { |
404 case PRE_SIZE: | 404 case PRE_SIZE: |
405 return Verify("SIZE /file\r\n", data, PRE_CWD_EPSV, | 405 return Verify("SIZE /file\r\n", data, |
| 406 use_epsv() ? PRE_CWD_EPSV : PRE_CWD_PASV, |
406 "550 File Not Found\r\n"); | 407 "550 File Not Found\r\n"); |
407 case PRE_CWD: | 408 case PRE_CWD: |
408 return Verify("CWD /file\r\n", data, PRE_RETR_EPSV, | 409 return Verify("CWD /file\r\n", data, |
| 410 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, |
409 "550 File Not Found\r\n"); | 411 "550 File Not Found\r\n"); |
410 case PRE_RETR: | 412 case PRE_RETR: |
411 return Verify("RETR /file\r\n", data, PRE_QUIT, | 413 return Verify("RETR /file\r\n", data, PRE_QUIT, |
412 "550 File Not Found\r\n"); | 414 "550 File Not Found\r\n"); |
413 default: | 415 default: |
414 return FtpSocketDataProvider::OnWrite(data); | 416 return FtpSocketDataProvider::OnWrite(data); |
415 } | 417 } |
416 } | 418 } |
417 | 419 |
418 private: | 420 private: |
419 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileNotFound); | 421 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileNotFound); |
420 }; | 422 }; |
421 | 423 |
422 class FtpSocketDataProviderFileDownloadWithPasvFallback | 424 class FtpSocketDataProviderFileDownloadWithPasvFallback |
423 : public FtpSocketDataProviderFileDownload { | 425 : public FtpSocketDataProviderFileDownload { |
424 public: | 426 public: |
425 FtpSocketDataProviderFileDownloadWithPasvFallback() { | 427 FtpSocketDataProviderFileDownloadWithPasvFallback() { |
426 } | 428 } |
427 | 429 |
428 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 430 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
429 if (InjectFault()) | 431 if (InjectFault()) |
430 return MockWriteResult(ASYNC, data.length()); | 432 return MockWriteResult(ASYNC, data.length()); |
431 switch (state()) { | 433 switch (state()) { |
432 case PRE_EPSV: | 434 case PRE_EPSV: |
433 return Verify("EPSV\r\n", data, PRE_PASV, | 435 return Verify("EPSV\r\n", data, PRE_PASV, |
434 "500 No can do\r\n"); | 436 "500 No can do\r\n"); |
435 case PRE_PASV: | |
436 return Verify("PASV\r\n", data, PRE_SIZE, | |
437 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | |
438 case PRE_CWD: | 437 case PRE_CWD: |
439 return Verify("CWD /file\r\n", data, PRE_RETR_PASV, | 438 return Verify("CWD /file\r\n", data, PRE_RETR_PASV, |
440 "550 Not a directory\r\n"); | 439 "550 Not a directory\r\n"); |
441 default: | 440 default: |
442 return FtpSocketDataProviderFileDownload::OnWrite(data); | 441 return FtpSocketDataProviderFileDownload::OnWrite(data); |
443 } | 442 } |
444 } | 443 } |
445 | 444 |
446 private: | 445 private: |
447 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithPasvFallback); | 446 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithPasvFallback); |
448 }; | 447 }; |
449 | 448 |
450 class FtpSocketDataProviderFileDownloadZeroSize | 449 class FtpSocketDataProviderFileDownloadZeroSize |
451 : public FtpSocketDataProviderFileDownload { | 450 : public FtpSocketDataProviderFileDownload { |
452 public: | 451 public: |
453 FtpSocketDataProviderFileDownloadZeroSize() { | 452 FtpSocketDataProviderFileDownloadZeroSize() { |
454 } | 453 } |
455 | 454 |
456 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 455 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
457 if (InjectFault()) | 456 if (InjectFault()) |
458 return MockWriteResult(ASYNC, data.length()); | 457 return MockWriteResult(ASYNC, data.length()); |
459 switch (state()) { | 458 switch (state()) { |
460 case PRE_SIZE: | 459 case PRE_SIZE: |
461 return Verify("SIZE /file\r\n", data, PRE_CWD, | 460 return Verify("SIZE /file\r\n", data, PRE_CWD, |
462 "213 0\r\n"); | 461 "213 0\r\n"); |
463 case PRE_CWD: | 462 case PRE_CWD: |
464 return Verify("CWD /file\r\n", data, PRE_RETR_EPSV, | 463 return Verify("CWD /file\r\n", data, |
| 464 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, |
465 "550 not a directory\r\n"); | 465 "550 not a directory\r\n"); |
466 default: | 466 default: |
467 return FtpSocketDataProviderFileDownload::OnWrite(data); | 467 return FtpSocketDataProviderFileDownload::OnWrite(data); |
468 } | 468 } |
469 } | 469 } |
470 | 470 |
471 private: | 471 private: |
472 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadZeroSize); | 472 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadZeroSize); |
473 }; | 473 }; |
474 | 474 |
475 class FtpSocketDataProviderFileDownloadCWD451 | 475 class FtpSocketDataProviderFileDownloadCWD451 |
476 : public FtpSocketDataProviderFileDownload { | 476 : public FtpSocketDataProviderFileDownload { |
477 public: | 477 public: |
478 FtpSocketDataProviderFileDownloadCWD451() { | 478 FtpSocketDataProviderFileDownloadCWD451() { |
479 } | 479 } |
480 | 480 |
481 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 481 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
482 if (InjectFault()) | 482 if (InjectFault()) |
483 return MockWriteResult(ASYNC, data.length()); | 483 return MockWriteResult(ASYNC, data.length()); |
484 switch (state()) { | 484 switch (state()) { |
485 case PRE_CWD: | 485 case PRE_CWD: |
486 return Verify("CWD /file\r\n", data, PRE_RETR_EPSV, | 486 return Verify("CWD /file\r\n", data, |
| 487 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, |
487 "451 not a directory\r\n"); | 488 "451 not a directory\r\n"); |
488 default: | 489 default: |
489 return FtpSocketDataProviderFileDownload::OnWrite(data); | 490 return FtpSocketDataProviderFileDownload::OnWrite(data); |
490 } | 491 } |
491 } | 492 } |
492 | 493 |
493 private: | 494 private: |
494 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadCWD451); | 495 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadCWD451); |
495 }; | 496 }; |
496 | 497 |
497 class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider { | 498 class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider { |
498 public: | 499 public: |
499 FtpSocketDataProviderVMSFileDownload() { | 500 FtpSocketDataProviderVMSFileDownload() { |
500 } | 501 } |
501 | 502 |
502 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 503 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
503 if (InjectFault()) | 504 if (InjectFault()) |
504 return MockWriteResult(ASYNC, data.length()); | 505 return MockWriteResult(ASYNC, data.length()); |
505 switch (state()) { | 506 switch (state()) { |
506 case PRE_SYST: | 507 case PRE_SYST: |
507 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); | 508 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); |
508 case PRE_PWD: | 509 case PRE_PWD: |
509 return Verify("PWD\r\n", data, PRE_TYPE, | 510 return Verify("PWD\r\n", data, PRE_TYPE, |
510 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); | 511 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); |
511 case PRE_EPSV: | 512 case PRE_EPSV: |
512 return Verify("EPSV\r\n", data, PRE_PASV, | 513 return Verify("EPSV\r\n", data, PRE_PASV, |
513 "500 EPSV command unknown\r\n"); | 514 "500 EPSV command unknown\r\n"); |
514 case PRE_PASV: | |
515 return Verify("PASV\r\n", data, PRE_SIZE, | |
516 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | |
517 case PRE_SIZE: | 515 case PRE_SIZE: |
518 return Verify("SIZE ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_CWD, | 516 return Verify("SIZE ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_CWD, |
519 "213 18\r\n"); | 517 "213 18\r\n"); |
520 case PRE_CWD: | 518 case PRE_CWD: |
521 return Verify("CWD ANONYMOUS_ROOT:[file]\r\n", data, PRE_RETR_PASV, | 519 return Verify("CWD ANONYMOUS_ROOT:[file]\r\n", data, PRE_RETR_PASV, |
522 "550 Not a directory\r\n"); | 520 "550 Not a directory\r\n"); |
523 case PRE_RETR: | 521 case PRE_RETR: |
524 return Verify("RETR ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_QUIT, | 522 return Verify("RETR ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_QUIT, |
525 "200 OK\r\n"); | 523 "200 OK\r\n"); |
526 default: | 524 default: |
(...skipping 11 matching lines...) Expand all Loading... |
538 } | 536 } |
539 | 537 |
540 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 538 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
541 if (InjectFault()) | 539 if (InjectFault()) |
542 return MockWriteResult(ASYNC, data.length()); | 540 return MockWriteResult(ASYNC, data.length()); |
543 switch (state()) { | 541 switch (state()) { |
544 case PRE_SIZE: | 542 case PRE_SIZE: |
545 return Verify("SIZE / !\"#$%y\200\201\r\n", data, PRE_CWD, | 543 return Verify("SIZE / !\"#$%y\200\201\r\n", data, PRE_CWD, |
546 "213 18\r\n"); | 544 "213 18\r\n"); |
547 case PRE_CWD: | 545 case PRE_CWD: |
548 return Verify("CWD / !\"#$%y\200\201\r\n", data, PRE_RETR_EPSV, | 546 return Verify("CWD / !\"#$%y\200\201\r\n", data, |
| 547 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, |
549 "550 Not a directory\r\n"); | 548 "550 Not a directory\r\n"); |
550 case PRE_RETR: | 549 case PRE_RETR: |
551 return Verify("RETR / !\"#$%y\200\201\r\n", data, PRE_QUIT, | 550 return Verify("RETR / !\"#$%y\200\201\r\n", data, PRE_QUIT, |
552 "200 OK\r\n"); | 551 "200 OK\r\n"); |
553 default: | 552 default: |
554 return FtpSocketDataProviderFileDownload::OnWrite(data); | 553 return FtpSocketDataProviderFileDownload::OnWrite(data); |
555 } | 554 } |
556 } | 555 } |
557 | 556 |
558 private: | 557 private: |
(...skipping 205 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
764 PRE_QUIT, ""); | 763 PRE_QUIT, ""); |
765 default: | 764 default: |
766 return FtpSocketDataProvider::OnWrite(data); | 765 return FtpSocketDataProvider::OnWrite(data); |
767 } | 766 } |
768 } | 767 } |
769 | 768 |
770 private: | 769 private: |
771 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderCloseConnection); | 770 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderCloseConnection); |
772 }; | 771 }; |
773 | 772 |
774 class FtpNetworkTransactionTest : public PlatformTest { | 773 class FtpNetworkTransactionTest |
| 774 : public PlatformTest, |
| 775 public ::testing::WithParamInterface<int> { |
775 public: | 776 public: |
776 FtpNetworkTransactionTest() | 777 FtpNetworkTransactionTest() |
777 : host_resolver_(new MockHostResolver), | 778 : host_resolver_(new MockHostResolver), |
778 session_(new FtpNetworkSession(host_resolver_.get())), | 779 session_(new FtpNetworkSession(host_resolver_.get())), |
779 transaction_(session_.get(), &mock_socket_factory_) { | 780 transaction_(session_.get(), &mock_socket_factory_) { |
| 781 scoped_refptr<RuleBasedHostResolverProc> rules( |
| 782 new RuleBasedHostResolverProc(NULL)); |
| 783 if (GetFamily() == AF_INET) { |
| 784 rules->AddIPLiteralRule("*", "127.0.0.1", "127.0.0.1"); |
| 785 } else if (GetFamily() == AF_INET6) { |
| 786 rules->AddIPLiteralRule("*", "::1", "::1"); |
| 787 } else { |
| 788 NOTREACHED(); |
| 789 } |
| 790 host_resolver_->set_rules(rules.get()); |
780 } | 791 } |
781 | 792 |
782 protected: | 793 protected: |
| 794 // Accessor to make code refactoring-friendly, e.g. when we change the way |
| 795 // parameters are passed (like more parameters). |
| 796 int GetFamily() { |
| 797 return GetParam(); |
| 798 } |
| 799 |
783 FtpRequestInfo GetRequestInfo(const std::string& url) { | 800 FtpRequestInfo GetRequestInfo(const std::string& url) { |
784 FtpRequestInfo info; | 801 FtpRequestInfo info; |
785 info.url = GURL(url); | 802 info.url = GURL(url); |
786 return info; | 803 return info; |
787 } | 804 } |
788 | 805 |
789 void ExecuteTransaction(FtpSocketDataProvider* ctrl_socket, | 806 void ExecuteTransaction(FtpSocketDataProvider* ctrl_socket, |
790 const char* request, | 807 const char* request, |
791 int data_socket, | 808 int data_socket, |
792 int expected_result) { | 809 int expected_result) { |
| 810 // Expect EPSV usage for non-IPv4 control connections. |
| 811 ctrl_socket->set_use_epsv((GetFamily() != AF_INET)); |
| 812 |
793 mock_socket_factory_.AddSocketDataProvider(ctrl_socket); | 813 mock_socket_factory_.AddSocketDataProvider(ctrl_socket); |
794 | 814 |
795 std::string mock_data("mock-data"); | 815 std::string mock_data("mock-data"); |
796 MockRead data_reads[] = { | 816 MockRead data_reads[] = { |
797 // Usually FTP servers close the data connection after the entire data has | 817 // Usually FTP servers close the data connection after the entire data has |
798 // been received. | 818 // been received. |
799 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), | 819 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
800 MockRead(mock_data.c_str()), | 820 MockRead(mock_data.c_str()), |
801 }; | 821 }; |
802 | 822 |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
853 ExecuteTransaction(ctrl_socket, request, 1, expected_result); | 873 ExecuteTransaction(ctrl_socket, request, 1, expected_result); |
854 } | 874 } |
855 | 875 |
856 scoped_ptr<MockHostResolver> host_resolver_; | 876 scoped_ptr<MockHostResolver> host_resolver_; |
857 scoped_refptr<FtpNetworkSession> session_; | 877 scoped_refptr<FtpNetworkSession> session_; |
858 MockClientSocketFactory mock_socket_factory_; | 878 MockClientSocketFactory mock_socket_factory_; |
859 FtpNetworkTransaction transaction_; | 879 FtpNetworkTransaction transaction_; |
860 TestCompletionCallback callback_; | 880 TestCompletionCallback callback_; |
861 }; | 881 }; |
862 | 882 |
863 TEST_F(FtpNetworkTransactionTest, FailedLookup) { | 883 TEST_P(FtpNetworkTransactionTest, FailedLookup) { |
864 FtpRequestInfo request_info = GetRequestInfo("ftp://badhost"); | 884 FtpRequestInfo request_info = GetRequestInfo("ftp://badhost"); |
865 host_resolver_->rules()->AddSimulatedFailure("badhost"); | 885 scoped_refptr<RuleBasedHostResolverProc> rules( |
| 886 new RuleBasedHostResolverProc(NULL)); |
| 887 rules->AddSimulatedFailure("badhost"); |
| 888 host_resolver_->set_rules(rules.get()); |
| 889 |
866 EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState()); | 890 EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState()); |
867 ASSERT_EQ(ERR_IO_PENDING, | 891 ASSERT_EQ(ERR_IO_PENDING, |
868 transaction_.Start(&request_info, callback_.callback(), | 892 transaction_.Start(&request_info, callback_.callback(), |
869 BoundNetLog())); | 893 BoundNetLog())); |
870 ASSERT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult()); | 894 ASSERT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult()); |
871 EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState()); | 895 EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState()); |
872 } | 896 } |
873 | 897 |
874 // Check that when determining the host, the square brackets decorating IPv6 | 898 // Check that when determining the host, the square brackets decorating IPv6 |
875 // literals in URLs are stripped. | 899 // literals in URLs are stripped. |
876 TEST_F(FtpNetworkTransactionTest, StripBracketsFromIPv6Literals) { | 900 TEST_P(FtpNetworkTransactionTest, StripBracketsFromIPv6Literals) { |
| 901 // This test only makes sense for IPv6 connections. |
| 902 if (GetFamily() != AF_INET6) |
| 903 return; |
| 904 |
877 host_resolver_->rules()->AddSimulatedFailure("[::1]"); | 905 host_resolver_->rules()->AddSimulatedFailure("[::1]"); |
878 | 906 |
879 // We start a transaction that is expected to fail with ERR_INVALID_RESPONSE. | 907 // We start a transaction that is expected to fail with ERR_INVALID_RESPONSE. |
880 // The important part of this test is to make sure that we don't fail with | 908 // The important part of this test is to make sure that we don't fail with |
881 // ERR_NAME_NOT_RESOLVED, since that would mean the decorated hostname | 909 // ERR_NAME_NOT_RESOLVED, since that would mean the decorated hostname |
882 // was used. | 910 // was used. |
883 FtpSocketDataProviderEvilSize ctrl_socket( | 911 FtpSocketDataProviderEvilSize ctrl_socket( |
884 "213 99999999999999999999999999999999\r\n", | 912 "213 99999999999999999999999999999999\r\n", |
885 FtpSocketDataProvider::PRE_QUIT); | 913 FtpSocketDataProvider::PRE_QUIT); |
886 ExecuteTransaction(&ctrl_socket, "ftp://[::1]/file", 1, ERR_INVALID_RESPONSE); | 914 ExecuteTransaction(&ctrl_socket, "ftp://[::1]/file", 1, ERR_INVALID_RESPONSE); |
887 } | 915 } |
888 | 916 |
889 TEST_F(FtpNetworkTransactionTest, DirectoryTransaction) { | 917 TEST_P(FtpNetworkTransactionTest, DirectoryTransaction) { |
890 FtpSocketDataProviderDirectoryListing ctrl_socket; | 918 FtpSocketDataProviderDirectoryListing ctrl_socket; |
891 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); | 919 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); |
892 | 920 |
893 EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing); | 921 EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing); |
894 EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size); | 922 EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size); |
895 EXPECT_EQ("127.0.0.1", | 923 EXPECT_EQ((GetFamily() == AF_INET) ? "127.0.0.1" : "::1", |
896 transaction_.GetResponseInfo()->socket_address.host()); | 924 transaction_.GetResponseInfo()->socket_address.host()); |
897 EXPECT_EQ(21, transaction_.GetResponseInfo()->socket_address.port()); | 925 EXPECT_EQ(21, transaction_.GetResponseInfo()->socket_address.port()); |
898 } | 926 } |
899 | 927 |
900 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionWithPasvFallback) { | 928 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionWithPasvFallback) { |
901 FtpSocketDataProviderDirectoryListingWithPasvFallback ctrl_socket; | 929 FtpSocketDataProviderDirectoryListingWithPasvFallback ctrl_socket; |
902 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); | 930 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); |
903 | 931 |
904 EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing); | 932 EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing); |
905 EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size); | 933 EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size); |
906 } | 934 } |
907 | 935 |
908 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionWithTypecode) { | 936 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionWithTypecode) { |
909 FtpSocketDataProviderDirectoryListing ctrl_socket; | 937 FtpSocketDataProviderDirectoryListing ctrl_socket; |
910 ExecuteTransaction(&ctrl_socket, "ftp://host;type=d", 1, OK); | 938 ExecuteTransaction(&ctrl_socket, "ftp://host;type=d", 1, OK); |
911 | 939 |
912 EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing); | 940 EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing); |
913 EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size); | 941 EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size); |
914 } | 942 } |
915 | 943 |
916 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionMultilineWelcome) { | 944 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionMultilineWelcome) { |
917 FtpSocketDataProviderDirectoryListing ctrl_socket; | 945 FtpSocketDataProviderDirectoryListing ctrl_socket; |
918 ctrl_socket.set_multiline_welcome(true); | 946 ctrl_socket.set_multiline_welcome(true); |
919 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); | 947 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); |
920 } | 948 } |
921 | 949 |
922 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionShortReads2) { | 950 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionShortReads2) { |
923 FtpSocketDataProviderDirectoryListing ctrl_socket; | 951 FtpSocketDataProviderDirectoryListing ctrl_socket; |
924 ctrl_socket.set_short_read_limit(2); | 952 ctrl_socket.set_short_read_limit(2); |
925 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); | 953 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); |
926 } | 954 } |
927 | 955 |
928 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionShortReads5) { | 956 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionShortReads5) { |
929 FtpSocketDataProviderDirectoryListing ctrl_socket; | 957 FtpSocketDataProviderDirectoryListing ctrl_socket; |
930 ctrl_socket.set_short_read_limit(5); | 958 ctrl_socket.set_short_read_limit(5); |
931 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); | 959 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); |
932 } | 960 } |
933 | 961 |
934 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionMultilineWelcomeShort) { | 962 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionMultilineWelcomeShort) { |
935 FtpSocketDataProviderDirectoryListing ctrl_socket; | 963 FtpSocketDataProviderDirectoryListing ctrl_socket; |
936 // The client will not consume all three 230 lines. That's good, we want to | 964 // The client will not consume all three 230 lines. That's good, we want to |
937 // test that scenario. | 965 // test that scenario. |
938 ctrl_socket.allow_unconsumed_reads(true); | 966 ctrl_socket.allow_unconsumed_reads(true); |
939 ctrl_socket.set_multiline_welcome(true); | 967 ctrl_socket.set_multiline_welcome(true); |
940 ctrl_socket.set_short_read_limit(5); | 968 ctrl_socket.set_short_read_limit(5); |
941 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); | 969 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); |
942 } | 970 } |
943 | 971 |
944 // Regression test for http://crbug.com/60555. | 972 // Regression test for http://crbug.com/60555. |
945 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionZeroSize) { | 973 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionZeroSize) { |
946 FtpSocketDataProviderDirectoryListingZeroSize ctrl_socket; | 974 FtpSocketDataProviderDirectoryListingZeroSize ctrl_socket; |
947 ExecuteTransaction(&ctrl_socket, "ftp://host", 0, OK); | 975 ExecuteTransaction(&ctrl_socket, "ftp://host", 0, OK); |
948 } | 976 } |
949 | 977 |
950 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionVMS) { | 978 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionVMS) { |
951 FtpSocketDataProviderVMSDirectoryListing ctrl_socket; | 979 FtpSocketDataProviderVMSDirectoryListing ctrl_socket; |
952 ExecuteTransaction(&ctrl_socket, "ftp://host/dir", 1, OK); | 980 ExecuteTransaction(&ctrl_socket, "ftp://host/dir", 1, OK); |
953 } | 981 } |
954 | 982 |
955 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionVMSRootDirectory) { | 983 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionVMSRootDirectory) { |
956 FtpSocketDataProviderVMSDirectoryListingRootDirectory ctrl_socket; | 984 FtpSocketDataProviderVMSDirectoryListingRootDirectory ctrl_socket; |
957 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); | 985 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); |
958 } | 986 } |
959 | 987 |
960 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionTransferStarting) { | 988 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionTransferStarting) { |
961 FtpSocketDataProviderDirectoryListingTransferStarting ctrl_socket; | 989 FtpSocketDataProviderDirectoryListingTransferStarting ctrl_socket; |
962 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); | 990 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, OK); |
963 } | 991 } |
964 | 992 |
965 TEST_F(FtpNetworkTransactionTest, DownloadTransaction) { | 993 TEST_P(FtpNetworkTransactionTest, DownloadTransaction) { |
966 FtpSocketDataProviderFileDownload ctrl_socket; | 994 FtpSocketDataProviderFileDownload ctrl_socket; |
967 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 995 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
968 | 996 |
969 // We pass an artificial value of 18 as a response to the SIZE command. | 997 // We pass an artificial value of 18 as a response to the SIZE command. |
970 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); | 998 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); |
971 EXPECT_EQ("127.0.0.1", | 999 EXPECT_EQ((GetFamily() == AF_INET) ? "127.0.0.1" : "::1", |
972 transaction_.GetResponseInfo()->socket_address.host()); | 1000 transaction_.GetResponseInfo()->socket_address.host()); |
973 EXPECT_EQ(21, transaction_.GetResponseInfo()->socket_address.port()); | 1001 EXPECT_EQ(21, transaction_.GetResponseInfo()->socket_address.port()); |
974 } | 1002 } |
975 | 1003 |
976 TEST_F(FtpNetworkTransactionTest, DownloadTransactionWithPasvFallback) { | 1004 TEST_P(FtpNetworkTransactionTest, DownloadTransactionWithPasvFallback) { |
977 FtpSocketDataProviderFileDownloadWithPasvFallback ctrl_socket; | 1005 FtpSocketDataProviderFileDownloadWithPasvFallback ctrl_socket; |
978 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 1006 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
979 | 1007 |
980 // We pass an artificial value of 18 as a response to the SIZE command. | 1008 // We pass an artificial value of 18 as a response to the SIZE command. |
981 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); | 1009 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); |
982 } | 1010 } |
983 | 1011 |
984 TEST_F(FtpNetworkTransactionTest, DownloadTransactionWithTypecodeA) { | 1012 TEST_P(FtpNetworkTransactionTest, DownloadTransactionWithTypecodeA) { |
985 FtpSocketDataProviderFileDownloadWithFileTypecode ctrl_socket; | 1013 FtpSocketDataProviderFileDownloadWithFileTypecode ctrl_socket; |
986 ctrl_socket.set_data_type('A'); | 1014 ctrl_socket.set_data_type('A'); |
987 ExecuteTransaction(&ctrl_socket, "ftp://host/file;type=a", 0, OK); | 1015 ExecuteTransaction(&ctrl_socket, "ftp://host/file;type=a", 0, OK); |
988 | 1016 |
989 // We pass an artificial value of 18 as a response to the SIZE command. | 1017 // We pass an artificial value of 18 as a response to the SIZE command. |
990 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); | 1018 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); |
991 } | 1019 } |
992 | 1020 |
993 TEST_F(FtpNetworkTransactionTest, DownloadTransactionWithTypecodeI) { | 1021 TEST_P(FtpNetworkTransactionTest, DownloadTransactionWithTypecodeI) { |
994 FtpSocketDataProviderFileDownloadWithFileTypecode ctrl_socket; | 1022 FtpSocketDataProviderFileDownloadWithFileTypecode ctrl_socket; |
995 ExecuteTransaction(&ctrl_socket, "ftp://host/file;type=i", 0, OK); | 1023 ExecuteTransaction(&ctrl_socket, "ftp://host/file;type=i", 0, OK); |
996 | 1024 |
997 // We pass an artificial value of 18 as a response to the SIZE command. | 1025 // We pass an artificial value of 18 as a response to the SIZE command. |
998 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); | 1026 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); |
999 } | 1027 } |
1000 | 1028 |
1001 TEST_F(FtpNetworkTransactionTest, DownloadTransactionMultilineWelcome) { | 1029 TEST_P(FtpNetworkTransactionTest, DownloadTransactionMultilineWelcome) { |
1002 FtpSocketDataProviderFileDownload ctrl_socket; | 1030 FtpSocketDataProviderFileDownload ctrl_socket; |
1003 ctrl_socket.set_multiline_welcome(true); | 1031 ctrl_socket.set_multiline_welcome(true); |
1004 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 1032 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
1005 } | 1033 } |
1006 | 1034 |
1007 TEST_F(FtpNetworkTransactionTest, DownloadTransactionShortReads2) { | 1035 TEST_P(FtpNetworkTransactionTest, DownloadTransactionShortReads2) { |
1008 FtpSocketDataProviderFileDownload ctrl_socket; | 1036 FtpSocketDataProviderFileDownload ctrl_socket; |
1009 ctrl_socket.set_short_read_limit(2); | 1037 ctrl_socket.set_short_read_limit(2); |
1010 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 1038 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
1011 } | 1039 } |
1012 | 1040 |
1013 TEST_F(FtpNetworkTransactionTest, DownloadTransactionShortReads5) { | 1041 TEST_P(FtpNetworkTransactionTest, DownloadTransactionShortReads5) { |
1014 FtpSocketDataProviderFileDownload ctrl_socket; | 1042 FtpSocketDataProviderFileDownload ctrl_socket; |
1015 ctrl_socket.set_short_read_limit(5); | 1043 ctrl_socket.set_short_read_limit(5); |
1016 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 1044 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
1017 } | 1045 } |
1018 | 1046 |
1019 TEST_F(FtpNetworkTransactionTest, DownloadTransactionZeroSize) { | 1047 TEST_P(FtpNetworkTransactionTest, DownloadTransactionZeroSize) { |
1020 FtpSocketDataProviderFileDownloadZeroSize ctrl_socket; | 1048 FtpSocketDataProviderFileDownloadZeroSize ctrl_socket; |
1021 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 1049 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
1022 } | 1050 } |
1023 | 1051 |
1024 TEST_F(FtpNetworkTransactionTest, DownloadTransactionCWD451) { | 1052 TEST_P(FtpNetworkTransactionTest, DownloadTransactionCWD451) { |
1025 FtpSocketDataProviderFileDownloadCWD451 ctrl_socket; | 1053 FtpSocketDataProviderFileDownloadCWD451 ctrl_socket; |
1026 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 1054 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
1027 } | 1055 } |
1028 | 1056 |
1029 TEST_F(FtpNetworkTransactionTest, DownloadTransactionVMS) { | 1057 TEST_P(FtpNetworkTransactionTest, DownloadTransactionVMS) { |
1030 FtpSocketDataProviderVMSFileDownload ctrl_socket; | 1058 FtpSocketDataProviderVMSFileDownload ctrl_socket; |
1031 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 1059 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
1032 } | 1060 } |
1033 | 1061 |
1034 TEST_F(FtpNetworkTransactionTest, DownloadTransactionTransferStarting) { | 1062 TEST_P(FtpNetworkTransactionTest, DownloadTransactionTransferStarting) { |
1035 FtpSocketDataProviderFileDownloadTransferStarting ctrl_socket; | 1063 FtpSocketDataProviderFileDownloadTransferStarting ctrl_socket; |
1036 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 1064 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
1037 } | 1065 } |
1038 | 1066 |
1039 TEST_F(FtpNetworkTransactionTest, DownloadTransactionInvalidResponse) { | 1067 TEST_P(FtpNetworkTransactionTest, DownloadTransactionInvalidResponse) { |
1040 FtpSocketDataProviderFileDownloadInvalidResponse ctrl_socket; | 1068 FtpSocketDataProviderFileDownloadInvalidResponse ctrl_socket; |
1041 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); | 1069 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); |
1042 } | 1070 } |
1043 | 1071 |
1044 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilPasvReallyBadFormat) { | 1072 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvReallyBadFormat) { |
1045 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,\r\n", | 1073 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,\r\n", |
1046 FtpSocketDataProvider::PRE_QUIT); | 1074 FtpSocketDataProvider::PRE_QUIT); |
1047 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); | 1075 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); |
1048 } | 1076 } |
1049 | 1077 |
1050 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort1) { | 1078 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort1) { |
1051 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,0,22)\r\n", | 1079 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,0,22)\r\n", |
1052 FtpSocketDataProvider::PRE_QUIT); | 1080 FtpSocketDataProvider::PRE_QUIT); |
1053 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); | 1081 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); |
1054 } | 1082 } |
1055 | 1083 |
1056 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort2) { | 1084 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort2) { |
1057 // Still unsafe. 1 * 256 + 2 = 258, which is < 1024. | 1085 // Still unsafe. 1 * 256 + 2 = 258, which is < 1024. |
1058 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,1,2)\r\n", | 1086 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,1,2)\r\n", |
1059 FtpSocketDataProvider::PRE_QUIT); | 1087 FtpSocketDataProvider::PRE_QUIT); |
1060 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); | 1088 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); |
1061 } | 1089 } |
1062 | 1090 |
1063 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort3) { | 1091 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort3) { |
1064 // Still unsafe. 3 * 256 + 4 = 772, which is < 1024. | 1092 // Still unsafe. 3 * 256 + 4 = 772, which is < 1024. |
1065 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,3,4)\r\n", | 1093 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,3,4)\r\n", |
1066 FtpSocketDataProvider::PRE_QUIT); | 1094 FtpSocketDataProvider::PRE_QUIT); |
1067 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); | 1095 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); |
1068 } | 1096 } |
1069 | 1097 |
1070 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort4) { | 1098 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort4) { |
1071 // Unsafe. 8 * 256 + 1 = 2049, which is used by nfs. | 1099 // Unsafe. 8 * 256 + 1 = 2049, which is used by nfs. |
1072 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,8,1)\r\n", | 1100 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,8,1)\r\n", |
1073 FtpSocketDataProvider::PRE_QUIT); | 1101 FtpSocketDataProvider::PRE_QUIT); |
1074 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); | 1102 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); |
1075 } | 1103 } |
1076 | 1104 |
1077 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafeHost) { | 1105 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafeHost) { |
1078 FtpSocketDataProviderEvilPasv ctrl_socket( | 1106 FtpSocketDataProviderEvilPasv ctrl_socket( |
1079 "227 Portscan (10,1,2,3,123,456)\r\n", FtpSocketDataProvider::PRE_SIZE); | 1107 "227 Portscan (10,1,2,3,123,456)\r\n", FtpSocketDataProvider::PRE_SIZE); |
| 1108 ctrl_socket.set_use_epsv(GetFamily() != AF_INET); |
1080 std::string mock_data("mock-data"); | 1109 std::string mock_data("mock-data"); |
1081 MockRead data_reads[] = { | 1110 MockRead data_reads[] = { |
1082 MockRead(mock_data.c_str()), | 1111 MockRead(mock_data.c_str()), |
1083 }; | 1112 }; |
1084 StaticSocketDataProvider data_socket1; | 1113 StaticSocketDataProvider data_socket1; |
1085 StaticSocketDataProvider data_socket2(data_reads, arraysize(data_reads), | 1114 StaticSocketDataProvider data_socket2(data_reads, arraysize(data_reads), |
1086 NULL, 0); | 1115 NULL, 0); |
1087 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket); | 1116 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket); |
1088 mock_socket_factory_.AddSocketDataProvider(&data_socket1); | 1117 mock_socket_factory_.AddSocketDataProvider(&data_socket1); |
1089 mock_socket_factory_.AddSocketDataProvider(&data_socket2); | 1118 mock_socket_factory_.AddSocketDataProvider(&data_socket2); |
(...skipping 14 matching lines...) Expand all Loading... |
1104 | 1133 |
1105 // Even if the PASV response specified some other address, we connect | 1134 // Even if the PASV response specified some other address, we connect |
1106 // to the address we used for control connection (which could be 127.0.0.1 | 1135 // to the address we used for control connection (which could be 127.0.0.1 |
1107 // or ::1 depending on whether we use IPv6). | 1136 // or ::1 depending on whether we use IPv6). |
1108 for (AddressList::const_iterator it = data_socket->addresses().begin(); | 1137 for (AddressList::const_iterator it = data_socket->addresses().begin(); |
1109 it != data_socket->addresses().end(); ++it) { | 1138 it != data_socket->addresses().end(); ++it) { |
1110 EXPECT_NE("10.1.2.3", it->ToStringWithoutPort()); | 1139 EXPECT_NE("10.1.2.3", it->ToStringWithoutPort()); |
1111 } | 1140 } |
1112 } | 1141 } |
1113 | 1142 |
1114 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat1) { | 1143 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat1) { |
| 1144 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1145 if (GetFamily() == AF_INET) |
| 1146 return; |
| 1147 |
1115 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||22)\r\n", | 1148 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||22)\r\n", |
1116 FtpSocketDataProvider::PRE_QUIT); | 1149 FtpSocketDataProvider::PRE_QUIT); |
1117 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); | 1150 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); |
1118 } | 1151 } |
1119 | 1152 |
1120 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat2) { | 1153 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat2) { |
| 1154 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1155 if (GetFamily() == AF_INET) |
| 1156 return; |
| 1157 |
1121 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (||\r\n", | 1158 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (||\r\n", |
1122 FtpSocketDataProvider::PRE_QUIT); | 1159 FtpSocketDataProvider::PRE_QUIT); |
1123 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); | 1160 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); |
1124 } | 1161 } |
1125 | 1162 |
1126 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat3) { | 1163 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat3) { |
| 1164 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1165 if (GetFamily() == AF_INET) |
| 1166 return; |
| 1167 |
1127 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan\r\n", | 1168 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan\r\n", |
1128 FtpSocketDataProvider::PRE_QUIT); | 1169 FtpSocketDataProvider::PRE_QUIT); |
1129 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); | 1170 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); |
1130 } | 1171 } |
1131 | 1172 |
1132 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat4) { | 1173 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat4) { |
| 1174 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1175 if (GetFamily() == AF_INET) |
| 1176 return; |
| 1177 |
1133 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (||||)\r\n", | 1178 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (||||)\r\n", |
1134 FtpSocketDataProvider::PRE_QUIT); | 1179 FtpSocketDataProvider::PRE_QUIT); |
1135 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); | 1180 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); |
1136 } | 1181 } |
1137 | 1182 |
1138 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat5) { | 1183 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat5) { |
| 1184 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1185 if (GetFamily() == AF_INET) |
| 1186 return; |
| 1187 |
1139 const char response[] = "227 Portscan (\0\0\031773\0)\r\n"; | 1188 const char response[] = "227 Portscan (\0\0\031773\0)\r\n"; |
1140 FtpSocketDataProviderEvilEpsv ctrl_socket(response, sizeof(response)-1, | 1189 FtpSocketDataProviderEvilEpsv ctrl_socket(response, sizeof(response)-1, |
1141 FtpSocketDataProvider::PRE_QUIT); | 1190 FtpSocketDataProvider::PRE_QUIT); |
1142 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); | 1191 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); |
1143 } | 1192 } |
1144 | 1193 |
1145 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort1) { | 1194 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort1) { |
| 1195 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1196 if (GetFamily() == AF_INET) |
| 1197 return; |
| 1198 |
1146 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||22|)\r\n", | 1199 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||22|)\r\n", |
1147 FtpSocketDataProvider::PRE_QUIT); | 1200 FtpSocketDataProvider::PRE_QUIT); |
1148 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); | 1201 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); |
1149 } | 1202 } |
1150 | 1203 |
1151 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort2) { | 1204 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort2) { |
| 1205 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1206 if (GetFamily() == AF_INET) |
| 1207 return; |
| 1208 |
1152 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||258|)\r\n", | 1209 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||258|)\r\n", |
1153 FtpSocketDataProvider::PRE_QUIT); | 1210 FtpSocketDataProvider::PRE_QUIT); |
1154 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); | 1211 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); |
1155 } | 1212 } |
1156 | 1213 |
1157 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort3) { | 1214 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort3) { |
| 1215 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1216 if (GetFamily() == AF_INET) |
| 1217 return; |
| 1218 |
1158 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||772|)\r\n", | 1219 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||772|)\r\n", |
1159 FtpSocketDataProvider::PRE_QUIT); | 1220 FtpSocketDataProvider::PRE_QUIT); |
1160 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); | 1221 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); |
1161 } | 1222 } |
1162 | 1223 |
1163 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort4) { | 1224 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort4) { |
| 1225 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1226 if (GetFamily() == AF_INET) |
| 1227 return; |
| 1228 |
1164 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||2049|)\r\n", | 1229 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||2049|)\r\n", |
1165 FtpSocketDataProvider::PRE_QUIT); | 1230 FtpSocketDataProvider::PRE_QUIT); |
1166 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); | 1231 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); |
1167 } | 1232 } |
1168 | 1233 |
1169 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvWeirdSep) { | 1234 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvWeirdSep) { |
| 1235 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1236 if (GetFamily() == AF_INET) |
| 1237 return; |
| 1238 |
1170 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan ($$$31744$)\r\n", | 1239 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan ($$$31744$)\r\n", |
1171 FtpSocketDataProvider::PRE_SIZE); | 1240 FtpSocketDataProvider::PRE_SIZE); |
1172 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 1241 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
1173 } | 1242 } |
1174 | 1243 |
1175 TEST_F(FtpNetworkTransactionTest, | 1244 TEST_P(FtpNetworkTransactionTest, |
1176 DownloadTransactionEvilEpsvWeirdSepUnsafePort) { | 1245 DownloadTransactionEvilEpsvWeirdSepUnsafePort) { |
| 1246 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1247 if (GetFamily() == AF_INET) |
| 1248 return; |
| 1249 |
1177 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan ($$$317$)\r\n", | 1250 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan ($$$317$)\r\n", |
1178 FtpSocketDataProvider::PRE_QUIT); | 1251 FtpSocketDataProvider::PRE_QUIT); |
1179 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); | 1252 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT); |
1180 } | 1253 } |
1181 | 1254 |
1182 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvIllegalHost) { | 1255 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvIllegalHost) { |
| 1256 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1257 if (GetFamily() == AF_INET) |
| 1258 return; |
| 1259 |
1183 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|2|::1|31744|)\r\n", | 1260 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|2|::1|31744|)\r\n", |
1184 FtpSocketDataProvider::PRE_QUIT); | 1261 FtpSocketDataProvider::PRE_QUIT); |
1185 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); | 1262 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); |
1186 } | 1263 } |
1187 | 1264 |
1188 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilLoginBadUsername) { | 1265 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilLoginBadUsername) { |
1189 FtpSocketDataProviderEvilLogin ctrl_socket("hello%0Aworld", "test"); | 1266 FtpSocketDataProviderEvilLogin ctrl_socket("hello%0Aworld", "test"); |
1190 ExecuteTransaction(&ctrl_socket, "ftp://hello%0Aworld:test@host/file", 1, OK); | 1267 ExecuteTransaction(&ctrl_socket, "ftp://hello%0Aworld:test@host/file", 1, OK); |
1191 } | 1268 } |
1192 | 1269 |
1193 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilLoginBadPassword) { | 1270 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilLoginBadPassword) { |
1194 FtpSocketDataProviderEvilLogin ctrl_socket("test", "hello%0Dworld"); | 1271 FtpSocketDataProviderEvilLogin ctrl_socket("test", "hello%0Dworld"); |
1195 ExecuteTransaction(&ctrl_socket, "ftp://test:hello%0Dworld@host/file", 1, OK); | 1272 ExecuteTransaction(&ctrl_socket, "ftp://test:hello%0Dworld@host/file", 1, OK); |
1196 } | 1273 } |
1197 | 1274 |
1198 TEST_F(FtpNetworkTransactionTest, DownloadTransactionSpaceInLogin) { | 1275 TEST_P(FtpNetworkTransactionTest, DownloadTransactionSpaceInLogin) { |
1199 FtpSocketDataProviderEvilLogin ctrl_socket("hello world", "test"); | 1276 FtpSocketDataProviderEvilLogin ctrl_socket("hello world", "test"); |
1200 ExecuteTransaction(&ctrl_socket, "ftp://hello%20world:test@host/file", 1, OK); | 1277 ExecuteTransaction(&ctrl_socket, "ftp://hello%20world:test@host/file", 1, OK); |
1201 } | 1278 } |
1202 | 1279 |
1203 TEST_F(FtpNetworkTransactionTest, DownloadTransactionSpaceInPassword) { | 1280 TEST_P(FtpNetworkTransactionTest, DownloadTransactionSpaceInPassword) { |
1204 FtpSocketDataProviderEvilLogin ctrl_socket("test", "hello world"); | 1281 FtpSocketDataProviderEvilLogin ctrl_socket("test", "hello world"); |
1205 ExecuteTransaction(&ctrl_socket, "ftp://test:hello%20world@host/file", 1, OK); | 1282 ExecuteTransaction(&ctrl_socket, "ftp://test:hello%20world@host/file", 1, OK); |
1206 } | 1283 } |
1207 | 1284 |
1208 TEST_F(FtpNetworkTransactionTest, EvilRestartUser) { | 1285 TEST_P(FtpNetworkTransactionTest, EvilRestartUser) { |
1209 FtpSocketDataProvider ctrl_socket1; | 1286 FtpSocketDataProvider ctrl_socket1; |
1210 ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD, | 1287 ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD, |
1211 FtpSocketDataProvider::PRE_QUIT, | 1288 FtpSocketDataProvider::PRE_QUIT, |
1212 "530 Login authentication failed\r\n"); | 1289 "530 Login authentication failed\r\n"); |
1213 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1); | 1290 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1); |
1214 | 1291 |
1215 FtpRequestInfo request_info = GetRequestInfo("ftp://host/file"); | 1292 FtpRequestInfo request_info = GetRequestInfo("ftp://host/file"); |
1216 | 1293 |
1217 ASSERT_EQ(ERR_IO_PENDING, | 1294 ASSERT_EQ(ERR_IO_PENDING, |
1218 transaction_.Start(&request_info, callback_.callback(), | 1295 transaction_.Start(&request_info, callback_.callback(), |
(...skipping 13 matching lines...) Expand all Loading... |
1232 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); | 1309 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); |
1233 ASSERT_EQ(ERR_IO_PENDING, | 1310 ASSERT_EQ(ERR_IO_PENDING, |
1234 transaction_.RestartWithAuth( | 1311 transaction_.RestartWithAuth( |
1235 AuthCredentials( | 1312 AuthCredentials( |
1236 ASCIIToUTF16("foo\nownz0red"), | 1313 ASCIIToUTF16("foo\nownz0red"), |
1237 ASCIIToUTF16("innocent")), | 1314 ASCIIToUTF16("innocent")), |
1238 callback_.callback())); | 1315 callback_.callback())); |
1239 EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult()); | 1316 EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult()); |
1240 } | 1317 } |
1241 | 1318 |
1242 TEST_F(FtpNetworkTransactionTest, EvilRestartPassword) { | 1319 TEST_P(FtpNetworkTransactionTest, EvilRestartPassword) { |
1243 FtpSocketDataProvider ctrl_socket1; | 1320 FtpSocketDataProvider ctrl_socket1; |
1244 ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD, | 1321 ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD, |
1245 FtpSocketDataProvider::PRE_QUIT, | 1322 FtpSocketDataProvider::PRE_QUIT, |
1246 "530 Login authentication failed\r\n"); | 1323 "530 Login authentication failed\r\n"); |
1247 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1); | 1324 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1); |
1248 | 1325 |
1249 FtpRequestInfo request_info = GetRequestInfo("ftp://host/file"); | 1326 FtpRequestInfo request_info = GetRequestInfo("ftp://host/file"); |
1250 | 1327 |
1251 ASSERT_EQ(ERR_IO_PENDING, | 1328 ASSERT_EQ(ERR_IO_PENDING, |
1252 transaction_.Start(&request_info, callback_.callback(), | 1329 transaction_.Start(&request_info, callback_.callback(), |
(...skipping 14 matching lines...) Expand all Loading... |
1267 ctrl_writes, arraysize(ctrl_writes)); | 1344 ctrl_writes, arraysize(ctrl_writes)); |
1268 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); | 1345 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); |
1269 ASSERT_EQ(ERR_IO_PENDING, | 1346 ASSERT_EQ(ERR_IO_PENDING, |
1270 transaction_.RestartWithAuth( | 1347 transaction_.RestartWithAuth( |
1271 AuthCredentials(ASCIIToUTF16("innocent"), | 1348 AuthCredentials(ASCIIToUTF16("innocent"), |
1272 ASCIIToUTF16("foo\nownz0red")), | 1349 ASCIIToUTF16("foo\nownz0red")), |
1273 callback_.callback())); | 1350 callback_.callback())); |
1274 EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult()); | 1351 EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult()); |
1275 } | 1352 } |
1276 | 1353 |
1277 TEST_F(FtpNetworkTransactionTest, Escaping) { | 1354 TEST_P(FtpNetworkTransactionTest, Escaping) { |
1278 FtpSocketDataProviderEscaping ctrl_socket; | 1355 FtpSocketDataProviderEscaping ctrl_socket; |
1279 ExecuteTransaction(&ctrl_socket, "ftp://host/%20%21%22%23%24%25%79%80%81", | 1356 ExecuteTransaction(&ctrl_socket, "ftp://host/%20%21%22%23%24%25%79%80%81", |
1280 1, OK); | 1357 1, OK); |
1281 } | 1358 } |
1282 | 1359 |
1283 // Test for http://crbug.com/23794. | 1360 // Test for http://crbug.com/23794. |
1284 TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilSize) { | 1361 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilSize) { |
1285 // Try to overflow int64 in the response. | 1362 // Try to overflow int64 in the response. |
1286 FtpSocketDataProviderEvilSize ctrl_socket( | 1363 FtpSocketDataProviderEvilSize ctrl_socket( |
1287 "213 99999999999999999999999999999999\r\n", | 1364 "213 99999999999999999999999999999999\r\n", |
1288 FtpSocketDataProvider::PRE_QUIT); | 1365 FtpSocketDataProvider::PRE_QUIT); |
1289 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); | 1366 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE); |
1290 } | 1367 } |
1291 | 1368 |
1292 // Test for http://crbug.com/36360. | 1369 // Test for http://crbug.com/36360. |
1293 TEST_F(FtpNetworkTransactionTest, DownloadTransactionBigSize) { | 1370 TEST_P(FtpNetworkTransactionTest, DownloadTransactionBigSize) { |
1294 // Pass a valid, but large file size. The transaction should not fail. | 1371 // Pass a valid, but large file size. The transaction should not fail. |
1295 FtpSocketDataProviderEvilSize ctrl_socket( | 1372 FtpSocketDataProviderEvilSize ctrl_socket( |
1296 "213 3204427776\r\n", | 1373 "213 3204427776\r\n", |
1297 FtpSocketDataProvider::PRE_CWD); | 1374 FtpSocketDataProvider::PRE_CWD); |
1298 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); | 1375 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK); |
1299 EXPECT_EQ(3204427776LL, | 1376 EXPECT_EQ(3204427776LL, |
1300 transaction_.GetResponseInfo()->expected_content_size); | 1377 transaction_.GetResponseInfo()->expected_content_size); |
1301 } | 1378 } |
1302 | 1379 |
1303 // Regression test for http://crbug.com/25023. | 1380 // Regression test for http://crbug.com/25023. |
1304 TEST_F(FtpNetworkTransactionTest, CloseConnection) { | 1381 TEST_P(FtpNetworkTransactionTest, CloseConnection) { |
1305 FtpSocketDataProviderCloseConnection ctrl_socket; | 1382 FtpSocketDataProviderCloseConnection ctrl_socket; |
1306 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, ERR_EMPTY_RESPONSE); | 1383 ExecuteTransaction(&ctrl_socket, "ftp://host", 1, ERR_EMPTY_RESPONSE); |
1307 } | 1384 } |
1308 | 1385 |
1309 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailUser) { | 1386 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailUser) { |
1310 FtpSocketDataProviderDirectoryListing ctrl_socket; | 1387 FtpSocketDataProviderDirectoryListing ctrl_socket; |
1311 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1388 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1312 // ERR_FTP_FAILED bucket. | 1389 // ERR_FTP_FAILED bucket. |
1313 TransactionFailHelper(&ctrl_socket, | 1390 TransactionFailHelper(&ctrl_socket, |
1314 "ftp://host", | 1391 "ftp://host", |
1315 FtpSocketDataProvider::PRE_USER, | 1392 FtpSocketDataProvider::PRE_USER, |
1316 FtpSocketDataProvider::PRE_QUIT, | 1393 FtpSocketDataProvider::PRE_QUIT, |
1317 "599 fail\r\n", | 1394 "599 fail\r\n", |
1318 ERR_FTP_FAILED); | 1395 ERR_FTP_FAILED); |
1319 } | 1396 } |
1320 | 1397 |
1321 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailPass) { | 1398 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailPass) { |
1322 FtpSocketDataProviderDirectoryListing ctrl_socket; | 1399 FtpSocketDataProviderDirectoryListing ctrl_socket; |
1323 TransactionFailHelper(&ctrl_socket, | 1400 TransactionFailHelper(&ctrl_socket, |
1324 "ftp://host", | 1401 "ftp://host", |
1325 FtpSocketDataProvider::PRE_PASSWD, | 1402 FtpSocketDataProvider::PRE_PASSWD, |
1326 FtpSocketDataProvider::PRE_QUIT, | 1403 FtpSocketDataProvider::PRE_QUIT, |
1327 "530 Login authentication failed\r\n", | 1404 "530 Login authentication failed\r\n", |
1328 ERR_FTP_FAILED); | 1405 ERR_FTP_FAILED); |
1329 } | 1406 } |
1330 | 1407 |
1331 // Regression test for http://crbug.com/38707. | 1408 // Regression test for http://crbug.com/38707. |
1332 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailPass503) { | 1409 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailPass503) { |
1333 FtpSocketDataProviderDirectoryListing ctrl_socket; | 1410 FtpSocketDataProviderDirectoryListing ctrl_socket; |
1334 TransactionFailHelper(&ctrl_socket, | 1411 TransactionFailHelper(&ctrl_socket, |
1335 "ftp://host", | 1412 "ftp://host", |
1336 FtpSocketDataProvider::PRE_PASSWD, | 1413 FtpSocketDataProvider::PRE_PASSWD, |
1337 FtpSocketDataProvider::PRE_QUIT, | 1414 FtpSocketDataProvider::PRE_QUIT, |
1338 "503 Bad sequence of commands\r\n", | 1415 "503 Bad sequence of commands\r\n", |
1339 ERR_FTP_BAD_COMMAND_SEQUENCE); | 1416 ERR_FTP_BAD_COMMAND_SEQUENCE); |
1340 } | 1417 } |
1341 | 1418 |
1342 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailSyst) { | 1419 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailSyst) { |
1343 FtpSocketDataProviderDirectoryListing ctrl_socket; | 1420 FtpSocketDataProviderDirectoryListing ctrl_socket; |
1344 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1421 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1345 // ERR_FTP_FAILED bucket. | 1422 // ERR_FTP_FAILED bucket. |
1346 TransactionFailHelper(&ctrl_socket, | 1423 TransactionFailHelper(&ctrl_socket, |
1347 "ftp://host", | 1424 "ftp://host", |
1348 FtpSocketDataProvider::PRE_SYST, | 1425 FtpSocketDataProvider::PRE_SYST, |
1349 FtpSocketDataProvider::PRE_PWD, | 1426 FtpSocketDataProvider::PRE_PWD, |
1350 "599 fail\r\n", | 1427 "599 fail\r\n", |
1351 OK); | 1428 OK); |
1352 } | 1429 } |
1353 | 1430 |
1354 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailPwd) { | 1431 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailPwd) { |
1355 FtpSocketDataProviderDirectoryListing ctrl_socket; | 1432 FtpSocketDataProviderDirectoryListing ctrl_socket; |
1356 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1433 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1357 // ERR_FTP_FAILED bucket. | 1434 // ERR_FTP_FAILED bucket. |
1358 TransactionFailHelper(&ctrl_socket, | 1435 TransactionFailHelper(&ctrl_socket, |
1359 "ftp://host", | 1436 "ftp://host", |
1360 FtpSocketDataProvider::PRE_PWD, | 1437 FtpSocketDataProvider::PRE_PWD, |
1361 FtpSocketDataProvider::PRE_QUIT, | 1438 FtpSocketDataProvider::PRE_QUIT, |
1362 "599 fail\r\n", | 1439 "599 fail\r\n", |
1363 ERR_FTP_FAILED); | 1440 ERR_FTP_FAILED); |
1364 } | 1441 } |
1365 | 1442 |
1366 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailType) { | 1443 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailType) { |
1367 FtpSocketDataProviderDirectoryListing ctrl_socket; | 1444 FtpSocketDataProviderDirectoryListing ctrl_socket; |
1368 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1445 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1369 // ERR_FTP_FAILED bucket. | 1446 // ERR_FTP_FAILED bucket. |
1370 TransactionFailHelper(&ctrl_socket, | 1447 TransactionFailHelper(&ctrl_socket, |
1371 "ftp://host", | 1448 "ftp://host", |
1372 FtpSocketDataProvider::PRE_TYPE, | 1449 FtpSocketDataProvider::PRE_TYPE, |
1373 FtpSocketDataProvider::PRE_QUIT, | 1450 FtpSocketDataProvider::PRE_QUIT, |
1374 "599 fail\r\n", | 1451 "599 fail\r\n", |
1375 ERR_FTP_FAILED); | 1452 ERR_FTP_FAILED); |
1376 } | 1453 } |
1377 | 1454 |
1378 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailEpsv) { | 1455 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailEpsv) { |
| 1456 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1457 if (GetFamily() == AF_INET) |
| 1458 return; |
| 1459 |
1379 FtpSocketDataProviderDirectoryListing ctrl_socket; | 1460 FtpSocketDataProviderDirectoryListing ctrl_socket; |
1380 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1461 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1381 // ERR_FTP_FAILED bucket. | 1462 // ERR_FTP_FAILED bucket. |
1382 TransactionFailHelper(&ctrl_socket, | 1463 TransactionFailHelper(&ctrl_socket, |
1383 "ftp://host", | 1464 "ftp://host", |
1384 FtpSocketDataProvider::PRE_EPSV, | 1465 FtpSocketDataProvider::PRE_EPSV, |
1385 FtpSocketDataProvider::PRE_NOPASV, | 1466 FtpSocketDataProvider::PRE_NOPASV, |
1386 "599 fail\r\n", | 1467 "599 fail\r\n", |
1387 ERR_FTP_FAILED); | 1468 ERR_FTP_FAILED); |
1388 } | 1469 } |
1389 | 1470 |
1390 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailCwd) { | 1471 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailCwd) { |
1391 FtpSocketDataProviderDirectoryListing ctrl_socket; | 1472 FtpSocketDataProviderDirectoryListing ctrl_socket; |
1392 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1473 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1393 // ERR_FTP_FAILED bucket. | 1474 // ERR_FTP_FAILED bucket. |
1394 TransactionFailHelper(&ctrl_socket, | 1475 TransactionFailHelper(&ctrl_socket, |
1395 "ftp://host", | 1476 "ftp://host", |
1396 FtpSocketDataProvider::PRE_CWD, | 1477 FtpSocketDataProvider::PRE_CWD, |
1397 FtpSocketDataProvider::PRE_QUIT, | 1478 FtpSocketDataProvider::PRE_QUIT, |
1398 "599 fail\r\n", | 1479 "599 fail\r\n", |
1399 ERR_FTP_FAILED); | 1480 ERR_FTP_FAILED); |
1400 } | 1481 } |
1401 | 1482 |
1402 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailList) { | 1483 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailList) { |
1403 FtpSocketDataProviderVMSDirectoryListing ctrl_socket; | 1484 FtpSocketDataProviderVMSDirectoryListing ctrl_socket; |
1404 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1485 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1405 // ERR_FTP_FAILED bucket. | 1486 // ERR_FTP_FAILED bucket. |
1406 TransactionFailHelper(&ctrl_socket, | 1487 TransactionFailHelper(&ctrl_socket, |
1407 "ftp://host/dir", | 1488 "ftp://host/dir", |
1408 FtpSocketDataProvider::PRE_LIST, | 1489 FtpSocketDataProvider::PRE_LIST, |
1409 FtpSocketDataProvider::PRE_QUIT, | 1490 FtpSocketDataProvider::PRE_QUIT, |
1410 "599 fail\r\n", | 1491 "599 fail\r\n", |
1411 ERR_FTP_FAILED); | 1492 ERR_FTP_FAILED); |
1412 } | 1493 } |
1413 | 1494 |
1414 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailUser) { | 1495 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailUser) { |
1415 FtpSocketDataProviderFileDownload ctrl_socket; | 1496 FtpSocketDataProviderFileDownload ctrl_socket; |
1416 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1497 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1417 // ERR_FTP_FAILED bucket. | 1498 // ERR_FTP_FAILED bucket. |
1418 TransactionFailHelper(&ctrl_socket, | 1499 TransactionFailHelper(&ctrl_socket, |
1419 "ftp://host/file", | 1500 "ftp://host/file", |
1420 FtpSocketDataProvider::PRE_USER, | 1501 FtpSocketDataProvider::PRE_USER, |
1421 FtpSocketDataProvider::PRE_QUIT, | 1502 FtpSocketDataProvider::PRE_QUIT, |
1422 "599 fail\r\n", | 1503 "599 fail\r\n", |
1423 ERR_FTP_FAILED); | 1504 ERR_FTP_FAILED); |
1424 } | 1505 } |
1425 | 1506 |
1426 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailPass) { | 1507 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailPass) { |
1427 FtpSocketDataProviderFileDownload ctrl_socket; | 1508 FtpSocketDataProviderFileDownload ctrl_socket; |
1428 TransactionFailHelper(&ctrl_socket, | 1509 TransactionFailHelper(&ctrl_socket, |
1429 "ftp://host/file", | 1510 "ftp://host/file", |
1430 FtpSocketDataProvider::PRE_PASSWD, | 1511 FtpSocketDataProvider::PRE_PASSWD, |
1431 FtpSocketDataProvider::PRE_QUIT, | 1512 FtpSocketDataProvider::PRE_QUIT, |
1432 "530 Login authentication failed\r\n", | 1513 "530 Login authentication failed\r\n", |
1433 ERR_FTP_FAILED); | 1514 ERR_FTP_FAILED); |
1434 } | 1515 } |
1435 | 1516 |
1436 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailSyst) { | 1517 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailSyst) { |
1437 FtpSocketDataProviderFileDownload ctrl_socket; | 1518 FtpSocketDataProviderFileDownload ctrl_socket; |
1438 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1519 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1439 // ERR_FTP_FAILED bucket. | 1520 // ERR_FTP_FAILED bucket. |
1440 TransactionFailHelper(&ctrl_socket, | 1521 TransactionFailHelper(&ctrl_socket, |
1441 "ftp://host/file", | 1522 "ftp://host/file", |
1442 FtpSocketDataProvider::PRE_SYST, | 1523 FtpSocketDataProvider::PRE_SYST, |
1443 FtpSocketDataProvider::PRE_PWD, | 1524 FtpSocketDataProvider::PRE_PWD, |
1444 "599 fail\r\n", | 1525 "599 fail\r\n", |
1445 OK); | 1526 OK); |
1446 } | 1527 } |
1447 | 1528 |
1448 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailPwd) { | 1529 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailPwd) { |
1449 FtpSocketDataProviderFileDownload ctrl_socket; | 1530 FtpSocketDataProviderFileDownload ctrl_socket; |
1450 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1531 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1451 // ERR_FTP_FAILED bucket. | 1532 // ERR_FTP_FAILED bucket. |
1452 TransactionFailHelper(&ctrl_socket, | 1533 TransactionFailHelper(&ctrl_socket, |
1453 "ftp://host/file", | 1534 "ftp://host/file", |
1454 FtpSocketDataProvider::PRE_PWD, | 1535 FtpSocketDataProvider::PRE_PWD, |
1455 FtpSocketDataProvider::PRE_QUIT, | 1536 FtpSocketDataProvider::PRE_QUIT, |
1456 "599 fail\r\n", | 1537 "599 fail\r\n", |
1457 ERR_FTP_FAILED); | 1538 ERR_FTP_FAILED); |
1458 } | 1539 } |
1459 | 1540 |
1460 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailType) { | 1541 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailType) { |
1461 FtpSocketDataProviderFileDownload ctrl_socket; | 1542 FtpSocketDataProviderFileDownload ctrl_socket; |
1462 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1543 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1463 // ERR_FTP_FAILED bucket. | 1544 // ERR_FTP_FAILED bucket. |
1464 TransactionFailHelper(&ctrl_socket, | 1545 TransactionFailHelper(&ctrl_socket, |
1465 "ftp://host/file", | 1546 "ftp://host/file", |
1466 FtpSocketDataProvider::PRE_TYPE, | 1547 FtpSocketDataProvider::PRE_TYPE, |
1467 FtpSocketDataProvider::PRE_QUIT, | 1548 FtpSocketDataProvider::PRE_QUIT, |
1468 "599 fail\r\n", | 1549 "599 fail\r\n", |
1469 ERR_FTP_FAILED); | 1550 ERR_FTP_FAILED); |
1470 } | 1551 } |
1471 | 1552 |
1472 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailEpsv) { | 1553 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailEpsv) { |
| 1554 // This test makes no sense for IPv4 connections (we don't use EPSV there). |
| 1555 if (GetFamily() == AF_INET) |
| 1556 return; |
| 1557 |
1473 FtpSocketDataProviderFileDownload ctrl_socket; | 1558 FtpSocketDataProviderFileDownload ctrl_socket; |
1474 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1559 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1475 // ERR_FTP_FAILED bucket. | 1560 // ERR_FTP_FAILED bucket. |
1476 TransactionFailHelper(&ctrl_socket, | 1561 TransactionFailHelper(&ctrl_socket, |
1477 "ftp://host/file", | 1562 "ftp://host/file", |
1478 FtpSocketDataProvider::PRE_EPSV, | 1563 FtpSocketDataProvider::PRE_EPSV, |
1479 FtpSocketDataProvider::PRE_NOPASV, | 1564 FtpSocketDataProvider::PRE_NOPASV, |
1480 "599 fail\r\n", | 1565 "599 fail\r\n", |
1481 ERR_FTP_FAILED); | 1566 ERR_FTP_FAILED); |
1482 } | 1567 } |
1483 | 1568 |
1484 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailRetr) { | 1569 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailRetr) { |
1485 FtpSocketDataProviderFileDownload ctrl_socket; | 1570 FtpSocketDataProviderFileDownload ctrl_socket; |
1486 // Use unallocated 599 FTP error code to make sure it falls into the generic | 1571 // Use unallocated 599 FTP error code to make sure it falls into the generic |
1487 // ERR_FTP_FAILED bucket. | 1572 // ERR_FTP_FAILED bucket. |
1488 TransactionFailHelper(&ctrl_socket, | 1573 TransactionFailHelper(&ctrl_socket, |
1489 "ftp://host/file", | 1574 "ftp://host/file", |
1490 FtpSocketDataProvider::PRE_RETR, | 1575 FtpSocketDataProvider::PRE_RETR, |
1491 FtpSocketDataProvider::PRE_QUIT, | 1576 FtpSocketDataProvider::PRE_QUIT, |
1492 "599 fail\r\n", | 1577 "599 fail\r\n", |
1493 ERR_FTP_FAILED); | 1578 ERR_FTP_FAILED); |
1494 } | 1579 } |
1495 | 1580 |
1496 TEST_F(FtpNetworkTransactionTest, FileNotFound) { | 1581 TEST_P(FtpNetworkTransactionTest, FileNotFound) { |
1497 FtpSocketDataProviderFileNotFound ctrl_socket; | 1582 FtpSocketDataProviderFileNotFound ctrl_socket; |
1498 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 2, ERR_FTP_FAILED); | 1583 ExecuteTransaction(&ctrl_socket, "ftp://host/file", 2, ERR_FTP_FAILED); |
1499 } | 1584 } |
1500 | 1585 |
1501 // Test for http://crbug.com/38845. | 1586 // Test for http://crbug.com/38845. |
1502 TEST_F(FtpNetworkTransactionTest, ZeroLengthDirInPWD) { | 1587 TEST_P(FtpNetworkTransactionTest, ZeroLengthDirInPWD) { |
1503 FtpSocketDataProviderFileDownload ctrl_socket; | 1588 FtpSocketDataProviderFileDownload ctrl_socket; |
1504 TransactionFailHelper(&ctrl_socket, | 1589 TransactionFailHelper(&ctrl_socket, |
1505 "ftp://host/file", | 1590 "ftp://host/file", |
1506 FtpSocketDataProvider::PRE_PWD, | 1591 FtpSocketDataProvider::PRE_PWD, |
1507 FtpSocketDataProvider::PRE_TYPE, | 1592 FtpSocketDataProvider::PRE_TYPE, |
1508 "257 \"\"\r\n", | 1593 "257 \"\"\r\n", |
1509 OK); | 1594 OK); |
1510 } | 1595 } |
1511 | 1596 |
| 1597 INSTANTIATE_TEST_CASE_P(FTP, |
| 1598 FtpNetworkTransactionTest, |
| 1599 ::testing::Values(AF_INET, AF_INET6)); |
| 1600 |
1512 } // namespace net | 1601 } // namespace net |
OLD | NEW |