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 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
53 | 53 |
54 FtpSocketDataProvider() | 54 FtpSocketDataProvider() |
55 : failure_injection_state_(NONE), | 55 : failure_injection_state_(NONE), |
56 multiline_welcome_(false), | 56 multiline_welcome_(false), |
57 data_type_('I') { | 57 data_type_('I') { |
58 Init(); | 58 Init(); |
59 } | 59 } |
60 | 60 |
61 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 61 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
62 if (InjectFault()) | 62 if (InjectFault()) |
63 return MockWriteResult(true, data.length()); | 63 return MockWriteResult(ASYNC, data.length()); |
64 switch (state()) { | 64 switch (state()) { |
65 case PRE_USER: | 65 case PRE_USER: |
66 return Verify("USER anonymous\r\n", data, PRE_PASSWD, | 66 return Verify("USER anonymous\r\n", data, PRE_PASSWD, |
67 "331 Password needed\r\n"); | 67 "331 Password needed\r\n"); |
68 case PRE_PASSWD: | 68 case PRE_PASSWD: |
69 { | 69 { |
70 const char* response_one = "230 Welcome\r\n"; | 70 const char* response_one = "230 Welcome\r\n"; |
71 const char* response_multi = "230- One\r\n230- Two\r\n230 Three\r\n"; | 71 const char* response_multi = "230- One\r\n230- Two\r\n230 Three\r\n"; |
72 return Verify("PASS chrome@example.com\r\n", data, PRE_SYST, | 72 return Verify("PASS chrome@example.com\r\n", data, PRE_SYST, |
73 multiline_welcome_ ? response_multi : response_one); | 73 multiline_welcome_ ? response_multi : response_one); |
(...skipping 11 matching lines...) Expand all Loading... |
85 "227 Entering Extended Passive Mode (|||31744|)\r\n"); | 85 "227 Entering Extended Passive Mode (|||31744|)\r\n"); |
86 case PRE_NOPASV: | 86 case PRE_NOPASV: |
87 // Use unallocated 599 FTP error code to make sure it falls into the | 87 // Use unallocated 599 FTP error code to make sure it falls into the |
88 // generic ERR_FTP_FAILED bucket. | 88 // generic ERR_FTP_FAILED bucket. |
89 return Verify("PASV\r\n", data, PRE_QUIT, | 89 return Verify("PASV\r\n", data, PRE_QUIT, |
90 "599 fail\r\n"); | 90 "599 fail\r\n"); |
91 case PRE_QUIT: | 91 case PRE_QUIT: |
92 return Verify("QUIT\r\n", data, QUIT, "221 Goodbye.\r\n"); | 92 return Verify("QUIT\r\n", data, QUIT, "221 Goodbye.\r\n"); |
93 default: | 93 default: |
94 NOTREACHED() << "State not handled " << state(); | 94 NOTREACHED() << "State not handled " << state(); |
95 return MockWriteResult(true, ERR_UNEXPECTED); | 95 return MockWriteResult(ASYNC, ERR_UNEXPECTED); |
96 } | 96 } |
97 } | 97 } |
98 | 98 |
99 void InjectFailure(State state, State next_state, const char* response) { | 99 void InjectFailure(State state, State next_state, const char* response) { |
100 DCHECK_EQ(NONE, failure_injection_state_); | 100 DCHECK_EQ(NONE, failure_injection_state_); |
101 DCHECK_NE(NONE, state); | 101 DCHECK_NE(NONE, state); |
102 DCHECK_NE(NONE, next_state); | 102 DCHECK_NE(NONE, next_state); |
103 DCHECK_NE(state, next_state); | 103 DCHECK_NE(state, next_state); |
104 failure_injection_state_ = state; | 104 failure_injection_state_ = state; |
105 failure_injection_next_state_ = next_state; | 105 failure_injection_next_state_ = next_state; |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
141 | 141 |
142 MockWriteResult Verify(const std::string& expected, | 142 MockWriteResult Verify(const std::string& expected, |
143 const std::string& data, | 143 const std::string& data, |
144 State next_state, | 144 State next_state, |
145 const char* next_read, | 145 const char* next_read, |
146 const size_t next_read_length) { | 146 const size_t next_read_length) { |
147 EXPECT_EQ(expected, data); | 147 EXPECT_EQ(expected, data); |
148 if (expected == data) { | 148 if (expected == data) { |
149 state_ = next_state; | 149 state_ = next_state; |
150 SimulateRead(next_read, next_read_length); | 150 SimulateRead(next_read, next_read_length); |
151 return MockWriteResult(true, data.length()); | 151 return MockWriteResult(ASYNC, data.length()); |
152 } | 152 } |
153 return MockWriteResult(true, ERR_UNEXPECTED); | 153 return MockWriteResult(ASYNC, ERR_UNEXPECTED); |
154 } | 154 } |
155 | 155 |
156 MockWriteResult Verify(const std::string& expected, | 156 MockWriteResult Verify(const std::string& expected, |
157 const std::string& data, | 157 const std::string& data, |
158 State next_state, | 158 State next_state, |
159 const char* next_read) { | 159 const char* next_read) { |
160 return Verify(expected, data, next_state, | 160 return Verify(expected, data, next_state, |
161 next_read, std::strlen(next_read)); | 161 next_read, std::strlen(next_read)); |
162 } | 162 } |
163 | 163 |
(...skipping 13 matching lines...) Expand all Loading... |
177 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProvider); | 177 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProvider); |
178 }; | 178 }; |
179 | 179 |
180 class FtpSocketDataProviderDirectoryListing : public FtpSocketDataProvider { | 180 class FtpSocketDataProviderDirectoryListing : public FtpSocketDataProvider { |
181 public: | 181 public: |
182 FtpSocketDataProviderDirectoryListing() { | 182 FtpSocketDataProviderDirectoryListing() { |
183 } | 183 } |
184 | 184 |
185 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 185 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
186 if (InjectFault()) | 186 if (InjectFault()) |
187 return MockWriteResult(true, data.length()); | 187 return MockWriteResult(ASYNC, data.length()); |
188 switch (state()) { | 188 switch (state()) { |
189 case PRE_SIZE: | 189 case PRE_SIZE: |
190 return Verify("SIZE /\r\n", data, PRE_CWD, | 190 return Verify("SIZE /\r\n", data, PRE_CWD, |
191 "550 I can only retrieve regular files\r\n"); | 191 "550 I can only retrieve regular files\r\n"); |
192 case PRE_CWD: | 192 case PRE_CWD: |
193 return Verify("CWD /\r\n", data, PRE_LIST, "200 OK\r\n"); | 193 return Verify("CWD /\r\n", data, PRE_LIST, "200 OK\r\n"); |
194 case PRE_LIST: | 194 case PRE_LIST: |
195 return Verify("LIST\r\n", data, PRE_QUIT, "200 OK\r\n"); | 195 return Verify("LIST\r\n", data, PRE_QUIT, "200 OK\r\n"); |
196 default: | 196 default: |
197 return FtpSocketDataProvider::OnWrite(data); | 197 return FtpSocketDataProvider::OnWrite(data); |
198 } | 198 } |
199 } | 199 } |
200 | 200 |
201 private: | 201 private: |
202 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListing); | 202 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListing); |
203 }; | 203 }; |
204 | 204 |
205 class FtpSocketDataProviderDirectoryListingWithPasvFallback | 205 class FtpSocketDataProviderDirectoryListingWithPasvFallback |
206 : public FtpSocketDataProviderDirectoryListing { | 206 : public FtpSocketDataProviderDirectoryListing { |
207 public: | 207 public: |
208 FtpSocketDataProviderDirectoryListingWithPasvFallback() { | 208 FtpSocketDataProviderDirectoryListingWithPasvFallback() { |
209 } | 209 } |
210 | 210 |
211 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 211 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
212 if (InjectFault()) | 212 if (InjectFault()) |
213 return MockWriteResult(true, data.length()); | 213 return MockWriteResult(ASYNC, data.length()); |
214 switch (state()) { | 214 switch (state()) { |
215 case PRE_EPSV: | 215 case PRE_EPSV: |
216 return Verify("EPSV\r\n", data, PRE_PASV, | 216 return Verify("EPSV\r\n", data, PRE_PASV, |
217 "500 no EPSV for you\r\n"); | 217 "500 no EPSV for you\r\n"); |
218 case PRE_PASV: | 218 case PRE_PASV: |
219 return Verify("PASV\r\n", data, PRE_SIZE, | 219 return Verify("PASV\r\n", data, PRE_SIZE, |
220 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | 220 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); |
221 default: | 221 default: |
222 return FtpSocketDataProviderDirectoryListing::OnWrite(data); | 222 return FtpSocketDataProviderDirectoryListing::OnWrite(data); |
223 } | 223 } |
224 } | 224 } |
225 | 225 |
226 private: | 226 private: |
227 DISALLOW_COPY_AND_ASSIGN( | 227 DISALLOW_COPY_AND_ASSIGN( |
228 FtpSocketDataProviderDirectoryListingWithPasvFallback); | 228 FtpSocketDataProviderDirectoryListingWithPasvFallback); |
229 }; | 229 }; |
230 | 230 |
231 class FtpSocketDataProviderDirectoryListingZeroSize | 231 class FtpSocketDataProviderDirectoryListingZeroSize |
232 : public FtpSocketDataProviderDirectoryListing { | 232 : public FtpSocketDataProviderDirectoryListing { |
233 public: | 233 public: |
234 FtpSocketDataProviderDirectoryListingZeroSize() { | 234 FtpSocketDataProviderDirectoryListingZeroSize() { |
235 } | 235 } |
236 | 236 |
237 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 237 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
238 if (InjectFault()) | 238 if (InjectFault()) |
239 return MockWriteResult(true, data.length()); | 239 return MockWriteResult(ASYNC, data.length()); |
240 switch (state()) { | 240 switch (state()) { |
241 case PRE_SIZE: | 241 case PRE_SIZE: |
242 return Verify("SIZE /\r\n", data, PRE_CWD, "213 0\r\n"); | 242 return Verify("SIZE /\r\n", data, PRE_CWD, "213 0\r\n"); |
243 default: | 243 default: |
244 return FtpSocketDataProviderDirectoryListing::OnWrite(data); | 244 return FtpSocketDataProviderDirectoryListing::OnWrite(data); |
245 } | 245 } |
246 } | 246 } |
247 | 247 |
248 private: | 248 private: |
249 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListingZeroSize); | 249 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListingZeroSize); |
250 }; | 250 }; |
251 | 251 |
252 class FtpSocketDataProviderVMSDirectoryListing : public FtpSocketDataProvider { | 252 class FtpSocketDataProviderVMSDirectoryListing : public FtpSocketDataProvider { |
253 public: | 253 public: |
254 FtpSocketDataProviderVMSDirectoryListing() { | 254 FtpSocketDataProviderVMSDirectoryListing() { |
255 } | 255 } |
256 | 256 |
257 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 257 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
258 if (InjectFault()) | 258 if (InjectFault()) |
259 return MockWriteResult(true, data.length()); | 259 return MockWriteResult(ASYNC, data.length()); |
260 switch (state()) { | 260 switch (state()) { |
261 case PRE_SYST: | 261 case PRE_SYST: |
262 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); | 262 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); |
263 case PRE_PWD: | 263 case PRE_PWD: |
264 return Verify("PWD\r\n", data, PRE_TYPE, | 264 return Verify("PWD\r\n", data, PRE_TYPE, |
265 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); | 265 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); |
266 case PRE_EPSV: | 266 case PRE_EPSV: |
267 return Verify("EPSV\r\n", data, PRE_PASV, "500 Invalid command\r\n"); | 267 return Verify("EPSV\r\n", data, PRE_PASV, "500 Invalid command\r\n"); |
268 case PRE_PASV: | 268 case PRE_PASV: |
269 return Verify("PASV\r\n", data, PRE_SIZE, | 269 return Verify("PASV\r\n", data, PRE_SIZE, |
(...skipping 16 matching lines...) Expand all Loading... |
286 }; | 286 }; |
287 | 287 |
288 class FtpSocketDataProviderVMSDirectoryListingRootDirectory | 288 class FtpSocketDataProviderVMSDirectoryListingRootDirectory |
289 : public FtpSocketDataProvider { | 289 : public FtpSocketDataProvider { |
290 public: | 290 public: |
291 FtpSocketDataProviderVMSDirectoryListingRootDirectory() { | 291 FtpSocketDataProviderVMSDirectoryListingRootDirectory() { |
292 } | 292 } |
293 | 293 |
294 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 294 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
295 if (InjectFault()) | 295 if (InjectFault()) |
296 return MockWriteResult(true, data.length()); | 296 return MockWriteResult(ASYNC, data.length()); |
297 switch (state()) { | 297 switch (state()) { |
298 case PRE_SYST: | 298 case PRE_SYST: |
299 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); | 299 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); |
300 case PRE_PWD: | 300 case PRE_PWD: |
301 return Verify("PWD\r\n", data, PRE_TYPE, | 301 return Verify("PWD\r\n", data, PRE_TYPE, |
302 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); | 302 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); |
303 case PRE_EPSV: | 303 case PRE_EPSV: |
304 return Verify("EPSV\r\n", data, PRE_PASV, | 304 return Verify("EPSV\r\n", data, PRE_PASV, |
305 "500 EPSV command unknown\r\n"); | 305 "500 EPSV command unknown\r\n"); |
306 case PRE_PASV: | 306 case PRE_PASV: |
(...skipping 18 matching lines...) Expand all Loading... |
325 }; | 325 }; |
326 | 326 |
327 class FtpSocketDataProviderFileDownloadWithFileTypecode | 327 class FtpSocketDataProviderFileDownloadWithFileTypecode |
328 : public FtpSocketDataProvider { | 328 : public FtpSocketDataProvider { |
329 public: | 329 public: |
330 FtpSocketDataProviderFileDownloadWithFileTypecode() { | 330 FtpSocketDataProviderFileDownloadWithFileTypecode() { |
331 } | 331 } |
332 | 332 |
333 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 333 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
334 if (InjectFault()) | 334 if (InjectFault()) |
335 return MockWriteResult(true, data.length()); | 335 return MockWriteResult(ASYNC, data.length()); |
336 switch (state()) { | 336 switch (state()) { |
337 case PRE_SIZE: | 337 case PRE_SIZE: |
338 return Verify("SIZE /file\r\n", data, PRE_RETR, | 338 return Verify("SIZE /file\r\n", data, PRE_RETR, |
339 "213 18\r\n"); | 339 "213 18\r\n"); |
340 case PRE_RETR: | 340 case PRE_RETR: |
341 return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n"); | 341 return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n"); |
342 default: | 342 default: |
343 return FtpSocketDataProvider::OnWrite(data); | 343 return FtpSocketDataProvider::OnWrite(data); |
344 } | 344 } |
345 } | 345 } |
346 | 346 |
347 private: | 347 private: |
348 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithFileTypecode); | 348 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithFileTypecode); |
349 }; | 349 }; |
350 | 350 |
351 class FtpSocketDataProviderFileDownload : public FtpSocketDataProvider { | 351 class FtpSocketDataProviderFileDownload : public FtpSocketDataProvider { |
352 public: | 352 public: |
353 FtpSocketDataProviderFileDownload() { | 353 FtpSocketDataProviderFileDownload() { |
354 } | 354 } |
355 | 355 |
356 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 356 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
357 if (InjectFault()) | 357 if (InjectFault()) |
358 return MockWriteResult(true, data.length()); | 358 return MockWriteResult(ASYNC, data.length()); |
359 switch (state()) { | 359 switch (state()) { |
360 case PRE_SIZE: | 360 case PRE_SIZE: |
361 return Verify("SIZE /file\r\n", data, PRE_CWD, | 361 return Verify("SIZE /file\r\n", data, PRE_CWD, |
362 "213 18\r\n"); | 362 "213 18\r\n"); |
363 case PRE_CWD: | 363 case PRE_CWD: |
364 return Verify("CWD /file\r\n", data, PRE_RETR, | 364 return Verify("CWD /file\r\n", data, PRE_RETR, |
365 "550 Not a directory\r\n"); | 365 "550 Not a directory\r\n"); |
366 case PRE_RETR: | 366 case PRE_RETR: |
367 return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n"); | 367 return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n"); |
368 default: | 368 default: |
369 return FtpSocketDataProvider::OnWrite(data); | 369 return FtpSocketDataProvider::OnWrite(data); |
370 } | 370 } |
371 } | 371 } |
372 | 372 |
373 private: | 373 private: |
374 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownload); | 374 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownload); |
375 }; | 375 }; |
376 | 376 |
377 class FtpSocketDataProviderFileNotFound : public FtpSocketDataProvider { | 377 class FtpSocketDataProviderFileNotFound : public FtpSocketDataProvider { |
378 public: | 378 public: |
379 FtpSocketDataProviderFileNotFound() { | 379 FtpSocketDataProviderFileNotFound() { |
380 } | 380 } |
381 | 381 |
382 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 382 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
383 if (InjectFault()) | 383 if (InjectFault()) |
384 return MockWriteResult(true, data.length()); | 384 return MockWriteResult(ASYNC, data.length()); |
385 switch (state()) { | 385 switch (state()) { |
386 case PRE_SIZE: | 386 case PRE_SIZE: |
387 return Verify("SIZE /file\r\n", data, PRE_CWD, | 387 return Verify("SIZE /file\r\n", data, PRE_CWD, |
388 "550 File Not Found\r\n"); | 388 "550 File Not Found\r\n"); |
389 case PRE_CWD: | 389 case PRE_CWD: |
390 return Verify("CWD /file\r\n", data, PRE_RETR, | 390 return Verify("CWD /file\r\n", data, PRE_RETR, |
391 "550 File Not Found\r\n"); | 391 "550 File Not Found\r\n"); |
392 case PRE_RETR: | 392 case PRE_RETR: |
393 return Verify("RETR /file\r\n", data, PRE_QUIT, | 393 return Verify("RETR /file\r\n", data, PRE_QUIT, |
394 "550 File Not Found\r\n"); | 394 "550 File Not Found\r\n"); |
395 default: | 395 default: |
396 return FtpSocketDataProvider::OnWrite(data); | 396 return FtpSocketDataProvider::OnWrite(data); |
397 } | 397 } |
398 } | 398 } |
399 | 399 |
400 private: | 400 private: |
401 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileNotFound); | 401 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileNotFound); |
402 }; | 402 }; |
403 | 403 |
404 class FtpSocketDataProviderFileDownloadWithPasvFallback | 404 class FtpSocketDataProviderFileDownloadWithPasvFallback |
405 : public FtpSocketDataProviderFileDownload { | 405 : public FtpSocketDataProviderFileDownload { |
406 public: | 406 public: |
407 FtpSocketDataProviderFileDownloadWithPasvFallback() { | 407 FtpSocketDataProviderFileDownloadWithPasvFallback() { |
408 } | 408 } |
409 | 409 |
410 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 410 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
411 if (InjectFault()) | 411 if (InjectFault()) |
412 return MockWriteResult(true, data.length()); | 412 return MockWriteResult(ASYNC, data.length()); |
413 switch (state()) { | 413 switch (state()) { |
414 case PRE_EPSV: | 414 case PRE_EPSV: |
415 return Verify("EPSV\r\n", data, PRE_PASV, | 415 return Verify("EPSV\r\n", data, PRE_PASV, |
416 "500 No can do\r\n"); | 416 "500 No can do\r\n"); |
417 case PRE_PASV: | 417 case PRE_PASV: |
418 return Verify("PASV\r\n", data, PRE_SIZE, | 418 return Verify("PASV\r\n", data, PRE_SIZE, |
419 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | 419 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); |
420 default: | 420 default: |
421 return FtpSocketDataProviderFileDownload::OnWrite(data); | 421 return FtpSocketDataProviderFileDownload::OnWrite(data); |
422 } | 422 } |
423 } | 423 } |
424 | 424 |
425 private: | 425 private: |
426 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithPasvFallback); | 426 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithPasvFallback); |
427 }; | 427 }; |
428 | 428 |
429 class FtpSocketDataProviderFileDownloadZeroSize | 429 class FtpSocketDataProviderFileDownloadZeroSize |
430 : public FtpSocketDataProviderFileDownload { | 430 : public FtpSocketDataProviderFileDownload { |
431 public: | 431 public: |
432 FtpSocketDataProviderFileDownloadZeroSize() { | 432 FtpSocketDataProviderFileDownloadZeroSize() { |
433 } | 433 } |
434 | 434 |
435 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 435 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
436 if (InjectFault()) | 436 if (InjectFault()) |
437 return MockWriteResult(true, data.length()); | 437 return MockWriteResult(ASYNC, data.length()); |
438 switch (state()) { | 438 switch (state()) { |
439 case PRE_SIZE: | 439 case PRE_SIZE: |
440 return Verify("SIZE /file\r\n", data, PRE_CWD, | 440 return Verify("SIZE /file\r\n", data, PRE_CWD, |
441 "213 0\r\n"); | 441 "213 0\r\n"); |
442 case PRE_CWD: | 442 case PRE_CWD: |
443 return Verify("CWD /file\r\n", data, PRE_RETR, | 443 return Verify("CWD /file\r\n", data, PRE_RETR, |
444 "550 not a directory\r\n"); | 444 "550 not a directory\r\n"); |
445 default: | 445 default: |
446 return FtpSocketDataProviderFileDownload::OnWrite(data); | 446 return FtpSocketDataProviderFileDownload::OnWrite(data); |
447 } | 447 } |
448 } | 448 } |
449 | 449 |
450 private: | 450 private: |
451 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadZeroSize); | 451 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadZeroSize); |
452 }; | 452 }; |
453 | 453 |
454 class FtpSocketDataProviderFileDownloadCWD451 | 454 class FtpSocketDataProviderFileDownloadCWD451 |
455 : public FtpSocketDataProviderFileDownload { | 455 : public FtpSocketDataProviderFileDownload { |
456 public: | 456 public: |
457 FtpSocketDataProviderFileDownloadCWD451() { | 457 FtpSocketDataProviderFileDownloadCWD451() { |
458 } | 458 } |
459 | 459 |
460 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 460 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
461 if (InjectFault()) | 461 if (InjectFault()) |
462 return MockWriteResult(true, data.length()); | 462 return MockWriteResult(ASYNC, data.length()); |
463 switch (state()) { | 463 switch (state()) { |
464 case PRE_CWD: | 464 case PRE_CWD: |
465 return Verify("CWD /file\r\n", data, PRE_RETR, | 465 return Verify("CWD /file\r\n", data, PRE_RETR, |
466 "451 not a directory\r\n"); | 466 "451 not a directory\r\n"); |
467 default: | 467 default: |
468 return FtpSocketDataProviderFileDownload::OnWrite(data); | 468 return FtpSocketDataProviderFileDownload::OnWrite(data); |
469 } | 469 } |
470 } | 470 } |
471 | 471 |
472 private: | 472 private: |
473 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadCWD451); | 473 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadCWD451); |
474 }; | 474 }; |
475 | 475 |
476 class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider { | 476 class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider { |
477 public: | 477 public: |
478 FtpSocketDataProviderVMSFileDownload() { | 478 FtpSocketDataProviderVMSFileDownload() { |
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(true, data.length()); | 483 return MockWriteResult(ASYNC, data.length()); |
484 switch (state()) { | 484 switch (state()) { |
485 case PRE_SYST: | 485 case PRE_SYST: |
486 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); | 486 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); |
487 case PRE_PWD: | 487 case PRE_PWD: |
488 return Verify("PWD\r\n", data, PRE_TYPE, | 488 return Verify("PWD\r\n", data, PRE_TYPE, |
489 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); | 489 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); |
490 case PRE_EPSV: | 490 case PRE_EPSV: |
491 return Verify("EPSV\r\n", data, PRE_PASV, | 491 return Verify("EPSV\r\n", data, PRE_PASV, |
492 "500 EPSV command unknown\r\n"); | 492 "500 EPSV command unknown\r\n"); |
493 case PRE_PASV: | 493 case PRE_PASV: |
(...skipping 17 matching lines...) Expand all Loading... |
511 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderVMSFileDownload); | 511 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderVMSFileDownload); |
512 }; | 512 }; |
513 | 513 |
514 class FtpSocketDataProviderEscaping : public FtpSocketDataProviderFileDownload { | 514 class FtpSocketDataProviderEscaping : public FtpSocketDataProviderFileDownload { |
515 public: | 515 public: |
516 FtpSocketDataProviderEscaping() { | 516 FtpSocketDataProviderEscaping() { |
517 } | 517 } |
518 | 518 |
519 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 519 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
520 if (InjectFault()) | 520 if (InjectFault()) |
521 return MockWriteResult(true, data.length()); | 521 return MockWriteResult(ASYNC, data.length()); |
522 switch (state()) { | 522 switch (state()) { |
523 case PRE_SIZE: | 523 case PRE_SIZE: |
524 return Verify("SIZE / !\"#$%y\200\201\r\n", data, PRE_CWD, | 524 return Verify("SIZE / !\"#$%y\200\201\r\n", data, PRE_CWD, |
525 "213 18\r\n"); | 525 "213 18\r\n"); |
526 case PRE_CWD: | 526 case PRE_CWD: |
527 return Verify("CWD / !\"#$%y\200\201\r\n", data, PRE_RETR, | 527 return Verify("CWD / !\"#$%y\200\201\r\n", data, PRE_RETR, |
528 "550 Not a directory\r\n"); | 528 "550 Not a directory\r\n"); |
529 case PRE_RETR: | 529 case PRE_RETR: |
530 return Verify("RETR / !\"#$%y\200\201\r\n", data, PRE_QUIT, | 530 return Verify("RETR / !\"#$%y\200\201\r\n", data, PRE_QUIT, |
531 "200 OK\r\n"); | 531 "200 OK\r\n"); |
532 default: | 532 default: |
533 return FtpSocketDataProviderFileDownload::OnWrite(data); | 533 return FtpSocketDataProviderFileDownload::OnWrite(data); |
534 } | 534 } |
535 } | 535 } |
536 | 536 |
537 private: | 537 private: |
538 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEscaping); | 538 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEscaping); |
539 }; | 539 }; |
540 | 540 |
541 class FtpSocketDataProviderFileDownloadTransferStarting | 541 class FtpSocketDataProviderFileDownloadTransferStarting |
542 : public FtpSocketDataProviderFileDownload { | 542 : public FtpSocketDataProviderFileDownload { |
543 public: | 543 public: |
544 FtpSocketDataProviderFileDownloadTransferStarting() { | 544 FtpSocketDataProviderFileDownloadTransferStarting() { |
545 } | 545 } |
546 | 546 |
547 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 547 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
548 if (InjectFault()) | 548 if (InjectFault()) |
549 return MockWriteResult(true, data.length()); | 549 return MockWriteResult(ASYNC, data.length()); |
550 switch (state()) { | 550 switch (state()) { |
551 case PRE_RETR: | 551 case PRE_RETR: |
552 return Verify("RETR /file\r\n", data, PRE_QUIT, | 552 return Verify("RETR /file\r\n", data, PRE_QUIT, |
553 "125-Data connection already open.\r\n" | 553 "125-Data connection already open.\r\n" |
554 "125 Transfer starting.\r\n" | 554 "125 Transfer starting.\r\n" |
555 "226 Transfer complete.\r\n"); | 555 "226 Transfer complete.\r\n"); |
556 default: | 556 default: |
557 return FtpSocketDataProviderFileDownload::OnWrite(data); | 557 return FtpSocketDataProviderFileDownload::OnWrite(data); |
558 } | 558 } |
559 } | 559 } |
560 | 560 |
561 private: | 561 private: |
562 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadTransferStarting); | 562 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadTransferStarting); |
563 }; | 563 }; |
564 | 564 |
565 class FtpSocketDataProviderDirectoryListingTransferStarting | 565 class FtpSocketDataProviderDirectoryListingTransferStarting |
566 : public FtpSocketDataProviderDirectoryListing { | 566 : public FtpSocketDataProviderDirectoryListing { |
567 public: | 567 public: |
568 FtpSocketDataProviderDirectoryListingTransferStarting() { | 568 FtpSocketDataProviderDirectoryListingTransferStarting() { |
569 } | 569 } |
570 | 570 |
571 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 571 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
572 if (InjectFault()) | 572 if (InjectFault()) |
573 return MockWriteResult(true, data.length()); | 573 return MockWriteResult(ASYNC, data.length()); |
574 switch (state()) { | 574 switch (state()) { |
575 case PRE_LIST: | 575 case PRE_LIST: |
576 return Verify("LIST\r\n", data, PRE_QUIT, | 576 return Verify("LIST\r\n", data, PRE_QUIT, |
577 "125-Data connection already open.\r\n" | 577 "125-Data connection already open.\r\n" |
578 "125 Transfer starting.\r\n" | 578 "125 Transfer starting.\r\n" |
579 "226 Transfer complete.\r\n"); | 579 "226 Transfer complete.\r\n"); |
580 default: | 580 default: |
581 return FtpSocketDataProviderDirectoryListing::OnWrite(data); | 581 return FtpSocketDataProviderDirectoryListing::OnWrite(data); |
582 } | 582 } |
583 } | 583 } |
584 | 584 |
585 private: | 585 private: |
586 DISALLOW_COPY_AND_ASSIGN( | 586 DISALLOW_COPY_AND_ASSIGN( |
587 FtpSocketDataProviderDirectoryListingTransferStarting); | 587 FtpSocketDataProviderDirectoryListingTransferStarting); |
588 }; | 588 }; |
589 | 589 |
590 class FtpSocketDataProviderFileDownloadInvalidResponse | 590 class FtpSocketDataProviderFileDownloadInvalidResponse |
591 : public FtpSocketDataProviderFileDownload { | 591 : public FtpSocketDataProviderFileDownload { |
592 public: | 592 public: |
593 FtpSocketDataProviderFileDownloadInvalidResponse() { | 593 FtpSocketDataProviderFileDownloadInvalidResponse() { |
594 } | 594 } |
595 | 595 |
596 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 596 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
597 if (InjectFault()) | 597 if (InjectFault()) |
598 return MockWriteResult(true, data.length()); | 598 return MockWriteResult(ASYNC, data.length()); |
599 switch (state()) { | 599 switch (state()) { |
600 case PRE_SIZE: | 600 case PRE_SIZE: |
601 // Use unallocated 599 FTP error code to make sure it falls into the | 601 // Use unallocated 599 FTP error code to make sure it falls into the |
602 // generic ERR_FTP_FAILED bucket. | 602 // generic ERR_FTP_FAILED bucket. |
603 return Verify("SIZE /file\r\n", data, PRE_QUIT, | 603 return Verify("SIZE /file\r\n", data, PRE_QUIT, |
604 "599 Evil Response\r\n" | 604 "599 Evil Response\r\n" |
605 "599 More Evil\r\n"); | 605 "599 More Evil\r\n"); |
606 default: | 606 default: |
607 return FtpSocketDataProviderFileDownload::OnWrite(data); | 607 return FtpSocketDataProviderFileDownload::OnWrite(data); |
608 } | 608 } |
(...skipping 13 matching lines...) Expand all Loading... |
622 | 622 |
623 FtpSocketDataProviderEvilEpsv(const char* epsv_response, | 623 FtpSocketDataProviderEvilEpsv(const char* epsv_response, |
624 size_t epsv_response_length, | 624 size_t epsv_response_length, |
625 State expected_state) | 625 State expected_state) |
626 : epsv_response_(epsv_response), | 626 : epsv_response_(epsv_response), |
627 epsv_response_length_(epsv_response_length), | 627 epsv_response_length_(epsv_response_length), |
628 expected_state_(expected_state) {} | 628 expected_state_(expected_state) {} |
629 | 629 |
630 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 630 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
631 if (InjectFault()) | 631 if (InjectFault()) |
632 return MockWriteResult(true, data.length()); | 632 return MockWriteResult(ASYNC, data.length()); |
633 switch (state()) { | 633 switch (state()) { |
634 case PRE_EPSV: | 634 case PRE_EPSV: |
635 return Verify("EPSV\r\n", data, expected_state_, | 635 return Verify("EPSV\r\n", data, expected_state_, |
636 epsv_response_, epsv_response_length_); | 636 epsv_response_, epsv_response_length_); |
637 default: | 637 default: |
638 return FtpSocketDataProviderFileDownload::OnWrite(data); | 638 return FtpSocketDataProviderFileDownload::OnWrite(data); |
639 } | 639 } |
640 } | 640 } |
641 | 641 |
642 private: | 642 private: |
643 const char* epsv_response_; | 643 const char* epsv_response_; |
644 const size_t epsv_response_length_; | 644 const size_t epsv_response_length_; |
645 const State expected_state_; | 645 const State expected_state_; |
646 | 646 |
647 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilEpsv); | 647 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilEpsv); |
648 }; | 648 }; |
649 | 649 |
650 class FtpSocketDataProviderEvilPasv | 650 class FtpSocketDataProviderEvilPasv |
651 : public FtpSocketDataProviderFileDownloadWithPasvFallback { | 651 : public FtpSocketDataProviderFileDownloadWithPasvFallback { |
652 public: | 652 public: |
653 FtpSocketDataProviderEvilPasv(const char* pasv_response, State expected_state) | 653 FtpSocketDataProviderEvilPasv(const char* pasv_response, State expected_state) |
654 : pasv_response_(pasv_response), | 654 : pasv_response_(pasv_response), |
655 expected_state_(expected_state) { | 655 expected_state_(expected_state) { |
656 } | 656 } |
657 | 657 |
658 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 658 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
659 if (InjectFault()) | 659 if (InjectFault()) |
660 return MockWriteResult(true, data.length()); | 660 return MockWriteResult(ASYNC, data.length()); |
661 switch (state()) { | 661 switch (state()) { |
662 case PRE_PASV: | 662 case PRE_PASV: |
663 return Verify("PASV\r\n", data, expected_state_, pasv_response_); | 663 return Verify("PASV\r\n", data, expected_state_, pasv_response_); |
664 default: | 664 default: |
665 return FtpSocketDataProviderFileDownloadWithPasvFallback::OnWrite(data); | 665 return FtpSocketDataProviderFileDownloadWithPasvFallback::OnWrite(data); |
666 } | 666 } |
667 } | 667 } |
668 | 668 |
669 private: | 669 private: |
670 const char* pasv_response_; | 670 const char* pasv_response_; |
671 const State expected_state_; | 671 const State expected_state_; |
672 | 672 |
673 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilPasv); | 673 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilPasv); |
674 }; | 674 }; |
675 | 675 |
676 class FtpSocketDataProviderEvilSize : public FtpSocketDataProviderFileDownload { | 676 class FtpSocketDataProviderEvilSize : public FtpSocketDataProviderFileDownload { |
677 public: | 677 public: |
678 FtpSocketDataProviderEvilSize(const char* size_response, State expected_state) | 678 FtpSocketDataProviderEvilSize(const char* size_response, State expected_state) |
679 : size_response_(size_response), | 679 : size_response_(size_response), |
680 expected_state_(expected_state) { | 680 expected_state_(expected_state) { |
681 } | 681 } |
682 | 682 |
683 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 683 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
684 if (InjectFault()) | 684 if (InjectFault()) |
685 return MockWriteResult(true, data.length()); | 685 return MockWriteResult(ASYNC, data.length()); |
686 switch (state()) { | 686 switch (state()) { |
687 case PRE_SIZE: | 687 case PRE_SIZE: |
688 return Verify("SIZE /file\r\n", data, expected_state_, size_response_); | 688 return Verify("SIZE /file\r\n", data, expected_state_, size_response_); |
689 default: | 689 default: |
690 return FtpSocketDataProviderFileDownload::OnWrite(data); | 690 return FtpSocketDataProviderFileDownload::OnWrite(data); |
691 } | 691 } |
692 } | 692 } |
693 | 693 |
694 private: | 694 private: |
695 const char* size_response_; | 695 const char* size_response_; |
696 const State expected_state_; | 696 const State expected_state_; |
697 | 697 |
698 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilSize); | 698 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilSize); |
699 }; | 699 }; |
700 | 700 |
701 class FtpSocketDataProviderEvilLogin | 701 class FtpSocketDataProviderEvilLogin |
702 : public FtpSocketDataProviderFileDownload { | 702 : public FtpSocketDataProviderFileDownload { |
703 public: | 703 public: |
704 FtpSocketDataProviderEvilLogin(const char* expected_user, | 704 FtpSocketDataProviderEvilLogin(const char* expected_user, |
705 const char* expected_password) | 705 const char* expected_password) |
706 : expected_user_(expected_user), | 706 : expected_user_(expected_user), |
707 expected_password_(expected_password) { | 707 expected_password_(expected_password) { |
708 } | 708 } |
709 | 709 |
710 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 710 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
711 if (InjectFault()) | 711 if (InjectFault()) |
712 return MockWriteResult(true, data.length()); | 712 return MockWriteResult(ASYNC, data.length()); |
713 switch (state()) { | 713 switch (state()) { |
714 case PRE_USER: | 714 case PRE_USER: |
715 return Verify(std::string("USER ") + expected_user_ + "\r\n", data, | 715 return Verify(std::string("USER ") + expected_user_ + "\r\n", data, |
716 PRE_PASSWD, "331 Password needed\r\n"); | 716 PRE_PASSWD, "331 Password needed\r\n"); |
717 case PRE_PASSWD: | 717 case PRE_PASSWD: |
718 return Verify(std::string("PASS ") + expected_password_ + "\r\n", data, | 718 return Verify(std::string("PASS ") + expected_password_ + "\r\n", data, |
719 PRE_SYST, "230 Welcome\r\n"); | 719 PRE_SYST, "230 Welcome\r\n"); |
720 default: | 720 default: |
721 return FtpSocketDataProviderFileDownload::OnWrite(data); | 721 return FtpSocketDataProviderFileDownload::OnWrite(data); |
722 } | 722 } |
723 } | 723 } |
724 | 724 |
725 private: | 725 private: |
726 const char* expected_user_; | 726 const char* expected_user_; |
727 const char* expected_password_; | 727 const char* expected_password_; |
728 | 728 |
729 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilLogin); | 729 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilLogin); |
730 }; | 730 }; |
731 | 731 |
732 class FtpSocketDataProviderCloseConnection : public FtpSocketDataProvider { | 732 class FtpSocketDataProviderCloseConnection : public FtpSocketDataProvider { |
733 public: | 733 public: |
734 FtpSocketDataProviderCloseConnection() { | 734 FtpSocketDataProviderCloseConnection() { |
735 } | 735 } |
736 | 736 |
737 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { | 737 virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE { |
738 if (InjectFault()) | 738 if (InjectFault()) |
739 return MockWriteResult(true, data.length()); | 739 return MockWriteResult(ASYNC, data.length()); |
740 switch (state()) { | 740 switch (state()) { |
741 case PRE_USER: | 741 case PRE_USER: |
742 return Verify("USER anonymous\r\n", data, | 742 return Verify("USER anonymous\r\n", data, |
743 PRE_QUIT, ""); | 743 PRE_QUIT, ""); |
744 default: | 744 default: |
745 return FtpSocketDataProvider::OnWrite(data); | 745 return FtpSocketDataProvider::OnWrite(data); |
746 } | 746 } |
747 } | 747 } |
748 | 748 |
749 private: | 749 private: |
(...skipping 15 matching lines...) Expand all Loading... |
765 return info; | 765 return info; |
766 } | 766 } |
767 | 767 |
768 void ExecuteTransaction(FtpSocketDataProvider* ctrl_socket, | 768 void ExecuteTransaction(FtpSocketDataProvider* ctrl_socket, |
769 const char* request, | 769 const char* request, |
770 int expected_result) { | 770 int expected_result) { |
771 std::string mock_data("mock-data"); | 771 std::string mock_data("mock-data"); |
772 MockRead data_reads[] = { | 772 MockRead data_reads[] = { |
773 // Usually FTP servers close the data connection after the entire data has | 773 // Usually FTP servers close the data connection after the entire data has |
774 // been received. | 774 // been received. |
775 MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), | 775 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
776 MockRead(mock_data.c_str()), | 776 MockRead(mock_data.c_str()), |
777 }; | 777 }; |
778 StaticSocketDataProvider data_socket(data_reads, arraysize(data_reads), | 778 StaticSocketDataProvider data_socket(data_reads, arraysize(data_reads), |
779 NULL, 0); | 779 NULL, 0); |
780 mock_socket_factory_.AddSocketDataProvider(ctrl_socket); | 780 mock_socket_factory_.AddSocketDataProvider(ctrl_socket); |
781 mock_socket_factory_.AddSocketDataProvider(&data_socket); | 781 mock_socket_factory_.AddSocketDataProvider(&data_socket); |
782 FtpRequestInfo request_info = GetRequestInfo(request); | 782 FtpRequestInfo request_info = GetRequestInfo(request); |
783 EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState()); | 783 EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState()); |
784 ASSERT_EQ(ERR_IO_PENDING, | 784 ASSERT_EQ(ERR_IO_PENDING, |
785 transaction_.Start(&request_info, callback_.callback(), | 785 transaction_.Start(&request_info, callback_.callback(), |
(...skipping 394 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1180 FtpRequestInfo request_info = GetRequestInfo("ftp://host/file"); | 1180 FtpRequestInfo request_info = GetRequestInfo("ftp://host/file"); |
1181 | 1181 |
1182 ASSERT_EQ(ERR_IO_PENDING, | 1182 ASSERT_EQ(ERR_IO_PENDING, |
1183 transaction_.Start(&request_info, callback_.callback(), | 1183 transaction_.Start(&request_info, callback_.callback(), |
1184 BoundNetLog())); | 1184 BoundNetLog())); |
1185 ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult()); | 1185 ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult()); |
1186 | 1186 |
1187 MockRead ctrl_reads[] = { | 1187 MockRead ctrl_reads[] = { |
1188 MockRead("220 host TestFTPd\r\n"), | 1188 MockRead("220 host TestFTPd\r\n"), |
1189 MockRead("221 Goodbye!\r\n"), | 1189 MockRead("221 Goodbye!\r\n"), |
1190 MockRead(false, OK), | 1190 MockRead(SYNCHRONOUS, OK), |
1191 }; | 1191 }; |
1192 MockWrite ctrl_writes[] = { | 1192 MockWrite ctrl_writes[] = { |
1193 MockWrite("QUIT\r\n"), | 1193 MockWrite("QUIT\r\n"), |
1194 }; | 1194 }; |
1195 StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads), | 1195 StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads), |
1196 ctrl_writes, arraysize(ctrl_writes)); | 1196 ctrl_writes, arraysize(ctrl_writes)); |
1197 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); | 1197 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); |
1198 ASSERT_EQ(ERR_IO_PENDING, | 1198 ASSERT_EQ(ERR_IO_PENDING, |
1199 transaction_.RestartWithAuth( | 1199 transaction_.RestartWithAuth( |
1200 AuthCredentials( | 1200 AuthCredentials( |
(...skipping 14 matching lines...) Expand all Loading... |
1215 | 1215 |
1216 ASSERT_EQ(ERR_IO_PENDING, | 1216 ASSERT_EQ(ERR_IO_PENDING, |
1217 transaction_.Start(&request_info, callback_.callback(), | 1217 transaction_.Start(&request_info, callback_.callback(), |
1218 BoundNetLog())); | 1218 BoundNetLog())); |
1219 ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult()); | 1219 ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult()); |
1220 | 1220 |
1221 MockRead ctrl_reads[] = { | 1221 MockRead ctrl_reads[] = { |
1222 MockRead("220 host TestFTPd\r\n"), | 1222 MockRead("220 host TestFTPd\r\n"), |
1223 MockRead("331 User okay, send password\r\n"), | 1223 MockRead("331 User okay, send password\r\n"), |
1224 MockRead("221 Goodbye!\r\n"), | 1224 MockRead("221 Goodbye!\r\n"), |
1225 MockRead(false, OK), | 1225 MockRead(SYNCHRONOUS, OK), |
1226 }; | 1226 }; |
1227 MockWrite ctrl_writes[] = { | 1227 MockWrite ctrl_writes[] = { |
1228 MockWrite("USER innocent\r\n"), | 1228 MockWrite("USER innocent\r\n"), |
1229 MockWrite("QUIT\r\n"), | 1229 MockWrite("QUIT\r\n"), |
1230 }; | 1230 }; |
1231 StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads), | 1231 StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads), |
1232 ctrl_writes, arraysize(ctrl_writes)); | 1232 ctrl_writes, arraysize(ctrl_writes)); |
1233 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); | 1233 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); |
1234 ASSERT_EQ(ERR_IO_PENDING, | 1234 ASSERT_EQ(ERR_IO_PENDING, |
1235 transaction_.RestartWithAuth( | 1235 transaction_.RestartWithAuth( |
(...skipping 232 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1468 FtpSocketDataProviderFileDownload ctrl_socket; | 1468 FtpSocketDataProviderFileDownload ctrl_socket; |
1469 TransactionFailHelper(&ctrl_socket, | 1469 TransactionFailHelper(&ctrl_socket, |
1470 "ftp://host/file", | 1470 "ftp://host/file", |
1471 FtpSocketDataProvider::PRE_PWD, | 1471 FtpSocketDataProvider::PRE_PWD, |
1472 FtpSocketDataProvider::PRE_TYPE, | 1472 FtpSocketDataProvider::PRE_TYPE, |
1473 "257 \"\"\r\n", | 1473 "257 \"\"\r\n", |
1474 OK); | 1474 OK); |
1475 } | 1475 } |
1476 | 1476 |
1477 } // namespace net | 1477 } // namespace net |
OLD | NEW |