FTP: change order of commands to improve compatibility

net/ftp/ftp_network_transaction_unittest.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/ftp/ftp_network_transaction.h"
 
 #include "build/build_config.h"
 
 #include "base/ref_counted.h"
 #include "net/base/io_buffer.h"
@@ skipping 21 matching lines @@
   enum State {
     NONE,
     PRE_USER,
     PRE_PASSWD,
     PRE_SYST,
     PRE_PWD,
     PRE_TYPE,
     PRE_EPSV,
     PRE_PASV,
     PRE_SIZE,
-    PRE_MDTM,
     PRE_MLSD,
     PRE_LIST,
     PRE_RETR,
-    PRE_EPSV2,
-    PRE_PASV2,
     PRE_CWD,
     PRE_QUIT,
     PRE_NOPASV,
     QUIT
   };
 
   FtpSocketDataProvider()
       : failure_injection_state_(NONE),
         multiline_welcome_(false),
         data_type_('I') {
@@ skipping 18 matching lines @@
         return Verify("SYST\r\n", data, PRE_PWD, "215 UNIX\r\n");
       case PRE_PWD:
         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,
                       PRE_EPSV, "200 TYPE set successfully\r\n");
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, PRE_SIZE,
                       "227 Entering Extended Passive Mode (|||31744|)\r\n");
-      case PRE_EPSV2:
-        return Verify("EPSV\r\n", data, PRE_CWD,
-                      "227 Entering Extended Passive Mode (|||31744|)\r\n");
-      case PRE_PASV:
-        return Verify("PASV\r\n", data, PRE_SIZE,
-                      "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
-      case PRE_PASV2:
-        // Parser should also accept format without parentheses.
-        return Verify("PASV\r\n", data, PRE_CWD,
-                      "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
       case PRE_NOPASV:
         return Verify("PASV\r\n", data, PRE_QUIT,
                       "500 not going to happen\r\n");
       case PRE_QUIT:
         return Verify("QUIT\r\n", data, QUIT, "221 Goodbye.\r\n");
       default:
         NOTREACHED() << "State not handled " << state();
         return MockWriteResult(true, ERR_UNEXPECTED);
     }
   }
