| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/ftp/ftp_network_transaction.h" | |
| 6 | |
| 7 #include "build/build_config.h" | |
| 8 | |
| 9 #include "base/compiler_specific.h" | |
| 10 #include "base/memory/ref_counted.h" | |
| 11 #include "base/memory/scoped_vector.h" | |
| 12 #include "base/strings/string_util.h" | |
| 13 #include "base/strings/utf_string_conversions.h" | |
| 14 #include "net/base/host_port_pair.h" | |
| 15 #include "net/base/io_buffer.h" | |
| 16 #include "net/base/net_util.h" | |
| 17 #include "net/base/test_completion_callback.h" | |
| 18 #include "net/dns/mock_host_resolver.h" | |
| 19 #include "net/ftp/ftp_network_session.h" | |
| 20 #include "net/ftp/ftp_request_info.h" | |
| 21 #include "net/socket/socket_test_util.h" | |
| 22 #include "testing/gtest/include/gtest/gtest.h" | |
| 23 #include "testing/platform_test.h" | |
| 24 | |
| 25 namespace { | |
| 26 | |
| 27 // Size we use for IOBuffers used to receive data from the test data socket. | |
| 28 const int kBufferSize = 128; | |
| 29 | |
| 30 } // namespace | |
| 31 | |
| 32 namespace net { | |
| 33 | |
| 34 class FtpSocketDataProvider : public DynamicSocketDataProvider { | |
| 35 public: | |
| 36 enum State { | |
| 37 NONE, | |
| 38 PRE_USER, | |
| 39 PRE_PASSWD, | |
| 40 PRE_SYST, | |
| 41 PRE_PWD, | |
| 42 PRE_TYPE, | |
| 43 PRE_SIZE, | |
| 44 PRE_LIST_EPSV, | |
| 45 PRE_LIST_PASV, | |
| 46 PRE_LIST, | |
| 47 PRE_RETR, | |
| 48 PRE_RETR_EPSV, | |
| 49 PRE_RETR_PASV, | |
| 50 PRE_CWD, | |
| 51 PRE_QUIT, | |
| 52 PRE_NOPASV, | |
| 53 QUIT | |
| 54 }; | |
| 55 | |
| 56 FtpSocketDataProvider() | |
| 57 : failure_injection_state_(NONE), | |
| 58 multiline_welcome_(false), | |
| 59 use_epsv_(true), | |
| 60 data_type_('I') { | |
| 61 Init(); | |
| 62 } | |
| 63 | |
| 64 MockWriteResult OnWrite(const std::string& data) override { | |
| 65 if (InjectFault()) | |
| 66 return MockWriteResult(ASYNC, data.length()); | |
| 67 switch (state()) { | |
| 68 case PRE_USER: | |
| 69 return Verify("USER anonymous\r\n", data, PRE_PASSWD, | |
| 70 "331 Password needed\r\n"); | |
| 71 case PRE_PASSWD: | |
| 72 { | |
| 73 static const char response_one[] = "230 Welcome\r\n"; | |
| 74 static const char response_multi[] = | |
| 75 "230- One\r\n230- Two\r\n230 Three\r\n"; | |
| 76 return Verify("PASS chrome@example.com\r\n", data, PRE_SYST, | |
| 77 multiline_welcome_ ? response_multi : response_one); | |
| 78 } | |
| 79 case PRE_SYST: | |
| 80 return Verify("SYST\r\n", data, PRE_PWD, "215 UNIX\r\n"); | |
| 81 case PRE_PWD: | |
| 82 return Verify("PWD\r\n", data, PRE_TYPE, | |
| 83 "257 \"/\" is your current location\r\n"); | |
| 84 case PRE_TYPE: | |
| 85 return Verify(std::string("TYPE ") + data_type_ + "\r\n", data, | |
| 86 PRE_SIZE, "200 TYPE set successfully\r\n"); | |
| 87 case PRE_LIST_EPSV: | |
| 88 return Verify("EPSV\r\n", data, PRE_LIST, | |
| 89 "227 Entering Extended Passive Mode (|||31744|)\r\n"); | |
| 90 case PRE_LIST_PASV: | |
| 91 return Verify("PASV\r\n", data, PRE_LIST, | |
| 92 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | |
| 93 case PRE_RETR_EPSV: | |
| 94 return Verify("EPSV\r\n", data, PRE_RETR, | |
| 95 "227 Entering Extended Passive Mode (|||31744|)\r\n"); | |
| 96 case PRE_RETR_PASV: | |
| 97 return Verify("PASV\r\n", data, PRE_RETR, | |
| 98 "227 Entering Passive Mode 127,0,0,1,123,456\r\n"); | |
| 99 case PRE_NOPASV: | |
| 100 // Use unallocated 599 FTP error code to make sure it falls into the | |
| 101 // generic ERR_FTP_FAILED bucket. | |
| 102 return Verify("PASV\r\n", data, PRE_QUIT, | |
| 103 "599 fail\r\n"); | |
| 104 case PRE_QUIT: | |
| 105 return Verify("QUIT\r\n", data, QUIT, "221 Goodbye.\r\n"); | |
| 106 default: | |
| 107 NOTREACHED() << "State not handled " << state(); | |
| 108 return MockWriteResult(ASYNC, ERR_UNEXPECTED); | |
| 109 } | |
| 110 } | |
| 111 | |
| 112 void InjectFailure(State state, State next_state, const char* response) { | |
| 113 DCHECK_EQ(NONE, failure_injection_state_); | |
| 114 DCHECK_NE(NONE, state); | |
| 115 DCHECK_NE(NONE, next_state); | |
| 116 DCHECK_NE(state, next_state); | |
| 117 failure_injection_state_ = state; | |
| 118 failure_injection_next_state_ = next_state; | |
| 119 fault_response_ = response; | |
| 120 } | |
| 121 | |
| 122 State state() const { | |
| 123 return state_; | |
| 124 } | |
| 125 | |
| 126 void Reset() override { | |
| 127 DynamicSocketDataProvider::Reset(); | |
| 128 Init(); | |
| 129 } | |
| 130 | |
| 131 void set_multiline_welcome(bool multiline) { multiline_welcome_ = multiline; } | |
| 132 | |
| 133 bool use_epsv() const { return use_epsv_; } | |
| 134 void set_use_epsv(bool use_epsv) { use_epsv_ = use_epsv; } | |
| 135 | |
| 136 void set_data_type(char data_type) { data_type_ = data_type; } | |
| 137 | |
| 138 protected: | |
| 139 void Init() { | |
| 140 state_ = PRE_USER; | |
| 141 SimulateRead("220 host TestFTPd\r\n"); | |
| 142 } | |
| 143 | |
| 144 // If protocol fault injection has been requested, adjusts state and mocked | |
| 145 // read and returns true. | |
| 146 bool InjectFault() { | |
| 147 if (state_ != failure_injection_state_) | |
| 148 return false; | |
| 149 SimulateRead(fault_response_); | |
| 150 state_ = failure_injection_next_state_; | |
| 151 return true; | |
| 152 } | |
| 153 | |
| 154 MockWriteResult Verify(const std::string& expected, | |
| 155 const std::string& data, | |
| 156 State next_state, | |
| 157 const char* next_read, | |
| 158 const size_t next_read_length) { | |
| 159 EXPECT_EQ(expected, data); | |
| 160 if (expected == data) { | |
| 161 state_ = next_state; | |
| 162 SimulateRead(next_read, next_read_length); | |
| 163 return MockWriteResult(ASYNC, data.length()); | |
| 164 } | |
| 165 return MockWriteResult(ASYNC, ERR_UNEXPECTED); | |
| 166 } | |
| 167 | |
| 168 MockWriteResult Verify(const std::string& expected, | |
| 169 const std::string& data, | |
| 170 State next_state, | |
| 171 const char* next_read) { | |
| 172 return Verify(expected, data, next_state, | |
| 173 next_read, std::strlen(next_read)); | |
| 174 } | |
| 175 | |
| 176 | |
| 177 private: | |
| 178 State state_; | |
| 179 State failure_injection_state_; | |
| 180 State failure_injection_next_state_; | |
| 181 const char* fault_response_; | |
| 182 | |
| 183 // If true, we will send multiple 230 lines as response after PASS. | |
| 184 bool multiline_welcome_; | |
| 185 | |
| 186 // If true, we will use EPSV command. | |
| 187 bool use_epsv_; | |
| 188 | |
| 189 // Data type to be used for TYPE command. | |
| 190 char data_type_; | |
| 191 | |
| 192 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProvider); | |
| 193 }; | |
| 194 | |
| 195 class FtpSocketDataProviderDirectoryListing : public FtpSocketDataProvider { | |
| 196 public: | |
| 197 FtpSocketDataProviderDirectoryListing() { | |
| 198 } | |
| 199 | |
| 200 MockWriteResult OnWrite(const std::string& data) override { | |
| 201 if (InjectFault()) | |
| 202 return MockWriteResult(ASYNC, data.length()); | |
| 203 switch (state()) { | |
| 204 case PRE_SIZE: | |
| 205 return Verify("SIZE /\r\n", data, PRE_CWD, | |
| 206 "550 I can only retrieve regular files\r\n"); | |
| 207 case PRE_CWD: | |
| 208 return Verify("CWD /\r\n", data, | |
| 209 use_epsv() ? PRE_LIST_EPSV : PRE_LIST_PASV, "200 OK\r\n"); | |
| 210 case PRE_LIST: | |
| 211 return Verify("LIST -l\r\n", data, PRE_QUIT, "200 OK\r\n"); | |
| 212 default: | |
| 213 return FtpSocketDataProvider::OnWrite(data); | |
| 214 } | |
| 215 } | |
| 216 | |
| 217 private: | |
| 218 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListing); | |
| 219 }; | |
| 220 | |
| 221 class FtpSocketDataProviderDirectoryListingWithPasvFallback | |
| 222 : public FtpSocketDataProviderDirectoryListing { | |
| 223 public: | |
| 224 FtpSocketDataProviderDirectoryListingWithPasvFallback() { | |
| 225 } | |
| 226 | |
| 227 MockWriteResult OnWrite(const std::string& data) override { | |
| 228 if (InjectFault()) | |
| 229 return MockWriteResult(ASYNC, data.length()); | |
| 230 switch (state()) { | |
| 231 case PRE_LIST_EPSV: | |
| 232 return Verify("EPSV\r\n", data, PRE_LIST_PASV, | |
| 233 "500 no EPSV for you\r\n"); | |
| 234 case PRE_SIZE: | |
| 235 return Verify("SIZE /\r\n", data, PRE_CWD, | |
| 236 "550 I can only retrieve regular files\r\n"); | |
| 237 default: | |
| 238 return FtpSocketDataProviderDirectoryListing::OnWrite(data); | |
| 239 } | |
| 240 } | |
| 241 | |
| 242 private: | |
| 243 DISALLOW_COPY_AND_ASSIGN( | |
| 244 FtpSocketDataProviderDirectoryListingWithPasvFallback); | |
| 245 }; | |
| 246 | |
| 247 class FtpSocketDataProviderDirectoryListingZeroSize | |
| 248 : public FtpSocketDataProviderDirectoryListing { | |
| 249 public: | |
| 250 FtpSocketDataProviderDirectoryListingZeroSize() { | |
| 251 } | |
| 252 | |
| 253 MockWriteResult OnWrite(const std::string& data) override { | |
| 254 if (InjectFault()) | |
| 255 return MockWriteResult(ASYNC, data.length()); | |
| 256 switch (state()) { | |
| 257 case PRE_SIZE: | |
| 258 return Verify("SIZE /\r\n", data, PRE_CWD, "213 0\r\n"); | |
| 259 default: | |
| 260 return FtpSocketDataProviderDirectoryListing::OnWrite(data); | |
| 261 } | |
| 262 } | |
| 263 | |
| 264 private: | |
| 265 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListingZeroSize); | |
| 266 }; | |
| 267 | |
| 268 class FtpSocketDataProviderVMSDirectoryListing : public FtpSocketDataProvider { | |
| 269 public: | |
| 270 FtpSocketDataProviderVMSDirectoryListing() { | |
| 271 } | |
| 272 | |
| 273 MockWriteResult OnWrite(const std::string& data) override { | |
| 274 if (InjectFault()) | |
| 275 return MockWriteResult(ASYNC, data.length()); | |
| 276 switch (state()) { | |
| 277 case PRE_SYST: | |
| 278 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); | |
| 279 case PRE_PWD: | |
| 280 return Verify("PWD\r\n", data, PRE_TYPE, | |
| 281 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); | |
| 282 case PRE_LIST_EPSV: | |
| 283 return Verify("EPSV\r\n", data, PRE_LIST_PASV, | |
| 284 "500 Invalid command\r\n"); | |
| 285 case PRE_SIZE: | |
| 286 return Verify("SIZE ANONYMOUS_ROOT:[000000]dir\r\n", data, PRE_CWD, | |
| 287 "550 I can only retrieve regular files\r\n"); | |
| 288 case PRE_CWD: | |
| 289 return Verify("CWD ANONYMOUS_ROOT:[dir]\r\n", data, | |
| 290 use_epsv() ? PRE_LIST_EPSV : PRE_LIST_PASV, "200 OK\r\n"); | |
| 291 case PRE_LIST: | |
| 292 return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n"); | |
| 293 default: | |
| 294 return FtpSocketDataProvider::OnWrite(data); | |
| 295 } | |
| 296 } | |
| 297 | |
| 298 private: | |
| 299 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderVMSDirectoryListing); | |
| 300 }; | |
| 301 | |
| 302 class FtpSocketDataProviderVMSDirectoryListingRootDirectory | |
| 303 : public FtpSocketDataProvider { | |
| 304 public: | |
| 305 FtpSocketDataProviderVMSDirectoryListingRootDirectory() { | |
| 306 } | |
| 307 | |
| 308 MockWriteResult OnWrite(const std::string& data) override { | |
| 309 if (InjectFault()) | |
| 310 return MockWriteResult(ASYNC, data.length()); | |
| 311 switch (state()) { | |
| 312 case PRE_SYST: | |
| 313 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); | |
| 314 case PRE_PWD: | |
| 315 return Verify("PWD\r\n", data, PRE_TYPE, | |
| 316 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); | |
| 317 case PRE_LIST_EPSV: | |
| 318 return Verify("EPSV\r\n", data, PRE_LIST_PASV, | |
| 319 "500 EPSV command unknown\r\n"); | |
| 320 case PRE_SIZE: | |
| 321 return Verify("SIZE ANONYMOUS_ROOT\r\n", data, PRE_CWD, | |
| 322 "550 I can only retrieve regular files\r\n"); | |
| 323 case PRE_CWD: | |
| 324 return Verify("CWD ANONYMOUS_ROOT:[000000]\r\n", data, | |
| 325 use_epsv() ? PRE_LIST_EPSV : PRE_LIST_PASV, "200 OK\r\n"); | |
| 326 case PRE_LIST: | |
| 327 return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n"); | |
| 328 default: | |
| 329 return FtpSocketDataProvider::OnWrite(data); | |
| 330 } | |
| 331 } | |
| 332 | |
| 333 private: | |
| 334 DISALLOW_COPY_AND_ASSIGN( | |
| 335 FtpSocketDataProviderVMSDirectoryListingRootDirectory); | |
| 336 }; | |
| 337 | |
| 338 class FtpSocketDataProviderFileDownloadWithFileTypecode | |
| 339 : public FtpSocketDataProvider { | |
| 340 public: | |
| 341 FtpSocketDataProviderFileDownloadWithFileTypecode() { | |
| 342 } | |
| 343 | |
| 344 MockWriteResult OnWrite(const std::string& data) override { | |
| 345 if (InjectFault()) | |
| 346 return MockWriteResult(ASYNC, data.length()); | |
| 347 switch (state()) { | |
| 348 case PRE_SIZE: | |
| 349 return Verify("SIZE /file\r\n", data, | |
| 350 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, "213 18\r\n"); | |
| 351 case PRE_RETR: | |
| 352 return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n"); | |
| 353 default: | |
| 354 return FtpSocketDataProvider::OnWrite(data); | |
| 355 } | |
| 356 } | |
| 357 | |
| 358 private: | |
| 359 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithFileTypecode); | |
| 360 }; | |
| 361 | |
| 362 class FtpSocketDataProviderFileDownload : public FtpSocketDataProvider { | |
| 363 public: | |
| 364 FtpSocketDataProviderFileDownload() { | |
| 365 } | |
| 366 | |
| 367 MockWriteResult OnWrite(const std::string& data) override { | |
| 368 if (InjectFault()) | |
| 369 return MockWriteResult(ASYNC, data.length()); | |
| 370 switch (state()) { | |
| 371 case PRE_SIZE: | |
| 372 return Verify("SIZE /file\r\n", data, PRE_CWD, "213 18\r\n"); | |
| 373 case PRE_CWD: | |
| 374 return Verify("CWD /file\r\n", data, | |
| 375 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, | |
| 376 "550 Not a directory\r\n"); | |
| 377 case PRE_RETR: | |
| 378 return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n"); | |
| 379 default: | |
| 380 return FtpSocketDataProvider::OnWrite(data); | |
| 381 } | |
| 382 } | |
| 383 | |
| 384 private: | |
| 385 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownload); | |
| 386 }; | |
| 387 | |
| 388 class FtpSocketDataProviderFileNotFound : public FtpSocketDataProvider { | |
| 389 public: | |
| 390 FtpSocketDataProviderFileNotFound() { | |
| 391 } | |
| 392 | |
| 393 MockWriteResult OnWrite(const std::string& data) override { | |
| 394 if (InjectFault()) | |
| 395 return MockWriteResult(ASYNC, data.length()); | |
| 396 switch (state()) { | |
| 397 case PRE_SIZE: | |
| 398 return Verify("SIZE /file\r\n", data, PRE_CWD, | |
| 399 "550 File Not Found\r\n"); | |
| 400 case PRE_CWD: | |
| 401 return Verify("CWD /file\r\n", data, | |
| 402 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, | |
| 403 "550 File Not Found\r\n"); | |
| 404 case PRE_RETR: | |
| 405 return Verify("RETR /file\r\n", data, PRE_QUIT, | |
| 406 "550 File Not Found\r\n"); | |
| 407 default: | |
| 408 return FtpSocketDataProvider::OnWrite(data); | |
| 409 } | |
| 410 } | |
| 411 | |
| 412 private: | |
| 413 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileNotFound); | |
| 414 }; | |
| 415 | |
| 416 class FtpSocketDataProviderFileDownloadWithPasvFallback | |
| 417 : public FtpSocketDataProviderFileDownload { | |
| 418 public: | |
| 419 FtpSocketDataProviderFileDownloadWithPasvFallback() { | |
| 420 } | |
| 421 | |
| 422 MockWriteResult OnWrite(const std::string& data) override { | |
| 423 if (InjectFault()) | |
| 424 return MockWriteResult(ASYNC, data.length()); | |
| 425 switch (state()) { | |
| 426 case PRE_RETR_EPSV: | |
| 427 return Verify("EPSV\r\n", data, PRE_RETR_PASV, "500 No can do\r\n"); | |
| 428 case PRE_CWD: | |
| 429 return Verify("CWD /file\r\n", data, | |
| 430 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, | |
| 431 "550 Not a directory\r\n"); | |
| 432 default: | |
| 433 return FtpSocketDataProviderFileDownload::OnWrite(data); | |
| 434 } | |
| 435 } | |
| 436 | |
| 437 private: | |
| 438 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithPasvFallback); | |
| 439 }; | |
| 440 | |
| 441 class FtpSocketDataProviderFileDownloadZeroSize | |
| 442 : public FtpSocketDataProviderFileDownload { | |
| 443 public: | |
| 444 FtpSocketDataProviderFileDownloadZeroSize() { | |
| 445 } | |
| 446 | |
| 447 MockWriteResult OnWrite(const std::string& data) override { | |
| 448 if (InjectFault()) | |
| 449 return MockWriteResult(ASYNC, data.length()); | |
| 450 switch (state()) { | |
| 451 case PRE_SIZE: | |
| 452 return Verify("SIZE /file\r\n", data, PRE_CWD, | |
| 453 "213 0\r\n"); | |
| 454 case PRE_CWD: | |
| 455 return Verify("CWD /file\r\n", data, | |
| 456 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, | |
| 457 "550 not a directory\r\n"); | |
| 458 default: | |
| 459 return FtpSocketDataProviderFileDownload::OnWrite(data); | |
| 460 } | |
| 461 } | |
| 462 | |
| 463 private: | |
| 464 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadZeroSize); | |
| 465 }; | |
| 466 | |
| 467 class FtpSocketDataProviderFileDownloadCWD451 | |
| 468 : public FtpSocketDataProviderFileDownload { | |
| 469 public: | |
| 470 FtpSocketDataProviderFileDownloadCWD451() { | |
| 471 } | |
| 472 | |
| 473 MockWriteResult OnWrite(const std::string& data) override { | |
| 474 if (InjectFault()) | |
| 475 return MockWriteResult(ASYNC, data.length()); | |
| 476 switch (state()) { | |
| 477 case PRE_CWD: | |
| 478 return Verify("CWD /file\r\n", data, | |
| 479 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, | |
| 480 "451 not a directory\r\n"); | |
| 481 default: | |
| 482 return FtpSocketDataProviderFileDownload::OnWrite(data); | |
| 483 } | |
| 484 } | |
| 485 | |
| 486 private: | |
| 487 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadCWD451); | |
| 488 }; | |
| 489 | |
| 490 class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider { | |
| 491 public: | |
| 492 FtpSocketDataProviderVMSFileDownload() { | |
| 493 } | |
| 494 | |
| 495 MockWriteResult OnWrite(const std::string& data) override { | |
| 496 if (InjectFault()) | |
| 497 return MockWriteResult(ASYNC, data.length()); | |
| 498 switch (state()) { | |
| 499 case PRE_SYST: | |
| 500 return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n"); | |
| 501 case PRE_PWD: | |
| 502 return Verify("PWD\r\n", data, PRE_TYPE, | |
| 503 "257 \"ANONYMOUS_ROOT:[000000]\"\r\n"); | |
| 504 case PRE_LIST_EPSV: | |
| 505 return Verify("EPSV\r\n", data, PRE_LIST_PASV, | |
| 506 "500 EPSV command unknown\r\n"); | |
| 507 case PRE_SIZE: | |
| 508 return Verify("SIZE ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_CWD, | |
| 509 "213 18\r\n"); | |
| 510 case PRE_CWD: | |
| 511 return Verify("CWD ANONYMOUS_ROOT:[file]\r\n", data, | |
| 512 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, | |
| 513 "550 Not a directory\r\n"); | |
| 514 case PRE_RETR: | |
| 515 return Verify("RETR ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_QUIT, | |
| 516 "200 OK\r\n"); | |
| 517 default: | |
| 518 return FtpSocketDataProvider::OnWrite(data); | |
| 519 } | |
| 520 } | |
| 521 | |
| 522 private: | |
| 523 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderVMSFileDownload); | |
| 524 }; | |
| 525 | |
| 526 class FtpSocketDataProviderEscaping : public FtpSocketDataProviderFileDownload { | |
| 527 public: | |
| 528 FtpSocketDataProviderEscaping() { | |
| 529 } | |
| 530 | |
| 531 MockWriteResult OnWrite(const std::string& data) override { | |
| 532 if (InjectFault()) | |
| 533 return MockWriteResult(ASYNC, data.length()); | |
| 534 switch (state()) { | |
| 535 case PRE_SIZE: | |
| 536 return Verify("SIZE / !\"#$%y\200\201\r\n", data, PRE_CWD, | |
| 537 "213 18\r\n"); | |
| 538 case PRE_CWD: | |
| 539 return Verify("CWD / !\"#$%y\200\201\r\n", data, | |
| 540 use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV, | |
| 541 "550 Not a directory\r\n"); | |
| 542 case PRE_RETR: | |
| 543 return Verify("RETR / !\"#$%y\200\201\r\n", data, PRE_QUIT, | |
| 544 "200 OK\r\n"); | |
| 545 default: | |
| 546 return FtpSocketDataProviderFileDownload::OnWrite(data); | |
| 547 } | |
| 548 } | |
| 549 | |
| 550 private: | |
| 551 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEscaping); | |
| 552 }; | |
| 553 | |
| 554 class FtpSocketDataProviderFileDownloadTransferStarting | |
| 555 : public FtpSocketDataProviderFileDownload { | |
| 556 public: | |
| 557 FtpSocketDataProviderFileDownloadTransferStarting() { | |
| 558 } | |
| 559 | |
| 560 MockWriteResult OnWrite(const std::string& data) override { | |
| 561 if (InjectFault()) | |
| 562 return MockWriteResult(ASYNC, data.length()); | |
| 563 switch (state()) { | |
| 564 case PRE_RETR: | |
| 565 return Verify("RETR /file\r\n", data, PRE_QUIT, | |
| 566 "125-Data connection already open.\r\n" | |
| 567 "125 Transfer starting.\r\n" | |
| 568 "226 Transfer complete.\r\n"); | |
| 569 default: | |
| 570 return FtpSocketDataProviderFileDownload::OnWrite(data); | |
| 571 } | |
| 572 } | |
| 573 | |
| 574 private: | |
| 575 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadTransferStarting); | |
| 576 }; | |
| 577 | |
| 578 class FtpSocketDataProviderDirectoryListingTransferStarting | |
| 579 : public FtpSocketDataProviderDirectoryListing { | |
| 580 public: | |
| 581 FtpSocketDataProviderDirectoryListingTransferStarting() { | |
| 582 } | |
| 583 | |
| 584 MockWriteResult OnWrite(const std::string& data) override { | |
| 585 if (InjectFault()) | |
| 586 return MockWriteResult(ASYNC, data.length()); | |
| 587 switch (state()) { | |
| 588 case PRE_LIST: | |
| 589 return Verify("LIST -l\r\n", data, PRE_QUIT, | |
| 590 "125-Data connection already open.\r\n" | |
| 591 "125 Transfer starting.\r\n" | |
| 592 "226 Transfer complete.\r\n"); | |
| 593 default: | |
| 594 return FtpSocketDataProviderDirectoryListing::OnWrite(data); | |
| 595 } | |
| 596 } | |
| 597 | |
| 598 private: | |
| 599 DISALLOW_COPY_AND_ASSIGN( | |
| 600 FtpSocketDataProviderDirectoryListingTransferStarting); | |
| 601 }; | |
| 602 | |
| 603 class FtpSocketDataProviderFileDownloadInvalidResponse | |
| 604 : public FtpSocketDataProviderFileDownload { | |
| 605 public: | |
| 606 FtpSocketDataProviderFileDownloadInvalidResponse() { | |
| 607 } | |
| 608 | |
| 609 MockWriteResult OnWrite(const std::string& data) override { | |
| 610 if (InjectFault()) | |
| 611 return MockWriteResult(ASYNC, data.length()); | |
| 612 switch (state()) { | |
| 613 case PRE_SIZE: | |
| 614 // Use unallocated 599 FTP error code to make sure it falls into the | |
| 615 // generic ERR_FTP_FAILED bucket. | |
| 616 return Verify("SIZE /file\r\n", data, PRE_QUIT, | |
| 617 "599 Evil Response\r\n" | |
| 618 "599 More Evil\r\n"); | |
| 619 default: | |
| 620 return FtpSocketDataProviderFileDownload::OnWrite(data); | |
| 621 } | |
| 622 } | |
| 623 | |
| 624 private: | |
| 625 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadInvalidResponse); | |
| 626 }; | |
| 627 | |
| 628 class FtpSocketDataProviderEvilEpsv : public FtpSocketDataProviderFileDownload { | |
| 629 public: | |
| 630 FtpSocketDataProviderEvilEpsv(const char* epsv_response, | |
| 631 State expected_state) | |
| 632 : epsv_response_(epsv_response), | |
| 633 epsv_response_length_(std::strlen(epsv_response)), | |
| 634 expected_state_(expected_state) {} | |
| 635 | |
| 636 FtpSocketDataProviderEvilEpsv(const char* epsv_response, | |
| 637 size_t epsv_response_length, | |
| 638 State expected_state) | |
| 639 : epsv_response_(epsv_response), | |
| 640 epsv_response_length_(epsv_response_length), | |
| 641 expected_state_(expected_state) {} | |
| 642 | |
| 643 MockWriteResult OnWrite(const std::string& data) override { | |
| 644 if (InjectFault()) | |
| 645 return MockWriteResult(ASYNC, data.length()); | |
| 646 switch (state()) { | |
| 647 case PRE_RETR_EPSV: | |
| 648 return Verify("EPSV\r\n", data, expected_state_, | |
| 649 epsv_response_, epsv_response_length_); | |
| 650 default: | |
| 651 return FtpSocketDataProviderFileDownload::OnWrite(data); | |
| 652 } | |
| 653 } | |
| 654 | |
| 655 private: | |
| 656 const char* epsv_response_; | |
| 657 const size_t epsv_response_length_; | |
| 658 const State expected_state_; | |
| 659 | |
| 660 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilEpsv); | |
| 661 }; | |
| 662 | |
| 663 class FtpSocketDataProviderEvilPasv | |
| 664 : public FtpSocketDataProviderFileDownloadWithPasvFallback { | |
| 665 public: | |
| 666 FtpSocketDataProviderEvilPasv(const char* pasv_response, State expected_state) | |
| 667 : pasv_response_(pasv_response), | |
| 668 expected_state_(expected_state) { | |
| 669 } | |
| 670 | |
| 671 MockWriteResult OnWrite(const std::string& data) override { | |
| 672 if (InjectFault()) | |
| 673 return MockWriteResult(ASYNC, data.length()); | |
| 674 switch (state()) { | |
| 675 case PRE_RETR_PASV: | |
| 676 return Verify("PASV\r\n", data, expected_state_, pasv_response_); | |
| 677 default: | |
| 678 return FtpSocketDataProviderFileDownloadWithPasvFallback::OnWrite(data); | |
| 679 } | |
| 680 } | |
| 681 | |
| 682 private: | |
| 683 const char* pasv_response_; | |
| 684 const State expected_state_; | |
| 685 | |
| 686 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilPasv); | |
| 687 }; | |
| 688 | |
| 689 class FtpSocketDataProviderEvilSize : public FtpSocketDataProviderFileDownload { | |
| 690 public: | |
| 691 FtpSocketDataProviderEvilSize(const char* size_response, State expected_state) | |
| 692 : size_response_(size_response), | |
| 693 expected_state_(expected_state) { | |
| 694 } | |
| 695 | |
| 696 MockWriteResult OnWrite(const std::string& data) override { | |
| 697 if (InjectFault()) | |
| 698 return MockWriteResult(ASYNC, data.length()); | |
| 699 switch (state()) { | |
| 700 case PRE_SIZE: | |
| 701 return Verify("SIZE /file\r\n", data, expected_state_, size_response_); | |
| 702 default: | |
| 703 return FtpSocketDataProviderFileDownload::OnWrite(data); | |
| 704 } | |
| 705 } | |
| 706 | |
| 707 private: | |
| 708 const char* size_response_; | |
| 709 const State expected_state_; | |
| 710 | |
| 711 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilSize); | |
| 712 }; | |
| 713 | |
| 714 class FtpSocketDataProviderEvilLogin | |
| 715 : public FtpSocketDataProviderFileDownload { | |
| 716 public: | |
| 717 FtpSocketDataProviderEvilLogin(const char* expected_user, | |
| 718 const char* expected_password) | |
| 719 : expected_user_(expected_user), | |
| 720 expected_password_(expected_password) { | |
| 721 } | |
| 722 | |
| 723 MockWriteResult OnWrite(const std::string& data) override { | |
| 724 if (InjectFault()) | |
| 725 return MockWriteResult(ASYNC, data.length()); | |
| 726 switch (state()) { | |
| 727 case PRE_USER: | |
| 728 return Verify(std::string("USER ") + expected_user_ + "\r\n", data, | |
| 729 PRE_PASSWD, "331 Password needed\r\n"); | |
| 730 case PRE_PASSWD: | |
| 731 return Verify(std::string("PASS ") + expected_password_ + "\r\n", data, | |
| 732 PRE_SYST, "230 Welcome\r\n"); | |
| 733 default: | |
| 734 return FtpSocketDataProviderFileDownload::OnWrite(data); | |
| 735 } | |
| 736 } | |
| 737 | |
| 738 private: | |
| 739 const char* expected_user_; | |
| 740 const char* expected_password_; | |
| 741 | |
| 742 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilLogin); | |
| 743 }; | |
| 744 | |
| 745 class FtpSocketDataProviderCloseConnection : public FtpSocketDataProvider { | |
| 746 public: | |
| 747 FtpSocketDataProviderCloseConnection() { | |
| 748 } | |
| 749 | |
| 750 MockWriteResult OnWrite(const std::string& data) override { | |
| 751 if (InjectFault()) | |
| 752 return MockWriteResult(ASYNC, data.length()); | |
| 753 switch (state()) { | |
| 754 case PRE_USER: | |
| 755 return Verify("USER anonymous\r\n", data, | |
| 756 PRE_QUIT, ""); | |
| 757 default: | |
| 758 return FtpSocketDataProvider::OnWrite(data); | |
| 759 } | |
| 760 } | |
| 761 | |
| 762 private: | |
| 763 DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderCloseConnection); | |
| 764 }; | |
| 765 | |
| 766 class FtpNetworkTransactionTest | |
| 767 : public PlatformTest, | |
| 768 public ::testing::WithParamInterface<int> { | |
| 769 public: | |
| 770 FtpNetworkTransactionTest() | |
| 771 : host_resolver_(new MockHostResolver), | |
| 772 session_(new FtpNetworkSession(host_resolver_.get())), | |
| 773 transaction_(session_.get(), &mock_socket_factory_) { | |
| 774 scoped_refptr<RuleBasedHostResolverProc> rules( | |
| 775 new RuleBasedHostResolverProc(NULL)); | |
| 776 if (GetFamily() == AF_INET) { | |
| 777 rules->AddIPLiteralRule("*", "127.0.0.1", "127.0.0.1"); | |
| 778 } else if (GetFamily() == AF_INET6) { | |
| 779 rules->AddIPLiteralRule("*", "::1", "::1"); | |
| 780 } else { | |
| 781 NOTREACHED(); | |
| 782 } | |
| 783 host_resolver_->set_rules(rules.get()); | |
| 784 } | |
| 785 | |
| 786 protected: | |
| 787 // Accessor to make code refactoring-friendly, e.g. when we change the way | |
| 788 // parameters are passed (like more parameters). | |
| 789 int GetFamily() { | |
| 790 return GetParam(); | |
| 791 } | |
| 792 | |
| 793 FtpRequestInfo GetRequestInfo(const std::string& url) { | |
| 794 FtpRequestInfo info; | |
| 795 info.url = GURL(url); | |
| 796 return info; | |
| 797 } | |
| 798 | |
| 799 void ExecuteTransaction(FtpSocketDataProvider* ctrl_socket, | |
| 800 const char* request, | |
| 801 int expected_result) { | |
| 802 // Expect EPSV usage for non-IPv4 control connections. | |
| 803 ctrl_socket->set_use_epsv((GetFamily() != AF_INET)); | |
| 804 | |
| 805 mock_socket_factory_.AddSocketDataProvider(ctrl_socket); | |
| 806 | |
| 807 std::string mock_data("mock-data"); | |
| 808 MockRead data_reads[] = { | |
| 809 // Usually FTP servers close the data connection after the entire data has | |
| 810 // been received. | |
| 811 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), | |
| 812 MockRead(mock_data.c_str()), | |
| 813 }; | |
| 814 | |
| 815 scoped_ptr<StaticSocketDataProvider> data_socket( | |
| 816 new StaticSocketDataProvider(data_reads, arraysize(data_reads), NULL, | |
| 817 0)); | |
| 818 mock_socket_factory_.AddSocketDataProvider(data_socket.get()); | |
| 819 FtpRequestInfo request_info = GetRequestInfo(request); | |
| 820 EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState()); | |
| 821 ASSERT_EQ(ERR_IO_PENDING, | |
| 822 transaction_.Start(&request_info, callback_.callback(), | |
| 823 BoundNetLog())); | |
| 824 EXPECT_NE(LOAD_STATE_IDLE, transaction_.GetLoadState()); | |
| 825 ASSERT_EQ(expected_result, callback_.WaitForResult()); | |
| 826 if (expected_result == OK) { | |
| 827 scoped_refptr<IOBuffer> io_buffer(new IOBuffer(kBufferSize)); | |
| 828 memset(io_buffer->data(), 0, kBufferSize); | |
| 829 ASSERT_EQ(ERR_IO_PENDING, | |
| 830 transaction_.Read(io_buffer.get(), kBufferSize, | |
| 831 callback_.callback())); | |
| 832 ASSERT_EQ(static_cast<int>(mock_data.length()), | |
| 833 callback_.WaitForResult()); | |
| 834 EXPECT_EQ(mock_data, std::string(io_buffer->data(), mock_data.length())); | |
| 835 | |
| 836 // Do another Read to detect that the data socket is now closed. | |
| 837 int rv = transaction_.Read(io_buffer.get(), kBufferSize, | |
| 838 callback_.callback()); | |
| 839 if (rv == ERR_IO_PENDING) { | |
| 840 EXPECT_EQ(0, callback_.WaitForResult()); | |
| 841 } else { | |
| 842 EXPECT_EQ(0, rv); | |
| 843 } | |
| 844 } | |
| 845 EXPECT_EQ(FtpSocketDataProvider::QUIT, ctrl_socket->state()); | |
| 846 EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState()); | |
| 847 } | |
| 848 | |
| 849 void TransactionFailHelper(FtpSocketDataProvider* ctrl_socket, | |
| 850 const char* request, | |
| 851 FtpSocketDataProvider::State state, | |
| 852 FtpSocketDataProvider::State next_state, | |
| 853 const char* response, | |
| 854 int expected_result) { | |
| 855 ctrl_socket->InjectFailure(state, next_state, response); | |
| 856 ExecuteTransaction(ctrl_socket, request, expected_result); | |
| 857 } | |
| 858 | |
| 859 scoped_ptr<MockHostResolver> host_resolver_; | |
| 860 scoped_refptr<FtpNetworkSession> session_; | |
| 861 MockClientSocketFactory mock_socket_factory_; | |
| 862 FtpNetworkTransaction transaction_; | |
| 863 TestCompletionCallback callback_; | |
| 864 }; | |
| 865 | |
| 866 TEST_P(FtpNetworkTransactionTest, FailedLookup) { | |
| 867 FtpRequestInfo request_info = GetRequestInfo("ftp://badhost"); | |
| 868 scoped_refptr<RuleBasedHostResolverProc> rules( | |
| 869 new RuleBasedHostResolverProc(NULL)); | |
| 870 rules->AddSimulatedFailure("badhost"); | |
| 871 host_resolver_->set_rules(rules.get()); | |
| 872 | |
| 873 EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState()); | |
| 874 ASSERT_EQ(ERR_IO_PENDING, | |
| 875 transaction_.Start(&request_info, callback_.callback(), | |
| 876 BoundNetLog())); | |
| 877 ASSERT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult()); | |
| 878 EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState()); | |
| 879 } | |
| 880 | |
| 881 // Check that when determining the host, the square brackets decorating IPv6 | |
| 882 // literals in URLs are stripped. | |
| 883 TEST_P(FtpNetworkTransactionTest, StripBracketsFromIPv6Literals) { | |
| 884 // This test only makes sense for IPv6 connections. | |
| 885 if (GetFamily() != AF_INET6) | |
| 886 return; | |
| 887 | |
| 888 host_resolver_->rules()->AddSimulatedFailure("[::1]"); | |
| 889 | |
| 890 // We start a transaction that is expected to fail with ERR_INVALID_RESPONSE. | |
| 891 // The important part of this test is to make sure that we don't fail with | |
| 892 // ERR_NAME_NOT_RESOLVED, since that would mean the decorated hostname | |
| 893 // was used. | |
| 894 FtpSocketDataProviderEvilSize ctrl_socket( | |
| 895 "213 99999999999999999999999999999999\r\n", | |
| 896 FtpSocketDataProvider::PRE_QUIT); | |
| 897 ExecuteTransaction(&ctrl_socket, "ftp://[::1]/file", ERR_INVALID_RESPONSE); | |
| 898 } | |
| 899 | |
| 900 TEST_P(FtpNetworkTransactionTest, DirectoryTransaction) { | |
| 901 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 902 ExecuteTransaction(&ctrl_socket, "ftp://host", OK); | |
| 903 | |
| 904 EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing); | |
| 905 EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size); | |
| 906 EXPECT_EQ((GetFamily() == AF_INET) ? "127.0.0.1" : "::1", | |
| 907 transaction_.GetResponseInfo()->socket_address.host()); | |
| 908 EXPECT_EQ(21, transaction_.GetResponseInfo()->socket_address.port()); | |
| 909 } | |
| 910 | |
| 911 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionWithPasvFallback) { | |
| 912 FtpSocketDataProviderDirectoryListingWithPasvFallback ctrl_socket; | |
| 913 ExecuteTransaction(&ctrl_socket, "ftp://host", OK); | |
| 914 | |
| 915 EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing); | |
| 916 EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size); | |
| 917 } | |
| 918 | |
| 919 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionWithTypecode) { | |
| 920 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 921 ExecuteTransaction(&ctrl_socket, "ftp://host/;type=d", OK); | |
| 922 | |
| 923 EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing); | |
| 924 EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size); | |
| 925 } | |
| 926 | |
| 927 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionMultilineWelcome) { | |
| 928 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 929 ctrl_socket.set_multiline_welcome(true); | |
| 930 ExecuteTransaction(&ctrl_socket, "ftp://host", OK); | |
| 931 } | |
| 932 | |
| 933 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionShortReads2) { | |
| 934 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 935 ctrl_socket.set_short_read_limit(2); | |
| 936 ExecuteTransaction(&ctrl_socket, "ftp://host", OK); | |
| 937 } | |
| 938 | |
| 939 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionShortReads5) { | |
| 940 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 941 ctrl_socket.set_short_read_limit(5); | |
| 942 ExecuteTransaction(&ctrl_socket, "ftp://host", OK); | |
| 943 } | |
| 944 | |
| 945 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionMultilineWelcomeShort) { | |
| 946 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 947 // The client will not consume all three 230 lines. That's good, we want to | |
| 948 // test that scenario. | |
| 949 ctrl_socket.allow_unconsumed_reads(true); | |
| 950 ctrl_socket.set_multiline_welcome(true); | |
| 951 ctrl_socket.set_short_read_limit(5); | |
| 952 ExecuteTransaction(&ctrl_socket, "ftp://host", OK); | |
| 953 } | |
| 954 | |
| 955 // Regression test for http://crbug.com/60555. | |
| 956 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionZeroSize) { | |
| 957 FtpSocketDataProviderDirectoryListingZeroSize ctrl_socket; | |
| 958 ExecuteTransaction(&ctrl_socket, "ftp://host", OK); | |
| 959 } | |
| 960 | |
| 961 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionVMS) { | |
| 962 FtpSocketDataProviderVMSDirectoryListing ctrl_socket; | |
| 963 ExecuteTransaction(&ctrl_socket, "ftp://host/dir", OK); | |
| 964 } | |
| 965 | |
| 966 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionVMSRootDirectory) { | |
| 967 FtpSocketDataProviderVMSDirectoryListingRootDirectory ctrl_socket; | |
| 968 ExecuteTransaction(&ctrl_socket, "ftp://host", OK); | |
| 969 } | |
| 970 | |
| 971 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionTransferStarting) { | |
| 972 FtpSocketDataProviderDirectoryListingTransferStarting ctrl_socket; | |
| 973 ExecuteTransaction(&ctrl_socket, "ftp://host", OK); | |
| 974 } | |
| 975 | |
| 976 TEST_P(FtpNetworkTransactionTest, DownloadTransaction) { | |
| 977 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 978 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 979 | |
| 980 // We pass an artificial value of 18 as a response to the SIZE command. | |
| 981 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); | |
| 982 EXPECT_EQ((GetFamily() == AF_INET) ? "127.0.0.1" : "::1", | |
| 983 transaction_.GetResponseInfo()->socket_address.host()); | |
| 984 EXPECT_EQ(21, transaction_.GetResponseInfo()->socket_address.port()); | |
| 985 } | |
| 986 | |
| 987 TEST_P(FtpNetworkTransactionTest, DownloadTransactionWithPasvFallback) { | |
| 988 FtpSocketDataProviderFileDownloadWithPasvFallback ctrl_socket; | |
| 989 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 990 | |
| 991 // We pass an artificial value of 18 as a response to the SIZE command. | |
| 992 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); | |
| 993 } | |
| 994 | |
| 995 TEST_P(FtpNetworkTransactionTest, DownloadTransactionWithTypecodeA) { | |
| 996 FtpSocketDataProviderFileDownloadWithFileTypecode ctrl_socket; | |
| 997 ctrl_socket.set_data_type('A'); | |
| 998 ExecuteTransaction(&ctrl_socket, "ftp://host/file;type=a", OK); | |
| 999 | |
| 1000 // We pass an artificial value of 18 as a response to the SIZE command. | |
| 1001 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); | |
| 1002 } | |
| 1003 | |
| 1004 TEST_P(FtpNetworkTransactionTest, DownloadTransactionWithTypecodeI) { | |
| 1005 FtpSocketDataProviderFileDownloadWithFileTypecode ctrl_socket; | |
| 1006 ExecuteTransaction(&ctrl_socket, "ftp://host/file;type=i", OK); | |
| 1007 | |
| 1008 // We pass an artificial value of 18 as a response to the SIZE command. | |
| 1009 EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size); | |
| 1010 } | |
| 1011 | |
| 1012 TEST_P(FtpNetworkTransactionTest, DownloadTransactionMultilineWelcome) { | |
| 1013 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1014 ctrl_socket.set_multiline_welcome(true); | |
| 1015 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 1016 } | |
| 1017 | |
| 1018 TEST_P(FtpNetworkTransactionTest, DownloadTransactionShortReads2) { | |
| 1019 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1020 ctrl_socket.set_short_read_limit(2); | |
| 1021 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 1022 } | |
| 1023 | |
| 1024 TEST_P(FtpNetworkTransactionTest, DownloadTransactionShortReads5) { | |
| 1025 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1026 ctrl_socket.set_short_read_limit(5); | |
| 1027 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 1028 } | |
| 1029 | |
| 1030 TEST_P(FtpNetworkTransactionTest, DownloadTransactionZeroSize) { | |
| 1031 FtpSocketDataProviderFileDownloadZeroSize ctrl_socket; | |
| 1032 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 1033 } | |
| 1034 | |
| 1035 TEST_P(FtpNetworkTransactionTest, DownloadTransactionCWD451) { | |
| 1036 FtpSocketDataProviderFileDownloadCWD451 ctrl_socket; | |
| 1037 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 1038 } | |
| 1039 | |
| 1040 TEST_P(FtpNetworkTransactionTest, DownloadTransactionVMS) { | |
| 1041 FtpSocketDataProviderVMSFileDownload ctrl_socket; | |
| 1042 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 1043 } | |
| 1044 | |
| 1045 TEST_P(FtpNetworkTransactionTest, DownloadTransactionTransferStarting) { | |
| 1046 FtpSocketDataProviderFileDownloadTransferStarting ctrl_socket; | |
| 1047 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 1048 } | |
| 1049 | |
| 1050 TEST_P(FtpNetworkTransactionTest, DownloadTransactionInvalidResponse) { | |
| 1051 FtpSocketDataProviderFileDownloadInvalidResponse ctrl_socket; | |
| 1052 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE); | |
| 1053 } | |
| 1054 | |
| 1055 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvReallyBadFormat) { | |
| 1056 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,\r\n", | |
| 1057 FtpSocketDataProvider::PRE_QUIT); | |
| 1058 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE); | |
| 1059 } | |
| 1060 | |
| 1061 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort1) { | |
| 1062 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,0,22)\r\n", | |
| 1063 FtpSocketDataProvider::PRE_QUIT); | |
| 1064 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_UNSAFE_PORT); | |
| 1065 } | |
| 1066 | |
| 1067 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort2) { | |
| 1068 // Still unsafe. 1 * 256 + 2 = 258, which is < 1024. | |
| 1069 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,1,2)\r\n", | |
| 1070 FtpSocketDataProvider::PRE_QUIT); | |
| 1071 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_UNSAFE_PORT); | |
| 1072 } | |
| 1073 | |
| 1074 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort3) { | |
| 1075 // Still unsafe. 3 * 256 + 4 = 772, which is < 1024. | |
| 1076 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,3,4)\r\n", | |
| 1077 FtpSocketDataProvider::PRE_QUIT); | |
| 1078 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_UNSAFE_PORT); | |
| 1079 } | |
| 1080 | |
| 1081 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafePort4) { | |
| 1082 // Unsafe. 8 * 256 + 1 = 2049, which is used by nfs. | |
| 1083 FtpSocketDataProviderEvilPasv ctrl_socket("227 Portscan (127,0,0,1,8,1)\r\n", | |
| 1084 FtpSocketDataProvider::PRE_QUIT); | |
| 1085 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_UNSAFE_PORT); | |
| 1086 } | |
| 1087 | |
| 1088 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafeHost) { | |
| 1089 FtpSocketDataProviderEvilPasv ctrl_socket( | |
| 1090 "227 Portscan (10,1,2,3,123,456)\r\n", FtpSocketDataProvider::PRE_RETR); | |
| 1091 ctrl_socket.set_use_epsv(GetFamily() != AF_INET); | |
| 1092 std::string mock_data("mock-data"); | |
| 1093 MockRead data_reads[] = { | |
| 1094 MockRead(mock_data.c_str()), | |
| 1095 }; | |
| 1096 StaticSocketDataProvider data_socket1; | |
| 1097 StaticSocketDataProvider data_socket2(data_reads, arraysize(data_reads), | |
| 1098 NULL, 0); | |
| 1099 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket); | |
| 1100 mock_socket_factory_.AddSocketDataProvider(&data_socket1); | |
| 1101 mock_socket_factory_.AddSocketDataProvider(&data_socket2); | |
| 1102 FtpRequestInfo request_info = GetRequestInfo("ftp://host/file"); | |
| 1103 | |
| 1104 // Start the transaction. | |
| 1105 ASSERT_EQ(ERR_IO_PENDING, | |
| 1106 transaction_.Start(&request_info, callback_.callback(), | |
| 1107 BoundNetLog())); | |
| 1108 ASSERT_EQ(OK, callback_.WaitForResult()); | |
| 1109 | |
| 1110 // The transaction fires the callback when we can start reading data. That | |
| 1111 // means that the data socket should be open. | |
| 1112 MockTCPClientSocket* data_socket = | |
| 1113 static_cast<MockTCPClientSocket*>(transaction_.data_socket_.get()); | |
| 1114 ASSERT_TRUE(data_socket); | |
| 1115 ASSERT_TRUE(data_socket->IsConnected()); | |
| 1116 | |
| 1117 // Even if the PASV response specified some other address, we connect | |
| 1118 // to the address we used for control connection (which could be 127.0.0.1 | |
| 1119 // or ::1 depending on whether we use IPv6). | |
| 1120 for (AddressList::const_iterator it = data_socket->addresses().begin(); | |
| 1121 it != data_socket->addresses().end(); ++it) { | |
| 1122 EXPECT_NE("10.1.2.3", it->ToStringWithoutPort()); | |
| 1123 } | |
| 1124 } | |
| 1125 | |
| 1126 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat1) { | |
| 1127 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1128 if (GetFamily() == AF_INET) | |
| 1129 return; | |
| 1130 | |
| 1131 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||22)\r\n", | |
| 1132 FtpSocketDataProvider::PRE_QUIT); | |
| 1133 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE); | |
| 1134 } | |
| 1135 | |
| 1136 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat2) { | |
| 1137 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1138 if (GetFamily() == AF_INET) | |
| 1139 return; | |
| 1140 | |
| 1141 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (||\r\n", | |
| 1142 FtpSocketDataProvider::PRE_QUIT); | |
| 1143 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE); | |
| 1144 } | |
| 1145 | |
| 1146 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat3) { | |
| 1147 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1148 if (GetFamily() == AF_INET) | |
| 1149 return; | |
| 1150 | |
| 1151 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan\r\n", | |
| 1152 FtpSocketDataProvider::PRE_QUIT); | |
| 1153 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE); | |
| 1154 } | |
| 1155 | |
| 1156 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat4) { | |
| 1157 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1158 if (GetFamily() == AF_INET) | |
| 1159 return; | |
| 1160 | |
| 1161 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (||||)\r\n", | |
| 1162 FtpSocketDataProvider::PRE_QUIT); | |
| 1163 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE); | |
| 1164 } | |
| 1165 | |
| 1166 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat5) { | |
| 1167 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1168 if (GetFamily() == AF_INET) | |
| 1169 return; | |
| 1170 | |
| 1171 // Breaking the string in the next line prevents MSVC warning C4125. | |
| 1172 const char response[] = "227 Portscan (\0\0\031" "773\0)\r\n"; | |
| 1173 FtpSocketDataProviderEvilEpsv ctrl_socket(response, sizeof(response)-1, | |
| 1174 FtpSocketDataProvider::PRE_QUIT); | |
| 1175 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE); | |
| 1176 } | |
| 1177 | |
| 1178 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort1) { | |
| 1179 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1180 if (GetFamily() == AF_INET) | |
| 1181 return; | |
| 1182 | |
| 1183 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||22|)\r\n", | |
| 1184 FtpSocketDataProvider::PRE_QUIT); | |
| 1185 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_UNSAFE_PORT); | |
| 1186 } | |
| 1187 | |
| 1188 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort2) { | |
| 1189 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1190 if (GetFamily() == AF_INET) | |
| 1191 return; | |
| 1192 | |
| 1193 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||258|)\r\n", | |
| 1194 FtpSocketDataProvider::PRE_QUIT); | |
| 1195 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_UNSAFE_PORT); | |
| 1196 } | |
| 1197 | |
| 1198 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort3) { | |
| 1199 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1200 if (GetFamily() == AF_INET) | |
| 1201 return; | |
| 1202 | |
| 1203 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||772|)\r\n", | |
| 1204 FtpSocketDataProvider::PRE_QUIT); | |
| 1205 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_UNSAFE_PORT); | |
| 1206 } | |
| 1207 | |
| 1208 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort4) { | |
| 1209 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1210 if (GetFamily() == AF_INET) | |
| 1211 return; | |
| 1212 | |
| 1213 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||2049|)\r\n", | |
| 1214 FtpSocketDataProvider::PRE_QUIT); | |
| 1215 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_UNSAFE_PORT); | |
| 1216 } | |
| 1217 | |
| 1218 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvWeirdSep) { | |
| 1219 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1220 if (GetFamily() == AF_INET) | |
| 1221 return; | |
| 1222 | |
| 1223 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan ($$$31744$)\r\n", | |
| 1224 FtpSocketDataProvider::PRE_RETR); | |
| 1225 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 1226 } | |
| 1227 | |
| 1228 TEST_P(FtpNetworkTransactionTest, | |
| 1229 DownloadTransactionEvilEpsvWeirdSepUnsafePort) { | |
| 1230 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1231 if (GetFamily() == AF_INET) | |
| 1232 return; | |
| 1233 | |
| 1234 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan ($$$317$)\r\n", | |
| 1235 FtpSocketDataProvider::PRE_QUIT); | |
| 1236 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_UNSAFE_PORT); | |
| 1237 } | |
| 1238 | |
| 1239 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvIllegalHost) { | |
| 1240 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1241 if (GetFamily() == AF_INET) | |
| 1242 return; | |
| 1243 | |
| 1244 FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|2|::1|31744|)\r\n", | |
| 1245 FtpSocketDataProvider::PRE_QUIT); | |
| 1246 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE); | |
| 1247 } | |
| 1248 | |
| 1249 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilLoginBadUsername) { | |
| 1250 FtpSocketDataProviderEvilLogin ctrl_socket("hello%0Aworld", "test"); | |
| 1251 ExecuteTransaction(&ctrl_socket, "ftp://hello%0Aworld:test@host/file", OK); | |
| 1252 } | |
| 1253 | |
| 1254 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilLoginBadPassword) { | |
| 1255 FtpSocketDataProviderEvilLogin ctrl_socket("test", "hello%0Dworld"); | |
| 1256 ExecuteTransaction(&ctrl_socket, "ftp://test:hello%0Dworld@host/file", OK); | |
| 1257 } | |
| 1258 | |
| 1259 TEST_P(FtpNetworkTransactionTest, DownloadTransactionSpaceInLogin) { | |
| 1260 FtpSocketDataProviderEvilLogin ctrl_socket("hello world", "test"); | |
| 1261 ExecuteTransaction(&ctrl_socket, "ftp://hello%20world:test@host/file", OK); | |
| 1262 } | |
| 1263 | |
| 1264 TEST_P(FtpNetworkTransactionTest, DownloadTransactionSpaceInPassword) { | |
| 1265 FtpSocketDataProviderEvilLogin ctrl_socket("test", "hello world"); | |
| 1266 ExecuteTransaction(&ctrl_socket, "ftp://test:hello%20world@host/file", OK); | |
| 1267 } | |
| 1268 | |
| 1269 TEST_P(FtpNetworkTransactionTest, EvilRestartUser) { | |
| 1270 FtpSocketDataProvider ctrl_socket1; | |
| 1271 ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD, | |
| 1272 FtpSocketDataProvider::PRE_QUIT, | |
| 1273 "530 Login authentication failed\r\n"); | |
| 1274 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1); | |
| 1275 | |
| 1276 FtpRequestInfo request_info = GetRequestInfo("ftp://host/file"); | |
| 1277 | |
| 1278 ASSERT_EQ(ERR_IO_PENDING, | |
| 1279 transaction_.Start(&request_info, callback_.callback(), | |
| 1280 BoundNetLog())); | |
| 1281 ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult()); | |
| 1282 | |
| 1283 MockRead ctrl_reads[] = { | |
| 1284 MockRead("220 host TestFTPd\r\n"), | |
| 1285 MockRead("221 Goodbye!\r\n"), | |
| 1286 MockRead(SYNCHRONOUS, OK), | |
| 1287 }; | |
| 1288 MockWrite ctrl_writes[] = { | |
| 1289 MockWrite("QUIT\r\n"), | |
| 1290 }; | |
| 1291 StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads), | |
| 1292 ctrl_writes, arraysize(ctrl_writes)); | |
| 1293 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); | |
| 1294 ASSERT_EQ(ERR_IO_PENDING, | |
| 1295 transaction_.RestartWithAuth( | |
| 1296 AuthCredentials( | |
| 1297 base::ASCIIToUTF16("foo\nownz0red"), | |
| 1298 base::ASCIIToUTF16("innocent")), | |
| 1299 callback_.callback())); | |
| 1300 EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult()); | |
| 1301 } | |
| 1302 | |
| 1303 TEST_P(FtpNetworkTransactionTest, EvilRestartPassword) { | |
| 1304 FtpSocketDataProvider ctrl_socket1; | |
| 1305 ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD, | |
| 1306 FtpSocketDataProvider::PRE_QUIT, | |
| 1307 "530 Login authentication failed\r\n"); | |
| 1308 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1); | |
| 1309 | |
| 1310 FtpRequestInfo request_info = GetRequestInfo("ftp://host/file"); | |
| 1311 | |
| 1312 ASSERT_EQ(ERR_IO_PENDING, | |
| 1313 transaction_.Start(&request_info, callback_.callback(), | |
| 1314 BoundNetLog())); | |
| 1315 ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult()); | |
| 1316 | |
| 1317 MockRead ctrl_reads[] = { | |
| 1318 MockRead("220 host TestFTPd\r\n"), | |
| 1319 MockRead("331 User okay, send password\r\n"), | |
| 1320 MockRead("221 Goodbye!\r\n"), | |
| 1321 MockRead(SYNCHRONOUS, OK), | |
| 1322 }; | |
| 1323 MockWrite ctrl_writes[] = { | |
| 1324 MockWrite("USER innocent\r\n"), | |
| 1325 MockWrite("QUIT\r\n"), | |
| 1326 }; | |
| 1327 StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads), | |
| 1328 ctrl_writes, arraysize(ctrl_writes)); | |
| 1329 mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2); | |
| 1330 ASSERT_EQ(ERR_IO_PENDING, | |
| 1331 transaction_.RestartWithAuth( | |
| 1332 AuthCredentials(base::ASCIIToUTF16("innocent"), | |
| 1333 base::ASCIIToUTF16("foo\nownz0red")), | |
| 1334 callback_.callback())); | |
| 1335 EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult()); | |
| 1336 } | |
| 1337 | |
| 1338 TEST_P(FtpNetworkTransactionTest, Escaping) { | |
| 1339 FtpSocketDataProviderEscaping ctrl_socket; | |
| 1340 ExecuteTransaction(&ctrl_socket, "ftp://host/%20%21%22%23%24%25%79%80%81", | |
| 1341 OK); | |
| 1342 } | |
| 1343 | |
| 1344 // Test for http://crbug.com/23794. | |
| 1345 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilSize) { | |
| 1346 // Try to overflow int64 in the response. | |
| 1347 FtpSocketDataProviderEvilSize ctrl_socket( | |
| 1348 "213 99999999999999999999999999999999\r\n", | |
| 1349 FtpSocketDataProvider::PRE_QUIT); | |
| 1350 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE); | |
| 1351 } | |
| 1352 | |
| 1353 // Test for http://crbug.com/36360. | |
| 1354 TEST_P(FtpNetworkTransactionTest, DownloadTransactionBigSize) { | |
| 1355 // Pass a valid, but large file size. The transaction should not fail. | |
| 1356 FtpSocketDataProviderEvilSize ctrl_socket( | |
| 1357 "213 3204427776\r\n", | |
| 1358 FtpSocketDataProvider::PRE_CWD); | |
| 1359 ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK); | |
| 1360 EXPECT_EQ(3204427776LL, | |
| 1361 transaction_.GetResponseInfo()->expected_content_size); | |
| 1362 } | |
| 1363 | |
| 1364 // Regression test for http://crbug.com/25023. | |
| 1365 TEST_P(FtpNetworkTransactionTest, CloseConnection) { | |
| 1366 FtpSocketDataProviderCloseConnection ctrl_socket; | |
| 1367 ExecuteTransaction(&ctrl_socket, "ftp://host", ERR_EMPTY_RESPONSE); | |
| 1368 } | |
| 1369 | |
| 1370 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailUser) { | |
| 1371 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 1372 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1373 // ERR_FTP_FAILED bucket. | |
| 1374 TransactionFailHelper(&ctrl_socket, | |
| 1375 "ftp://host", | |
| 1376 FtpSocketDataProvider::PRE_USER, | |
| 1377 FtpSocketDataProvider::PRE_QUIT, | |
| 1378 "599 fail\r\n", | |
| 1379 ERR_FTP_FAILED); | |
| 1380 } | |
| 1381 | |
| 1382 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailPass) { | |
| 1383 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 1384 TransactionFailHelper(&ctrl_socket, | |
| 1385 "ftp://host", | |
| 1386 FtpSocketDataProvider::PRE_PASSWD, | |
| 1387 FtpSocketDataProvider::PRE_QUIT, | |
| 1388 "530 Login authentication failed\r\n", | |
| 1389 ERR_FTP_FAILED); | |
| 1390 } | |
| 1391 | |
| 1392 // Regression test for http://crbug.com/38707. | |
| 1393 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailPass503) { | |
| 1394 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 1395 TransactionFailHelper(&ctrl_socket, | |
| 1396 "ftp://host", | |
| 1397 FtpSocketDataProvider::PRE_PASSWD, | |
| 1398 FtpSocketDataProvider::PRE_QUIT, | |
| 1399 "503 Bad sequence of commands\r\n", | |
| 1400 ERR_FTP_BAD_COMMAND_SEQUENCE); | |
| 1401 } | |
| 1402 | |
| 1403 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailSyst) { | |
| 1404 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 1405 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1406 // ERR_FTP_FAILED bucket. | |
| 1407 TransactionFailHelper(&ctrl_socket, | |
| 1408 "ftp://host", | |
| 1409 FtpSocketDataProvider::PRE_SYST, | |
| 1410 FtpSocketDataProvider::PRE_PWD, | |
| 1411 "599 fail\r\n", | |
| 1412 OK); | |
| 1413 } | |
| 1414 | |
| 1415 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailPwd) { | |
| 1416 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 1417 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1418 // ERR_FTP_FAILED bucket. | |
| 1419 TransactionFailHelper(&ctrl_socket, | |
| 1420 "ftp://host", | |
| 1421 FtpSocketDataProvider::PRE_PWD, | |
| 1422 FtpSocketDataProvider::PRE_QUIT, | |
| 1423 "599 fail\r\n", | |
| 1424 ERR_FTP_FAILED); | |
| 1425 } | |
| 1426 | |
| 1427 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailType) { | |
| 1428 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 1429 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1430 // ERR_FTP_FAILED bucket. | |
| 1431 TransactionFailHelper(&ctrl_socket, | |
| 1432 "ftp://host", | |
| 1433 FtpSocketDataProvider::PRE_TYPE, | |
| 1434 FtpSocketDataProvider::PRE_QUIT, | |
| 1435 "599 fail\r\n", | |
| 1436 ERR_FTP_FAILED); | |
| 1437 } | |
| 1438 | |
| 1439 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailEpsv) { | |
| 1440 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1441 if (GetFamily() == AF_INET) | |
| 1442 return; | |
| 1443 | |
| 1444 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 1445 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1446 // ERR_FTP_FAILED bucket. | |
| 1447 TransactionFailHelper( | |
| 1448 &ctrl_socket, "ftp://host", FtpSocketDataProvider::PRE_LIST_EPSV, | |
| 1449 FtpSocketDataProvider::PRE_NOPASV, "599 fail\r\n", ERR_FTP_FAILED); | |
| 1450 } | |
| 1451 | |
| 1452 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailCwd) { | |
| 1453 FtpSocketDataProviderDirectoryListing ctrl_socket; | |
| 1454 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1455 // ERR_FTP_FAILED bucket. | |
| 1456 TransactionFailHelper(&ctrl_socket, | |
| 1457 "ftp://host", | |
| 1458 FtpSocketDataProvider::PRE_CWD, | |
| 1459 FtpSocketDataProvider::PRE_QUIT, | |
| 1460 "599 fail\r\n", | |
| 1461 ERR_FTP_FAILED); | |
| 1462 } | |
| 1463 | |
| 1464 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailList) { | |
| 1465 FtpSocketDataProviderVMSDirectoryListing ctrl_socket; | |
| 1466 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1467 // ERR_FTP_FAILED bucket. | |
| 1468 TransactionFailHelper(&ctrl_socket, | |
| 1469 "ftp://host/dir", | |
| 1470 FtpSocketDataProvider::PRE_LIST, | |
| 1471 FtpSocketDataProvider::PRE_QUIT, | |
| 1472 "599 fail\r\n", | |
| 1473 ERR_FTP_FAILED); | |
| 1474 } | |
| 1475 | |
| 1476 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailUser) { | |
| 1477 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1478 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1479 // ERR_FTP_FAILED bucket. | |
| 1480 TransactionFailHelper(&ctrl_socket, | |
| 1481 "ftp://host/file", | |
| 1482 FtpSocketDataProvider::PRE_USER, | |
| 1483 FtpSocketDataProvider::PRE_QUIT, | |
| 1484 "599 fail\r\n", | |
| 1485 ERR_FTP_FAILED); | |
| 1486 } | |
| 1487 | |
| 1488 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailPass) { | |
| 1489 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1490 TransactionFailHelper(&ctrl_socket, | |
| 1491 "ftp://host/file", | |
| 1492 FtpSocketDataProvider::PRE_PASSWD, | |
| 1493 FtpSocketDataProvider::PRE_QUIT, | |
| 1494 "530 Login authentication failed\r\n", | |
| 1495 ERR_FTP_FAILED); | |
| 1496 } | |
| 1497 | |
| 1498 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailSyst) { | |
| 1499 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1500 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1501 // ERR_FTP_FAILED bucket. | |
| 1502 TransactionFailHelper(&ctrl_socket, | |
| 1503 "ftp://host/file", | |
| 1504 FtpSocketDataProvider::PRE_SYST, | |
| 1505 FtpSocketDataProvider::PRE_PWD, | |
| 1506 "599 fail\r\n", | |
| 1507 OK); | |
| 1508 } | |
| 1509 | |
| 1510 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailPwd) { | |
| 1511 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1512 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1513 // ERR_FTP_FAILED bucket. | |
| 1514 TransactionFailHelper(&ctrl_socket, | |
| 1515 "ftp://host/file", | |
| 1516 FtpSocketDataProvider::PRE_PWD, | |
| 1517 FtpSocketDataProvider::PRE_QUIT, | |
| 1518 "599 fail\r\n", | |
| 1519 ERR_FTP_FAILED); | |
| 1520 } | |
| 1521 | |
| 1522 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailType) { | |
| 1523 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1524 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1525 // ERR_FTP_FAILED bucket. | |
| 1526 TransactionFailHelper(&ctrl_socket, | |
| 1527 "ftp://host/file", | |
| 1528 FtpSocketDataProvider::PRE_TYPE, | |
| 1529 FtpSocketDataProvider::PRE_QUIT, | |
| 1530 "599 fail\r\n", | |
| 1531 ERR_FTP_FAILED); | |
| 1532 } | |
| 1533 | |
| 1534 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailEpsv) { | |
| 1535 // This test makes no sense for IPv4 connections (we don't use EPSV there). | |
| 1536 if (GetFamily() == AF_INET) | |
| 1537 return; | |
| 1538 | |
| 1539 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1540 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1541 // ERR_FTP_FAILED bucket. | |
| 1542 TransactionFailHelper( | |
| 1543 &ctrl_socket, "ftp://host/file", FtpSocketDataProvider::PRE_RETR_EPSV, | |
| 1544 FtpSocketDataProvider::PRE_NOPASV, "599 fail\r\n", ERR_FTP_FAILED); | |
| 1545 } | |
| 1546 | |
| 1547 TEST_P(FtpNetworkTransactionTest, DownloadTransactionFailRetr) { | |
| 1548 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1549 // Use unallocated 599 FTP error code to make sure it falls into the generic | |
| 1550 // ERR_FTP_FAILED bucket. | |
| 1551 TransactionFailHelper(&ctrl_socket, | |
| 1552 "ftp://host/file", | |
| 1553 FtpSocketDataProvider::PRE_RETR, | |
| 1554 FtpSocketDataProvider::PRE_QUIT, | |
| 1555 "599 fail\r\n", | |
| 1556 ERR_FTP_FAILED); | |
| 1557 } | |
| 1558 | |
| 1559 TEST_P(FtpNetworkTransactionTest, FileNotFound) { | |
| 1560 FtpSocketDataProviderFileNotFound ctrl_socket; | |
| 1561 ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_FTP_FAILED); | |
| 1562 } | |
| 1563 | |
| 1564 // Test for http://crbug.com/38845. | |
| 1565 TEST_P(FtpNetworkTransactionTest, ZeroLengthDirInPWD) { | |
| 1566 FtpSocketDataProviderFileDownload ctrl_socket; | |
| 1567 TransactionFailHelper(&ctrl_socket, | |
| 1568 "ftp://host/file", | |
| 1569 FtpSocketDataProvider::PRE_PWD, | |
| 1570 FtpSocketDataProvider::PRE_TYPE, | |
| 1571 "257 \"\"\r\n", | |
| 1572 OK); | |
| 1573 } | |
| 1574 | |
| 1575 INSTANTIATE_TEST_CASE_P(FTP, | |
| 1576 FtpNetworkTransactionTest, | |
| 1577 ::testing::Values(AF_INET, AF_INET6)); | |
| 1578 | |
| 1579 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master