FTP: Open a fresh data connection after a command error.

net/ftp/ftp_network_transaction.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
@@ skipping 206 matching lines @@
       read_data_buf_len_(0),
       last_error_(OK),
       system_type_(SYSTEM_TYPE_UNKNOWN),
       // Use image (binary) transfer by default. It should always work,
       // whereas the ascii transfer may damage binary data.
       data_type_(DATA_TYPE_IMAGE),
       resource_type_(RESOURCE_TYPE_UNKNOWN),
       use_epsv_(true),
       data_connection_port_(0),
       socket_factory_(socket_factory),
-      next_state_(STATE_NONE) {
+      next_state_(STATE_NONE),
+      state_after_data_connect_complete_(STATE_CTRL_WRITE_SIZE) {
 }
 
 FtpNetworkTransaction::~FtpNetworkTransaction() {
 }
 
 int FtpNetworkTransaction::Stop(int error) {
   if (command_sent_ == COMMAND_QUIT)
     return error;
 
   next_state_ = STATE_CTRL_WRITE_QUIT;
@@ skipping 101 matching lines @@
   ctrl_response_buffer_.reset(new FtpCtrlResponseBuffer(net_log_));
   read_data_buf_ = NULL;
   read_data_buf_len_ = 0;
   if (write_buf_)
     write_buf_->SetOffset(0);
   last_error_ = OK;
   data_connection_port_ = 0;
   ctrl_socket_.reset();
   data_socket_.reset();
   next_state_ = STATE_NONE;
+  state_after_data_connect_complete_ = STATE_CTRL_WRITE_SIZE;
+}
+
+void FtpNetworkTransaction::ResetDataConnectionAfterError(State next_state) {
+  // The server _might_ have reset the data connection
+  // (see RFC 959 3.2. ESTABLISHING DATA CONNECTIONS:
+  // "The server MUST close the data connection under the following
+  // conditions:
+  // ...
+  // 5. An irrecoverable error condition occurs.")
+  //
+  // It is ambiguous what an irrecoverable error condition is,
+  // so we take no chances.
+  state_after_data_connect_complete_ = next_state;
+  next_state_ = use_epsv_ ? STATE_CTRL_WRITE_EPSV : STATE_CTRL_WRITE_PASV;
 }
 
 void FtpNetworkTransaction::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(!user_callback_.is_null());
 
   // Since Run may result in Read being called, clear callback_ up front.
   CompletionCallback c = user_callback_;
   user_callback_.Reset();
   c.Run(rv);
@@ skipping 684 matching lines @@
 
 // SIZE command
 int FtpNetworkTransaction::DoCtrlWriteSIZE() {
   std::string command = "SIZE " + GetRequestPathForFtpCommand(false);
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, command, COMMAND_SIZE);
 }
 
 int FtpNetworkTransaction::ProcessResponseSIZE(
     const FtpCtrlResponse& response) {
+  State state_after_size;
+  if (resource_type_ == RESOURCE_TYPE_FILE)
+    state_after_size = STATE_CTRL_WRITE_RETR;
+  else
+    state_after_size = STATE_CTRL_WRITE_CWD;
+
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_INITIATED:
+      next_state_ = state_after_size;
       break;
     case ERROR_CLASS_OK:
       if (response.lines.size() != 1)
         return Stop(ERR_INVALID_RESPONSE);
       int64 size;
       if (!base::StringToInt64(response.lines[0], &size))
         return Stop(ERR_INVALID_RESPONSE);
       if (size < 0)
         return Stop(ERR_INVALID_RESPONSE);
 
       // A successful response to SIZE does not mean the resource is a file.
       // Some FTP servers (for example, the qnx one) send a SIZE even for
       // directories.
       response_.expected_content_size = size;
+
+      next_state_ = state_after_size;
       break;
     case ERROR_CLASS_INFO_NEEDED:
+      next_state_ = state_after_size;
       break;
     case ERROR_CLASS_TRANSIENT_ERROR:
+      ResetDataConnectionAfterError(state_after_size);
       break;
     case ERROR_CLASS_PERMANENT_ERROR:
       // It's possible that SIZE failed because the path is a directory.
       if (resource_type_ == RESOURCE_TYPE_UNKNOWN &&
           response.status_code != 550) {
         return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
       }
+
+      ResetDataConnectionAfterError(state_after_size);
       break;
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
 
-  if (resource_type_ == RESOURCE_TYPE_FILE)
-    next_state_ = STATE_CTRL_WRITE_RETR;
-  else
-    next_state_ = STATE_CTRL_WRITE_CWD;
-
   return OK;
 }
 
 // CWD command
 int FtpNetworkTransaction::DoCtrlWriteCWD() {
   std::string command = "CWD " + GetRequestPathForFtpCommand(true);
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, command, COMMAND_CWD);
 }
 
@@ skipping 34 matching lines @@
     // We're assuming that the resource is a directory, but the server
     // says it's not true. The most probable interpretation is that it
     // doesn't exist (with FTP we can't be sure).
     return Stop(ERR_FILE_NOT_FOUND);
   }
 
   // We are here because SIZE failed and we are not sure what the resource
   // type is. It could still be file, and SIZE could fail because of
   // an access error (http://crbug.com/56734). Try RETR just to be sure.
   resource_type_ = RESOURCE_TYPE_FILE;
-  next_state_ = STATE_CTRL_WRITE_RETR;
 
+  ResetDataConnectionAfterError(STATE_CTRL_WRITE_RETR);
   return OK;
 }
 
 // LIST command
 int FtpNetworkTransaction::DoCtrlWriteLIST() {
   // Use the -l option for mod_ftp configured in LISTIsNLST mode: the option
   // forces LIST output instead of NLST (which would be ambiguous for us
   // to parse).
   std::string command("LIST -l");
   if (system_type_ == SYSTEM_TYPE_VMS)
@@ skipping 75 matching lines @@
     return OK;
   }
 
   // Only record the connection error after we've applied all our fallbacks.
   // We want to capture the final error, one we're not going to recover from.
   RecordDataConnectionError(result);
 
   if (result != OK)
     return Stop(result);
 
-  next_state_ = STATE_CTRL_WRITE_SIZE;
+  next_state_ = state_after_data_connect_complete_;
   return OK;
 }
 
 int FtpNetworkTransaction::DoDataRead() {
   DCHECK(read_data_buf_);
   DCHECK_GT(read_data_buf_len_, 0);
 
   if (data_socket_ == NULL || !data_socket_->IsConnected()) {
     // If we don't destroy the data socket completely, some servers will wait
     // for us (http://crbug.com/21127). The half-closed TCP connection needs
@@ skipping 101 matching lines @@
   if (!had_error_type[type]) {
     had_error_type[type] = true;
     UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorHappened",
         type, NUM_OF_NET_ERROR_TYPES);
   }
   UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorCount",
       type, NUM_OF_NET_ERROR_TYPES);
 }
 
 }  // namespace net