@@ skipping 82 matching lines @@
 class FtpSocketDataProviderDirectoryListing : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderDirectoryListing() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) {
     if (InjectFault())
       return MockWriteResult(true, data.length());
     switch (state()) {
       case PRE_SIZE:
-        return Verify("SIZE /\r\n", data, PRE_MDTM,
+        return Verify("SIZE /\r\n", data, PRE_CWD,
                       "550 I can only retrieve regular files\r\n");
-      case PRE_MDTM:
-        return Verify("MDTM /\r\n", data, PRE_RETR,
-                      "213 20070221112533\r\n");
-      case PRE_RETR:
-        return Verify("RETR /\r\n", data, PRE_EPSV2,
-                      "550 Can't download directory\r\n");
       case PRE_CWD:
         return Verify("CWD /\r\n", data, PRE_MLSD, "200 OK\r\n");
       case PRE_MLSD:
         return Verify("MLSD\r\n", data, PRE_QUIT,
                       "150 Accepted data connection\r\n"
                       "226 MLSD complete\r\n");
       case PRE_LIST:
         return Verify("LIST\r\n", data, PRE_QUIT, "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
@@ skipping 10 matching lines @@
   FtpSocketDataProviderDirectoryListingWithPasvFallback() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) {
     if (InjectFault())
       return MockWriteResult(true, data.length());
     switch (state()) {
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, PRE_PASV,
                       "500 no EPSV for you\r\n");
-      case PRE_RETR:
-        return Verify("RETR /\r\n", data, PRE_PASV2,
-                      "550 Can't download directory\r\n");
+      case PRE_PASV:
+        return Verify("PASV\r\n", data, PRE_SIZE,
+                      "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
       default:
         return FtpSocketDataProviderDirectoryListing::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       FtpSocketDataProviderDirectoryListingWithPasvFallback);
 };
 
-class FtpSocketDataProviderDirectoryListingWithTypecode
-    : public FtpSocketDataProvider {
- public:
-  FtpSocketDataProviderDirectoryListingWithTypecode() {
-  }
-
-  virtual MockWriteResult OnWrite(const std::string& data) {
-    if (InjectFault())
-      return MockWriteResult(true, data.length());
-    switch (state()) {
-      case PRE_EPSV:
-        return Verify("EPSV\r\n", data, PRE_CWD,
-                      "227 Entering Passive Mode (|||31744|)\r\n");
-      case PRE_CWD:
-        return Verify("CWD /\r\n", data, PRE_MLSD, "200 OK\r\n");
-      case PRE_MLSD:
-        return Verify("MLSD\r\n", data, PRE_QUIT,
-                      "150 Accepted data connection\r\n"
-                      "226 MLSD complete\r\n");
-      case PRE_LIST:
-        return Verify("LIST\r\n", data, PRE_QUIT, "200 OK\r\n");
-      default:
-        return FtpSocketDataProvider::OnWrite(data);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListingWithTypecode);
-};
-
 class FtpSocketDataProviderVMSDirectoryListing : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderVMSDirectoryListing() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) {
     if (InjectFault())
       return MockWriteResult(true, data.length());
     switch (state()) {
       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");
+      case PRE_EPSV:
+        return Verify("EPSV\r\n", data, PRE_PASV, "500 Invalid command\r\n");
+      case PRE_PASV:
+        return Verify("PASV\r\n", data, PRE_SIZE,
+                      "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
       case PRE_SIZE:
-        return Verify("SIZE ANONYMOUS_ROOT:[000000]dir\r\n", data, PRE_MDTM,
+        return Verify("SIZE ANONYMOUS_ROOT:[000000]dir\r\n", data, PRE_CWD,
                       "550 I can only retrieve regular files\r\n");
-      case PRE_MDTM:
-        return Verify("MDTM ANONYMOUS_ROOT:[000000]dir\r\n", data, PRE_RETR,
-                      "213 20070221112533\r\n");
-      case PRE_RETR:
-        return Verify("RETR ANONYMOUS_ROOT:[000000]dir\r\n", data, PRE_EPSV2,
-                      "550 Can't download directory\r\n");
       case PRE_CWD:
         return Verify("CWD ANONYMOUS_ROOT:[dir]\r\n", data, PRE_MLSD,
                       "200 OK\r\n");
       case PRE_MLSD:
         return Verify("MLSD\r\n", data, PRE_LIST, "500 Invalid command\r\n");
       case PRE_LIST:
         return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
@@ skipping 14 matching lines @@
       return MockWriteResult(true, data.length());
     switch (state()) {
       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");
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, PRE_PASV,
                       "500 EPSV command unknown\r\n");
+      case PRE_PASV:
+        return Verify("PASV\r\n", data, PRE_SIZE,
+                      "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
       case PRE_SIZE:
-        return Verify("SIZE ANONYMOUS_ROOT\r\n", data, PRE_MDTM,
+        return Verify("SIZE ANONYMOUS_ROOT\r\n", data, PRE_CWD,
                       "550 I can only retrieve regular files\r\n");
-      case PRE_MDTM:
-        return Verify("MDTM ANONYMOUS_ROOT\r\n", data, PRE_RETR,
-                      "213 20070221112533\r\n");
-      case PRE_RETR:
-        return Verify("RETR ANONYMOUS_ROOT\r\n", data, PRE_PASV2,
-                      "550 Can't download directory\r\n");
       case PRE_CWD:
         return Verify("CWD ANONYMOUS_ROOT:[000000]\r\n", data, PRE_MLSD,
                       "200 OK\r\n");
       case PRE_MLSD:
         return Verify("MLSD\r\n", data, PRE_LIST, "500 Invalid command\r\n");
       case PRE_LIST:
         return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       FtpSocketDataProviderVMSDirectoryListingRootDirectory);
 };
 
 class FtpSocketDataProviderFileDownload : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderFileDownload() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) {
     if (InjectFault())
       return MockWriteResult(true, data.length());
     switch (state()) {
       case PRE_SIZE:
-        return Verify("SIZE /file\r\n", data, PRE_MDTM,
+        return Verify("SIZE /file\r\n", data, PRE_RETR,
                       "213 18\r\n");
-      case PRE_MDTM:
-        return Verify("MDTM /file\r\n", data, PRE_RETR,
-                      "213 20070221112533\r\n");
       case PRE_RETR:
         return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownload);
 };
 
 class FtpSocketDataProviderFileDownloadWithPasvFallback
     : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderFileDownloadWithPasvFallback() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) {
     if (InjectFault())
       return MockWriteResult(true, data.length());
     switch (state()) {
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, PRE_PASV,
                       "500 No can do\r\n");
+      case PRE_PASV:
+        return Verify("PASV\r\n", data, PRE_SIZE,
+                      "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithPasvFallback);
 };
 
 class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderVMSFileDownload() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) {
     if (InjectFault())
       return MockWriteResult(true, data.length());
     switch (state()) {
       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");
+      case PRE_EPSV:
+        return Verify("EPSV\r\n", data, PRE_PASV,
+                      "500 EPSV command unknown\r\n");
+      case PRE_PASV:
+        return Verify("PASV\r\n", data, PRE_SIZE,
+                      "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
       case PRE_SIZE:
-        return Verify("SIZE ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_MDTM,
+        return Verify("SIZE ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_RETR,
                       "213 18\r\n");
-      case PRE_MDTM:
-        return Verify("MDTM ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_RETR,
-                      "213 20070221112533\r\n");
       case PRE_RETR:
         return Verify("RETR ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_QUIT,
                       "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderVMSFileDownload);
 };
 
-class FtpSocketDataProviderEscaping : public FtpSocketDataProvider {
+class FtpSocketDataProviderEscaping : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderEscaping() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) {
     if (InjectFault())
       return MockWriteResult(true, data.length());
     switch (state()) {
       case PRE_SIZE:
-        return Verify("SIZE / !\"#$%y\200\201\r\n", data, PRE_MDTM,
+        return Verify("SIZE / !\"#$%y\200\201\r\n", data, PRE_RETR,
                       "213 18\r\n");
-      case PRE_MDTM:
-        return Verify("MDTM / !\"#$%y\200\201\r\n", data, PRE_RETR,
-                      "213 20070221112533\r\n");
       case PRE_RETR:
         return Verify("RETR / !\"#$%y\200\201\r\n", data, PRE_QUIT,
                       "200 OK\r\n");
       default:
-        return FtpSocketDataProvider::OnWrite(data);
+        return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEscaping);
 };
 
 class FtpSocketDataProviderFileDownloadTransferStarting
     : public FtpSocketDataProviderFileDownload {
  public:
@@ skipping 59 matching lines @@
                       "500 More Evil\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadInvalidResponse);
 };
 
-class FtpSocketDataProviderFileDownloadRetrFail
-    : public FtpSocketDataProviderFileDownload {
- public:
-  FtpSocketDataProviderFileDownloadRetrFail() {
-  }
-
-  virtual MockWriteResult OnWrite(const std::string& data) {
-    if (InjectFault())
-      return MockWriteResult(true, data.length());
-    switch (state()) {
-      case PRE_CWD:
-        return Verify("CWD /file\r\n", data, PRE_QUIT,
-                      "550 file is a directory\r\n");
-      default:
-        return FtpSocketDataProviderFileDownload::OnWrite(data);
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadRetrFail);
-};
-
 class FtpSocketDataProviderEvilEpsv : public FtpSocketDataProviderFileDownload {
  public:
   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,
@@ skipping 237 matching lines @@
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionWithPasvFallback) {
   FtpSocketDataProviderDirectoryListingWithPasvFallback ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host", OK);
 
   EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing);
   EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionWithTypecode) {
-  FtpSocketDataProviderDirectoryListingWithTypecode ctrl_socket;
+  FtpSocketDataProviderDirectoryListing ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host;type=d", OK);
 
   EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing);
   EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionMultilineWelcome) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
   ctrl_socket.set_multiline_welcome(true);
   ExecuteTransaction(&ctrl_socket, "ftp://host", OK);
@@ skipping 339 matching lines @@
       "213 99999999999999999999999999999999\r\n",
       FtpSocketDataProvider::PRE_QUIT);
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE);
 }
 
 // Test for http://crbug.com/36360.
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionBigSize) {
   // Pass a valid, but large file size. The transaction should not fail.
   FtpSocketDataProviderEvilSize ctrl_socket(
       "213 3204427776\r\n",
-      FtpSocketDataProvider::PRE_MDTM);
+      FtpSocketDataProvider::PRE_RETR);
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK);
   EXPECT_EQ(3204427776LL,
             transaction_.GetResponseInfo()->expected_content_size);
 }
 
 // Regression test for http://crbug.com/25023.
 TEST_F(FtpNetworkTransactionTest, CloseConnection) {
   FtpSocketDataProviderCloseConnection ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host", ERR_EMPTY_RESPONSE);
 }
@@ skipping 62 matching lines @@
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailEpsv) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host",
                         FtpSocketDataProvider::PRE_EPSV,
                         FtpSocketDataProvider::PRE_NOPASV,
                         "500 failed epsv\r\n",
                         ERR_FTP_PASV_COMMAND_FAILED);
 }
 
-TEST_F(FtpNetworkTransactionTest, DirectoryTransactionMalformedMdtm) {
-  FtpSocketDataProviderDirectoryListing ctrl_socket;
-  TransactionFailHelper(&ctrl_socket,
-                        "ftp://host",
-                        FtpSocketDataProvider::PRE_MDTM,
-                        FtpSocketDataProvider::PRE_RETR,
-                        "213 foobar\r\n",
-                        OK);
-}
-
-TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailMdtm) {
-  FtpSocketDataProviderDirectoryListing ctrl_socket;
-  TransactionFailHelper(&ctrl_socket,
-                        "ftp://host",
-                        FtpSocketDataProvider::PRE_MDTM,
-                        FtpSocketDataProvider::PRE_RETR,
-                        "500 failed mdtm\r\n",
-                        OK);
-}
-
-TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailEpsv2) {
-  FtpSocketDataProviderDirectoryListing ctrl_socket;
-  TransactionFailHelper(&ctrl_socket,
-                        "ftp://host",
-                        FtpSocketDataProvider::PRE_EPSV2,
-                        FtpSocketDataProvider::PRE_NOPASV,
-                        "500 failed epsv2\r\n",
-                        ERR_FTP_PASV_COMMAND_FAILED);
-}
-
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailCwd) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host",
                         FtpSocketDataProvider::PRE_CWD,
                         FtpSocketDataProvider::PRE_QUIT,
                         "500 failed cwd\r\n",
                         ERR_FAILED);
 }
 
