| Index: net/ftp/ftp_network_transaction_unittest.cc
|
| diff --git a/net/ftp/ftp_network_transaction_unittest.cc b/net/ftp/ftp_network_transaction_unittest.cc
|
| index 537ce147e5246c424394588090bbffc252a38d5d..13d744d412fd5d1191107f9dfcba9317e31c24d6 100644
|
| --- a/net/ftp/ftp_network_transaction_unittest.cc
|
| +++ b/net/ftp/ftp_network_transaction_unittest.cc
|
| @@ -68,47 +68,62 @@ class FtpSocketDataProvider : public DynamicSocketDataProvider {
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_USER:
|
| - return Verify("USER anonymous\r\n", data, PRE_PASSWD,
|
| - "331 Password needed\r\n");
|
| - case PRE_PASSWD:
|
| - {
|
| - const char* response_one = "230 Welcome\r\n";
|
| - const char* response_multi = "230- One\r\n230- Two\r\n230 Three\r\n";
|
| - return Verify("PASS chrome@example.com\r\n", data, PRE_SYST,
|
| - multiline_welcome_ ? response_multi : response_one);
|
| - }
|
| + return Verify(
|
| + "USER anonymous\r\n", data, PRE_PASSWD, "331 Password needed\r\n");
|
| + case PRE_PASSWD: {
|
| + const char* response_one = "230 Welcome\r\n";
|
| + const char* response_multi = "230- One\r\n230- Two\r\n230 Three\r\n";
|
| + return Verify("PASS chrome@example.com\r\n",
|
| + data,
|
| + PRE_SYST,
|
| + multiline_welcome_ ? response_multi : response_one);
|
| + }
|
| case PRE_SYST:
|
| return Verify("SYST\r\n", data, PRE_PWD, "215 UNIX\r\n");
|
| case PRE_PWD:
|
| - return Verify("PWD\r\n", data, PRE_TYPE,
|
| + return Verify("PWD\r\n",
|
| + data,
|
| + PRE_TYPE,
|
| "257 \"/\" is your current location\r\n");
|
| case PRE_TYPE:
|
| - return Verify(std::string("TYPE ") + data_type_ + "\r\n", data,
|
| + return Verify(std::string("TYPE ") + data_type_ + "\r\n",
|
| + data,
|
| use_epsv_ ? PRE_EPSV : PRE_PASV,
|
| "200 TYPE set successfully\r\n");
|
| case PRE_EPSV:
|
| - return Verify("EPSV\r\n", data, PRE_SIZE,
|
| + return Verify("EPSV\r\n",
|
| + data,
|
| + PRE_SIZE,
|
| "227 Entering Extended Passive Mode (|||31744|)\r\n");
|
| case PRE_CWD_EPSV:
|
| - return Verify("EPSV\r\n", data, PRE_CWD,
|
| + return Verify("EPSV\r\n",
|
| + data,
|
| + PRE_CWD,
|
| "227 Entering Extended Passive Mode (|||31744|)\r\n");
|
| case PRE_RETR_EPSV:
|
| - return Verify("EPSV\r\n", data, PRE_RETR,
|
| + return Verify("EPSV\r\n",
|
| + data,
|
| + PRE_RETR,
|
| "227 Entering Extended Passive Mode (|||31744|)\r\n");
|
| case PRE_CWD_PASV:
|
| - return Verify("PASV\r\n", data, PRE_CWD,
|
| + return Verify("PASV\r\n",
|
| + data,
|
| + PRE_CWD,
|
| "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
|
| case PRE_RETR_PASV:
|
| - return Verify("PASV\r\n", data, PRE_RETR,
|
| + return Verify("PASV\r\n",
|
| + data,
|
| + PRE_RETR,
|
| "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
|
| case PRE_PASV:
|
| - return Verify("PASV\r\n", data, PRE_SIZE,
|
| + return Verify("PASV\r\n",
|
| + data,
|
| + PRE_SIZE,
|
| "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
|
| case PRE_NOPASV:
|
| // Use unallocated 599 FTP error code to make sure it falls into the
|
| // generic ERR_FTP_FAILED bucket.
|
| - return Verify("PASV\r\n", data, PRE_QUIT,
|
| - "599 fail\r\n");
|
| + return Verify("PASV\r\n", data, PRE_QUIT, "599 fail\r\n");
|
| case PRE_QUIT:
|
| return Verify("QUIT\r\n", data, QUIT, "221 Goodbye.\r\n");
|
| default:
|
| @@ -127,9 +142,7 @@ class FtpSocketDataProvider : public DynamicSocketDataProvider {
|
| fault_response_ = response;
|
| }
|
|
|
| - State state() const {
|
| - return state_;
|
| - }
|
| + State state() const { return state_; }
|
|
|
| virtual void Reset() OVERRIDE {
|
| DynamicSocketDataProvider::Reset();
|
| @@ -177,11 +190,10 @@ class FtpSocketDataProvider : public DynamicSocketDataProvider {
|
| const std::string& data,
|
| State next_state,
|
| const char* next_read) {
|
| - return Verify(expected, data, next_state,
|
| - next_read, std::strlen(next_read));
|
| + return Verify(
|
| + expected, data, next_state, next_read, std::strlen(next_read));
|
| }
|
|
|
| -
|
| private:
|
| State state_;
|
| State failure_injection_state_;
|
| @@ -202,15 +214,15 @@ class FtpSocketDataProvider : public DynamicSocketDataProvider {
|
|
|
| class FtpSocketDataProviderDirectoryListing : public FtpSocketDataProvider {
|
| public:
|
| - FtpSocketDataProviderDirectoryListing() {
|
| - }
|
| + FtpSocketDataProviderDirectoryListing() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_SIZE:
|
| - return Verify("SIZE /\r\n", data,
|
| + return Verify("SIZE /\r\n",
|
| + data,
|
| use_epsv() ? PRE_CWD_EPSV : PRE_CWD_PASV,
|
| "550 I can only retrieve regular files\r\n");
|
| case PRE_CWD:
|
| @@ -229,18 +241,18 @@ class FtpSocketDataProviderDirectoryListing : public FtpSocketDataProvider {
|
| class FtpSocketDataProviderDirectoryListingWithPasvFallback
|
| : public FtpSocketDataProviderDirectoryListing {
|
| public:
|
| - FtpSocketDataProviderDirectoryListingWithPasvFallback() {
|
| - }
|
| + FtpSocketDataProviderDirectoryListingWithPasvFallback() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_EPSV:
|
| - return Verify("EPSV\r\n", data, PRE_PASV,
|
| - "500 no EPSV for you\r\n");
|
| + return Verify("EPSV\r\n", data, PRE_PASV, "500 no EPSV for you\r\n");
|
| case PRE_SIZE:
|
| - return Verify("SIZE /\r\n", data, PRE_CWD_PASV,
|
| + return Verify("SIZE /\r\n",
|
| + data,
|
| + PRE_CWD_PASV,
|
| "550 I can only retrieve regular files\r\n");
|
| default:
|
| return FtpSocketDataProviderDirectoryListing::OnWrite(data);
|
| @@ -255,8 +267,7 @@ class FtpSocketDataProviderDirectoryListingWithPasvFallback
|
| class FtpSocketDataProviderDirectoryListingZeroSize
|
| : public FtpSocketDataProviderDirectoryListing {
|
| public:
|
| - FtpSocketDataProviderDirectoryListingZeroSize() {
|
| - }
|
| + FtpSocketDataProviderDirectoryListingZeroSize() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| @@ -275,8 +286,7 @@ class FtpSocketDataProviderDirectoryListingZeroSize
|
|
|
| class FtpSocketDataProviderVMSDirectoryListing : public FtpSocketDataProvider {
|
| public:
|
| - FtpSocketDataProviderVMSDirectoryListing() {
|
| - }
|
| + FtpSocketDataProviderVMSDirectoryListing() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| @@ -285,16 +295,18 @@ class FtpSocketDataProviderVMSDirectoryListing : public FtpSocketDataProvider {
|
| case PRE_SYST:
|
| return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n");
|
| case PRE_PWD:
|
| - return Verify("PWD\r\n", data, PRE_TYPE,
|
| - "257 \"ANONYMOUS_ROOT:[000000]\"\r\n");
|
| + return Verify(
|
| + "PWD\r\n", data, PRE_TYPE, "257 \"ANONYMOUS_ROOT:[000000]\"\r\n");
|
| case PRE_EPSV:
|
| return Verify("EPSV\r\n", data, PRE_PASV, "500 Invalid command\r\n");
|
| case PRE_SIZE:
|
| - return Verify("SIZE ANONYMOUS_ROOT:[000000]dir\r\n", data, PRE_CWD_PASV,
|
| + return Verify("SIZE ANONYMOUS_ROOT:[000000]dir\r\n",
|
| + data,
|
| + PRE_CWD_PASV,
|
| "550 I can only retrieve regular files\r\n");
|
| case PRE_CWD:
|
| - return Verify("CWD ANONYMOUS_ROOT:[dir]\r\n", data, PRE_LIST,
|
| - "200 OK\r\n");
|
| + return Verify(
|
| + "CWD ANONYMOUS_ROOT:[dir]\r\n", data, PRE_LIST, "200 OK\r\n");
|
| case PRE_LIST:
|
| return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n");
|
| default:
|
| @@ -309,8 +321,7 @@ class FtpSocketDataProviderVMSDirectoryListing : public FtpSocketDataProvider {
|
| class FtpSocketDataProviderVMSDirectoryListingRootDirectory
|
| : public FtpSocketDataProvider {
|
| public:
|
| - FtpSocketDataProviderVMSDirectoryListingRootDirectory() {
|
| - }
|
| + FtpSocketDataProviderVMSDirectoryListingRootDirectory() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| @@ -319,17 +330,19 @@ class FtpSocketDataProviderVMSDirectoryListingRootDirectory
|
| case PRE_SYST:
|
| return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n");
|
| case PRE_PWD:
|
| - return Verify("PWD\r\n", data, PRE_TYPE,
|
| - "257 \"ANONYMOUS_ROOT:[000000]\"\r\n");
|
| + return Verify(
|
| + "PWD\r\n", data, PRE_TYPE, "257 \"ANONYMOUS_ROOT:[000000]\"\r\n");
|
| case PRE_EPSV:
|
| - return Verify("EPSV\r\n", data, PRE_PASV,
|
| - "500 EPSV command unknown\r\n");
|
| + return Verify(
|
| + "EPSV\r\n", data, PRE_PASV, "500 EPSV command unknown\r\n");
|
| case PRE_SIZE:
|
| - return Verify("SIZE ANONYMOUS_ROOT\r\n", data, PRE_CWD_PASV,
|
| + return Verify("SIZE ANONYMOUS_ROOT\r\n",
|
| + data,
|
| + PRE_CWD_PASV,
|
| "550 I can only retrieve regular files\r\n");
|
| case PRE_CWD:
|
| - return Verify("CWD ANONYMOUS_ROOT:[000000]\r\n", data, PRE_LIST,
|
| - "200 OK\r\n");
|
| + return Verify(
|
| + "CWD ANONYMOUS_ROOT:[000000]\r\n", data, PRE_LIST, "200 OK\r\n");
|
| case PRE_LIST:
|
| return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n");
|
| default:
|
| @@ -345,16 +358,14 @@ class FtpSocketDataProviderVMSDirectoryListingRootDirectory
|
| class FtpSocketDataProviderFileDownloadWithFileTypecode
|
| : public FtpSocketDataProvider {
|
| public:
|
| - FtpSocketDataProviderFileDownloadWithFileTypecode() {
|
| - }
|
| + FtpSocketDataProviderFileDownloadWithFileTypecode() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_SIZE:
|
| - return Verify("SIZE /file\r\n", data, PRE_RETR,
|
| - "213 18\r\n");
|
| + return Verify("SIZE /file\r\n", data, PRE_RETR, "213 18\r\n");
|
| case PRE_RETR:
|
| return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n");
|
| default:
|
| @@ -368,18 +379,17 @@ class FtpSocketDataProviderFileDownloadWithFileTypecode
|
|
|
| class FtpSocketDataProviderFileDownload : public FtpSocketDataProvider {
|
| public:
|
| - FtpSocketDataProviderFileDownload() {
|
| - }
|
| + FtpSocketDataProviderFileDownload() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_SIZE:
|
| - return Verify("SIZE /file\r\n", data, PRE_CWD,
|
| - "213 18\r\n");
|
| + return Verify("SIZE /file\r\n", data, PRE_CWD, "213 18\r\n");
|
| case PRE_CWD:
|
| - return Verify("CWD /file\r\n", data,
|
| + return Verify("CWD /file\r\n",
|
| + data,
|
| use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV,
|
| "550 Not a directory\r\n");
|
| case PRE_RETR:
|
| @@ -395,24 +405,25 @@ class FtpSocketDataProviderFileDownload : public FtpSocketDataProvider {
|
|
|
| class FtpSocketDataProviderFileNotFound : public FtpSocketDataProvider {
|
| public:
|
| - FtpSocketDataProviderFileNotFound() {
|
| - }
|
| + FtpSocketDataProviderFileNotFound() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_SIZE:
|
| - return Verify("SIZE /file\r\n", data,
|
| + return Verify("SIZE /file\r\n",
|
| + data,
|
| use_epsv() ? PRE_CWD_EPSV : PRE_CWD_PASV,
|
| "550 File Not Found\r\n");
|
| case PRE_CWD:
|
| - return Verify("CWD /file\r\n", data,
|
| + return Verify("CWD /file\r\n",
|
| + data,
|
| use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV,
|
| "550 File Not Found\r\n");
|
| case PRE_RETR:
|
| - return Verify("RETR /file\r\n", data, PRE_QUIT,
|
| - "550 File Not Found\r\n");
|
| + return Verify(
|
| + "RETR /file\r\n", data, PRE_QUIT, "550 File Not Found\r\n");
|
| default:
|
| return FtpSocketDataProvider::OnWrite(data);
|
| }
|
| @@ -425,19 +436,17 @@ class FtpSocketDataProviderFileNotFound : public FtpSocketDataProvider {
|
| class FtpSocketDataProviderFileDownloadWithPasvFallback
|
| : public FtpSocketDataProviderFileDownload {
|
| public:
|
| - FtpSocketDataProviderFileDownloadWithPasvFallback() {
|
| - }
|
| + FtpSocketDataProviderFileDownloadWithPasvFallback() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_EPSV:
|
| - return Verify("EPSV\r\n", data, PRE_PASV,
|
| - "500 No can do\r\n");
|
| + return Verify("EPSV\r\n", data, PRE_PASV, "500 No can do\r\n");
|
| case PRE_CWD:
|
| - return Verify("CWD /file\r\n", data, PRE_RETR_PASV,
|
| - "550 Not a directory\r\n");
|
| + return Verify(
|
| + "CWD /file\r\n", data, PRE_RETR_PASV, "550 Not a directory\r\n");
|
| default:
|
| return FtpSocketDataProviderFileDownload::OnWrite(data);
|
| }
|
| @@ -450,18 +459,17 @@ class FtpSocketDataProviderFileDownloadWithPasvFallback
|
| class FtpSocketDataProviderFileDownloadZeroSize
|
| : public FtpSocketDataProviderFileDownload {
|
| public:
|
| - FtpSocketDataProviderFileDownloadZeroSize() {
|
| - }
|
| + FtpSocketDataProviderFileDownloadZeroSize() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_SIZE:
|
| - return Verify("SIZE /file\r\n", data, PRE_CWD,
|
| - "213 0\r\n");
|
| + return Verify("SIZE /file\r\n", data, PRE_CWD, "213 0\r\n");
|
| case PRE_CWD:
|
| - return Verify("CWD /file\r\n", data,
|
| + return Verify("CWD /file\r\n",
|
| + data,
|
| use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV,
|
| "550 not a directory\r\n");
|
| default:
|
| @@ -476,15 +484,15 @@ class FtpSocketDataProviderFileDownloadZeroSize
|
| class FtpSocketDataProviderFileDownloadCWD451
|
| : public FtpSocketDataProviderFileDownload {
|
| public:
|
| - FtpSocketDataProviderFileDownloadCWD451() {
|
| - }
|
| + FtpSocketDataProviderFileDownloadCWD451() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_CWD:
|
| - return Verify("CWD /file\r\n", data,
|
| + return Verify("CWD /file\r\n",
|
| + data,
|
| use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV,
|
| "451 not a directory\r\n");
|
| default:
|
| @@ -498,8 +506,7 @@ class FtpSocketDataProviderFileDownloadCWD451
|
|
|
| class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider {
|
| public:
|
| - FtpSocketDataProviderVMSFileDownload() {
|
| - }
|
| + FtpSocketDataProviderVMSFileDownload() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| @@ -508,19 +515,25 @@ class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider {
|
| case PRE_SYST:
|
| return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n");
|
| case PRE_PWD:
|
| - return Verify("PWD\r\n", data, PRE_TYPE,
|
| - "257 \"ANONYMOUS_ROOT:[000000]\"\r\n");
|
| + return Verify(
|
| + "PWD\r\n", data, PRE_TYPE, "257 \"ANONYMOUS_ROOT:[000000]\"\r\n");
|
| case PRE_EPSV:
|
| - return Verify("EPSV\r\n", data, PRE_PASV,
|
| - "500 EPSV command unknown\r\n");
|
| + return Verify(
|
| + "EPSV\r\n", data, PRE_PASV, "500 EPSV command unknown\r\n");
|
| case PRE_SIZE:
|
| - return Verify("SIZE ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_CWD,
|
| + return Verify("SIZE ANONYMOUS_ROOT:[000000]file\r\n",
|
| + data,
|
| + PRE_CWD,
|
| "213 18\r\n");
|
| case PRE_CWD:
|
| - return Verify("CWD ANONYMOUS_ROOT:[file]\r\n", data, PRE_RETR_PASV,
|
| + return Verify("CWD ANONYMOUS_ROOT:[file]\r\n",
|
| + data,
|
| + PRE_RETR_PASV,
|
| "550 Not a directory\r\n");
|
| case PRE_RETR:
|
| - return Verify("RETR ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_QUIT,
|
| + return Verify("RETR ANONYMOUS_ROOT:[000000]file\r\n",
|
| + data,
|
| + PRE_QUIT,
|
| "200 OK\r\n");
|
| default:
|
| return FtpSocketDataProvider::OnWrite(data);
|
| @@ -533,23 +546,23 @@ class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider {
|
|
|
| class FtpSocketDataProviderEscaping : public FtpSocketDataProviderFileDownload {
|
| public:
|
| - FtpSocketDataProviderEscaping() {
|
| - }
|
| + FtpSocketDataProviderEscaping() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_SIZE:
|
| - return Verify("SIZE / !\"#$%y\200\201\r\n", data, PRE_CWD,
|
| - "213 18\r\n");
|
| + return Verify(
|
| + "SIZE / !\"#$%y\200\201\r\n", data, PRE_CWD, "213 18\r\n");
|
| case PRE_CWD:
|
| - return Verify("CWD / !\"#$%y\200\201\r\n", data,
|
| + return Verify("CWD / !\"#$%y\200\201\r\n",
|
| + data,
|
| use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV,
|
| "550 Not a directory\r\n");
|
| case PRE_RETR:
|
| - return Verify("RETR / !\"#$%y\200\201\r\n", data, PRE_QUIT,
|
| - "200 OK\r\n");
|
| + return Verify(
|
| + "RETR / !\"#$%y\200\201\r\n", data, PRE_QUIT, "200 OK\r\n");
|
| default:
|
| return FtpSocketDataProviderFileDownload::OnWrite(data);
|
| }
|
| @@ -562,15 +575,16 @@ class FtpSocketDataProviderEscaping : public FtpSocketDataProviderFileDownload {
|
| class FtpSocketDataProviderFileDownloadTransferStarting
|
| : public FtpSocketDataProviderFileDownload {
|
| public:
|
| - FtpSocketDataProviderFileDownloadTransferStarting() {
|
| - }
|
| + FtpSocketDataProviderFileDownloadTransferStarting() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_RETR:
|
| - return Verify("RETR /file\r\n", data, PRE_QUIT,
|
| + return Verify("RETR /file\r\n",
|
| + data,
|
| + PRE_QUIT,
|
| "125-Data connection already open.\r\n"
|
| "125 Transfer starting.\r\n"
|
| "226 Transfer complete.\r\n");
|
| @@ -586,15 +600,16 @@ class FtpSocketDataProviderFileDownloadTransferStarting
|
| class FtpSocketDataProviderDirectoryListingTransferStarting
|
| : public FtpSocketDataProviderDirectoryListing {
|
| public:
|
| - FtpSocketDataProviderDirectoryListingTransferStarting() {
|
| - }
|
| + FtpSocketDataProviderDirectoryListingTransferStarting() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_LIST:
|
| - return Verify("LIST -l\r\n", data, PRE_QUIT,
|
| + return Verify("LIST -l\r\n",
|
| + data,
|
| + PRE_QUIT,
|
| "125-Data connection already open.\r\n"
|
| "125 Transfer starting.\r\n"
|
| "226 Transfer complete.\r\n");
|
| @@ -611,8 +626,7 @@ class FtpSocketDataProviderDirectoryListingTransferStarting
|
| class FtpSocketDataProviderFileDownloadInvalidResponse
|
| : public FtpSocketDataProviderFileDownload {
|
| public:
|
| - FtpSocketDataProviderFileDownloadInvalidResponse() {
|
| - }
|
| + FtpSocketDataProviderFileDownloadInvalidResponse() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| @@ -621,7 +635,9 @@ class FtpSocketDataProviderFileDownloadInvalidResponse
|
| case PRE_SIZE:
|
| // Use unallocated 599 FTP error code to make sure it falls into the
|
| // generic ERR_FTP_FAILED bucket.
|
| - return Verify("SIZE /file\r\n", data, PRE_QUIT,
|
| + return Verify("SIZE /file\r\n",
|
| + data,
|
| + PRE_QUIT,
|
| "599 Evil Response\r\n"
|
| "599 More Evil\r\n");
|
| default:
|
| @@ -635,15 +651,14 @@ class FtpSocketDataProviderFileDownloadInvalidResponse
|
|
|
| class FtpSocketDataProviderEvilEpsv : public FtpSocketDataProviderFileDownload {
|
| public:
|
| - FtpSocketDataProviderEvilEpsv(const char* epsv_response,
|
| - State expected_state)
|
| + FtpSocketDataProviderEvilEpsv(const char* epsv_response, State expected_state)
|
| : epsv_response_(epsv_response),
|
| epsv_response_length_(std::strlen(epsv_response)),
|
| expected_state_(expected_state) {}
|
|
|
| FtpSocketDataProviderEvilEpsv(const char* epsv_response,
|
| - size_t epsv_response_length,
|
| - State expected_state)
|
| + size_t epsv_response_length,
|
| + State expected_state)
|
| : epsv_response_(epsv_response),
|
| epsv_response_length_(epsv_response_length),
|
| expected_state_(expected_state) {}
|
| @@ -653,8 +668,11 @@ class FtpSocketDataProviderEvilEpsv : public FtpSocketDataProviderFileDownload {
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_EPSV:
|
| - return Verify("EPSV\r\n", data, expected_state_,
|
| - epsv_response_, epsv_response_length_);
|
| + return Verify("EPSV\r\n",
|
| + data,
|
| + expected_state_,
|
| + epsv_response_,
|
| + epsv_response_length_);
|
| default:
|
| return FtpSocketDataProviderFileDownload::OnWrite(data);
|
| }
|
| @@ -672,9 +690,7 @@ class FtpSocketDataProviderEvilPasv
|
| : public FtpSocketDataProviderFileDownloadWithPasvFallback {
|
| public:
|
| FtpSocketDataProviderEvilPasv(const char* pasv_response, State expected_state)
|
| - : pasv_response_(pasv_response),
|
| - expected_state_(expected_state) {
|
| - }
|
| + : pasv_response_(pasv_response), expected_state_(expected_state) {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| @@ -697,9 +713,7 @@ class FtpSocketDataProviderEvilPasv
|
| class FtpSocketDataProviderEvilSize : public FtpSocketDataProviderFileDownload {
|
| public:
|
| FtpSocketDataProviderEvilSize(const char* size_response, State expected_state)
|
| - : size_response_(size_response),
|
| - expected_state_(expected_state) {
|
| - }
|
| + : size_response_(size_response), expected_state_(expected_state) {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| @@ -723,21 +737,23 @@ class FtpSocketDataProviderEvilLogin
|
| : public FtpSocketDataProviderFileDownload {
|
| public:
|
| FtpSocketDataProviderEvilLogin(const char* expected_user,
|
| - const char* expected_password)
|
| - : expected_user_(expected_user),
|
| - expected_password_(expected_password) {
|
| - }
|
| + const char* expected_password)
|
| + : expected_user_(expected_user), expected_password_(expected_password) {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_USER:
|
| - return Verify(std::string("USER ") + expected_user_ + "\r\n", data,
|
| - PRE_PASSWD, "331 Password needed\r\n");
|
| + return Verify(std::string("USER ") + expected_user_ + "\r\n",
|
| + data,
|
| + PRE_PASSWD,
|
| + "331 Password needed\r\n");
|
| case PRE_PASSWD:
|
| - return Verify(std::string("PASS ") + expected_password_ + "\r\n", data,
|
| - PRE_SYST, "230 Welcome\r\n");
|
| + return Verify(std::string("PASS ") + expected_password_ + "\r\n",
|
| + data,
|
| + PRE_SYST,
|
| + "230 Welcome\r\n");
|
| default:
|
| return FtpSocketDataProviderFileDownload::OnWrite(data);
|
| }
|
| @@ -752,16 +768,14 @@ class FtpSocketDataProviderEvilLogin
|
|
|
| class FtpSocketDataProviderCloseConnection : public FtpSocketDataProvider {
|
| public:
|
| - FtpSocketDataProviderCloseConnection() {
|
| - }
|
| + FtpSocketDataProviderCloseConnection() {}
|
|
|
| virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
|
| if (InjectFault())
|
| return MockWriteResult(ASYNC, data.length());
|
| switch (state()) {
|
| case PRE_USER:
|
| - return Verify("USER anonymous\r\n", data,
|
| - PRE_QUIT, "");
|
| + return Verify("USER anonymous\r\n", data, PRE_QUIT, "");
|
| default:
|
| return FtpSocketDataProvider::OnWrite(data);
|
| }
|
| @@ -771,9 +785,8 @@ class FtpSocketDataProviderCloseConnection : public FtpSocketDataProvider {
|
| DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderCloseConnection);
|
| };
|
|
|
| -class FtpNetworkTransactionTest
|
| - : public PlatformTest,
|
| - public ::testing::WithParamInterface<int> {
|
| +class FtpNetworkTransactionTest : public PlatformTest,
|
| + public ::testing::WithParamInterface<int> {
|
| public:
|
| FtpNetworkTransactionTest()
|
| : host_resolver_(new MockHostResolver),
|
| @@ -794,9 +807,7 @@ class FtpNetworkTransactionTest
|
| protected:
|
| // Accessor to make code refactoring-friendly, e.g. when we change the way
|
| // parameters are passed (like more parameters).
|
| - int GetFamily() {
|
| - return GetParam();
|
| - }
|
| + int GetFamily() { return GetParam(); }
|
|
|
| FtpRequestInfo GetRequestInfo(const std::string& url) {
|
| FtpRequestInfo info;
|
| @@ -815,10 +826,11 @@ class FtpNetworkTransactionTest
|
|
|
| std::string mock_data("mock-data");
|
| MockRead data_reads[] = {
|
| - // Usually FTP servers close the data connection after the entire data has
|
| - // been received.
|
| - MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
|
| - MockRead(mock_data.c_str()),
|
| + // Usually FTP servers close the data connection after the entire data
|
| + // has
|
| + // been received.
|
| + MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
|
| + MockRead(mock_data.c_str()),
|
| };
|
|
|
| ScopedVector<StaticSocketDataProvider> data_sockets;
|
| @@ -827,7 +839,7 @@ class FtpNetworkTransactionTest
|
| // We only read from one data socket, other ones are dummy.
|
| if (i == data_socket) {
|
| data_sockets.push_back(new StaticSocketDataProvider(
|
| - data_reads, arraysize(data_reads), NULL, 0));
|
| + data_reads, arraysize(data_reads), NULL, 0));
|
| } else {
|
| data_sockets.push_back(new StaticSocketDataProvider);
|
| }
|
| @@ -836,24 +848,24 @@ class FtpNetworkTransactionTest
|
|
|
| FtpRequestInfo request_info = GetRequestInfo(request);
|
| EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
|
| - ASSERT_EQ(ERR_IO_PENDING,
|
| - transaction_.Start(&request_info, callback_.callback(),
|
| - BoundNetLog()));
|
| + ASSERT_EQ(
|
| + ERR_IO_PENDING,
|
| + transaction_.Start(&request_info, callback_.callback(), BoundNetLog()));
|
| EXPECT_NE(LOAD_STATE_IDLE, transaction_.GetLoadState());
|
| ASSERT_EQ(expected_result, callback_.WaitForResult());
|
| if (expected_result == OK) {
|
| scoped_refptr<IOBuffer> io_buffer(new IOBuffer(kBufferSize));
|
| memset(io_buffer->data(), 0, kBufferSize);
|
| ASSERT_EQ(ERR_IO_PENDING,
|
| - transaction_.Read(io_buffer.get(), kBufferSize,
|
| - callback_.callback()));
|
| + transaction_.Read(
|
| + io_buffer.get(), kBufferSize, callback_.callback()));
|
| ASSERT_EQ(static_cast<int>(mock_data.length()),
|
| callback_.WaitForResult());
|
| EXPECT_EQ(mock_data, std::string(io_buffer->data(), mock_data.length()));
|
|
|
| // Do another Read to detect that the data socket is now closed.
|
| - int rv = transaction_.Read(io_buffer.get(), kBufferSize,
|
| - callback_.callback());
|
| + int rv =
|
| + transaction_.Read(io_buffer.get(), kBufferSize, callback_.callback());
|
| if (rv == ERR_IO_PENDING) {
|
| EXPECT_EQ(0, callback_.WaitForResult());
|
| } else {
|
| @@ -889,9 +901,9 @@ TEST_P(FtpNetworkTransactionTest, FailedLookup) {
|
| host_resolver_->set_rules(rules.get());
|
|
|
| EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
|
| - ASSERT_EQ(ERR_IO_PENDING,
|
| - transaction_.Start(&request_info, callback_.callback(),
|
| - BoundNetLog()));
|
| + ASSERT_EQ(
|
| + ERR_IO_PENDING,
|
| + transaction_.Start(&request_info, callback_.callback(), BoundNetLog()));
|
| ASSERT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
|
| EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
|
| }
|
| @@ -1109,20 +1121,20 @@ TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafeHost) {
|
| ctrl_socket.set_use_epsv(GetFamily() != AF_INET);
|
| std::string mock_data("mock-data");
|
| MockRead data_reads[] = {
|
| - MockRead(mock_data.c_str()),
|
| + MockRead(mock_data.c_str()),
|
| };
|
| StaticSocketDataProvider data_socket1;
|
| - StaticSocketDataProvider data_socket2(data_reads, arraysize(data_reads),
|
| - NULL, 0);
|
| + StaticSocketDataProvider data_socket2(
|
| + data_reads, arraysize(data_reads), NULL, 0);
|
| mock_socket_factory_.AddSocketDataProvider(&ctrl_socket);
|
| mock_socket_factory_.AddSocketDataProvider(&data_socket1);
|
| mock_socket_factory_.AddSocketDataProvider(&data_socket2);
|
| FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
|
|
|
| // Start the transaction.
|
| - ASSERT_EQ(ERR_IO_PENDING,
|
| - transaction_.Start(&request_info, callback_.callback(),
|
| - BoundNetLog()));
|
| + ASSERT_EQ(
|
| + ERR_IO_PENDING,
|
| + transaction_.Start(&request_info, callback_.callback(), BoundNetLog()));
|
| ASSERT_EQ(OK, callback_.WaitForResult());
|
|
|
| // The transaction fires the callback when we can start reading data. That
|
| @@ -1136,7 +1148,8 @@ TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafeHost) {
|
| // to the address we used for control connection (which could be 127.0.0.1
|
| // or ::1 depending on whether we use IPv6).
|
| for (AddressList::const_iterator it = data_socket->addresses().begin();
|
| - it != data_socket->addresses().end(); ++it) {
|
| + it != data_socket->addresses().end();
|
| + ++it) {
|
| EXPECT_NE("10.1.2.3", it->ToStringWithoutPort());
|
| }
|
| }
|
| @@ -1187,8 +1200,8 @@ TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat5) {
|
| return;
|
|
|
| const char response[] = "227 Portscan (\0\0\031773\0)\r\n";
|
| - FtpSocketDataProviderEvilEpsv ctrl_socket(response, sizeof(response)-1,
|
| - FtpSocketDataProvider::PRE_QUIT);
|
| + FtpSocketDataProviderEvilEpsv ctrl_socket(
|
| + response, sizeof(response) - 1, FtpSocketDataProvider::PRE_QUIT);
|
| ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE);
|
| }
|
|
|
| @@ -1292,27 +1305,25 @@ TEST_P(FtpNetworkTransactionTest, EvilRestartUser) {
|
|
|
| FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
|
|
|
| - ASSERT_EQ(ERR_IO_PENDING,
|
| - transaction_.Start(&request_info, callback_.callback(),
|
| - BoundNetLog()));
|
| + ASSERT_EQ(
|
| + ERR_IO_PENDING,
|
| + transaction_.Start(&request_info, callback_.callback(), BoundNetLog()));
|
| ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult());
|
|
|
| MockRead ctrl_reads[] = {
|
| - MockRead("220 host TestFTPd\r\n"),
|
| - MockRead("221 Goodbye!\r\n"),
|
| - MockRead(SYNCHRONOUS, OK),
|
| + MockRead("220 host TestFTPd\r\n"), MockRead("221 Goodbye!\r\n"),
|
| + MockRead(SYNCHRONOUS, OK),
|
| };
|
| MockWrite ctrl_writes[] = {
|
| - MockWrite("QUIT\r\n"),
|
| + MockWrite("QUIT\r\n"),
|
| };
|
| - StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads),
|
| - ctrl_writes, arraysize(ctrl_writes));
|
| + StaticSocketDataProvider ctrl_socket2(
|
| + ctrl_reads, arraysize(ctrl_reads), ctrl_writes, arraysize(ctrl_writes));
|
| mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2);
|
| ASSERT_EQ(ERR_IO_PENDING,
|
| transaction_.RestartWithAuth(
|
| - AuthCredentials(
|
| - base::ASCIIToUTF16("foo\nownz0red"),
|
| - base::ASCIIToUTF16("innocent")),
|
| + AuthCredentials(base::ASCIIToUTF16("foo\nownz0red"),
|
| + base::ASCIIToUTF16("innocent")),
|
| callback_.callback()));
|
| EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult());
|
| }
|
| @@ -1326,23 +1337,21 @@ TEST_P(FtpNetworkTransactionTest, EvilRestartPassword) {
|
|
|
| FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
|
|
|
| - ASSERT_EQ(ERR_IO_PENDING,
|
| - transaction_.Start(&request_info, callback_.callback(),
|
| - BoundNetLog()));
|
| + ASSERT_EQ(
|
| + ERR_IO_PENDING,
|
| + transaction_.Start(&request_info, callback_.callback(), BoundNetLog()));
|
| ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult());
|
|
|
| MockRead ctrl_reads[] = {
|
| - MockRead("220 host TestFTPd\r\n"),
|
| - MockRead("331 User okay, send password\r\n"),
|
| - MockRead("221 Goodbye!\r\n"),
|
| - MockRead(SYNCHRONOUS, OK),
|
| + MockRead("220 host TestFTPd\r\n"),
|
| + MockRead("331 User okay, send password\r\n"),
|
| + MockRead("221 Goodbye!\r\n"), MockRead(SYNCHRONOUS, OK),
|
| };
|
| MockWrite ctrl_writes[] = {
|
| - MockWrite("USER innocent\r\n"),
|
| - MockWrite("QUIT\r\n"),
|
| + MockWrite("USER innocent\r\n"), MockWrite("QUIT\r\n"),
|
| };
|
| - StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads),
|
| - ctrl_writes, arraysize(ctrl_writes));
|
| + StaticSocketDataProvider ctrl_socket2(
|
| + ctrl_reads, arraysize(ctrl_reads), ctrl_writes, arraysize(ctrl_writes));
|
| mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2);
|
| ASSERT_EQ(ERR_IO_PENDING,
|
| transaction_.RestartWithAuth(
|
| @@ -1354,8 +1363,8 @@ TEST_P(FtpNetworkTransactionTest, EvilRestartPassword) {
|
|
|
| TEST_P(FtpNetworkTransactionTest, Escaping) {
|
| FtpSocketDataProviderEscaping ctrl_socket;
|
| - ExecuteTransaction(&ctrl_socket, "ftp://host/%20%21%22%23%24%25%79%80%81",
|
| - 1, OK);
|
| + ExecuteTransaction(
|
| + &ctrl_socket, "ftp://host/%20%21%22%23%24%25%79%80%81", 1, OK);
|
| }
|
|
|
| // Test for http://crbug.com/23794.
|
| @@ -1370,9 +1379,8 @@ TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilSize) {
|
| // Test for http://crbug.com/36360.
|
| TEST_P(FtpNetworkTransactionTest, DownloadTransactionBigSize) {
|
| // Pass a valid, but large file size. The transaction should not fail.
|
| - FtpSocketDataProviderEvilSize ctrl_socket(
|
| - "213 3204427776\r\n",
|
| - FtpSocketDataProvider::PRE_CWD);
|
| + FtpSocketDataProviderEvilSize ctrl_socket("213 3204427776\r\n",
|
| + FtpSocketDataProvider::PRE_CWD);
|
| ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK);
|
| EXPECT_EQ(3204427776LL,
|
| transaction_.GetResponseInfo()->expected_content_size);
|
|
|
Chromium Code Reviews