@@ skipping 80 matching lines @@
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailEpsv) {
   FtpSocketDataProviderFileDownload ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_EPSV,
                         FtpSocketDataProvider::PRE_NOPASV,
                         "500 failed pasv\r\n",
                         ERR_FTP_PASV_COMMAND_FAILED);
 }
 
-TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailMdtm) {
+TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailRetr) {
   FtpSocketDataProviderFileDownload ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
-                        FtpSocketDataProvider::PRE_MDTM,
                         FtpSocketDataProvider::PRE_RETR,
-                        "500 failed mdtm\r\n",
-                        OK);
-}
-
-TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailRetr) {
-  FtpSocketDataProviderFileDownloadRetrFail ctrl_socket;
-  TransactionFailHelper(&ctrl_socket,
-                        "ftp://host/file",
-                        FtpSocketDataProvider::PRE_RETR,
                         FtpSocketDataProvider::PRE_QUIT,
                         "500 failed retr\r\n",
                         ERR_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFileNotFound) {
-  FtpSocketDataProviderFileDownloadRetrFail ctrl_socket;
+  FtpSocketDataProviderFileDownload ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
-                        "ftp://host/file",
-                        FtpSocketDataProvider::PRE_RETR,
-                        FtpSocketDataProvider::PRE_EPSV2,
-                        "550 cannot open file\r\n",
-                        ERR_FILE_NOT_FOUND);
+                        "ftp://host/file;type=i",
+                        FtpSocketDataProvider::PRE_SIZE,
+                        FtpSocketDataProvider::PRE_QUIT,
+                        "550 File Not Found\r\n",
+                        ERR_FAILED);
 }
 
 // Test for http://crbug.com/38845.
 TEST_F(FtpNetworkTransactionTest, ZeroLengthDirInPWD) {
   FtpSocketDataProviderFileDownload ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_PWD,
                         FtpSocketDataProvider::PRE_TYPE,
                         "257 \"\"\r\n",
                         OK);
 }
 
 }  // namespace net