Handle empty response to FTP QUIT message.

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_macros.h"
@@ skipping 200 matching lines @@
 }
 
 }  // namespace
 
 FtpNetworkTransaction::FtpNetworkTransaction(
     HostResolver* resolver,
     ClientSocketFactory* socket_factory)
     : command_sent_(COMMAND_NONE),
       io_callback_(base::Bind(&FtpNetworkTransaction::OnIOComplete,
                               base::Unretained(this))),
-      request_(NULL),
+      request_(nullptr),
       resolver_(resolver),
       read_ctrl_buf_(new IOBuffer(kCtrlBufLen)),
       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),
-      state_after_data_connect_complete_(STATE_NONE) {
-}
+      state_after_data_connect_complete_(STATE_NONE) {}
 
 FtpNetworkTransaction::~FtpNetworkTransaction() {
 }
 
 int FtpNetworkTransaction::Stop(int error) {
-  if (command_sent_ == COMMAND_QUIT)
-    return error;
+  if (command_sent_ == COMMAND_QUIT) {
+    if (error != ERR_EMPTY_RESPONSE)
+      return error;
+
+    // For empty responses, if this is propagating an error, then it will return
+    // the error. If the error occurred during a QUIT command, then this will
+    // return OK since there was no previous error. Some FTP servers are lazy
+    // and do not bother responding to QUIT commands.
+    // See https://crbug.com/633841
+    return last_error_;
+  }
 
   next_state_ = STATE_CTRL_WRITE_QUIT;
   last_error_ = error;
   return OK;
 }
 
 int FtpNetworkTransaction::Start(const FtpRequestInfo* request_info,
                                  const CompletionCallback& callback,
                                  const NetLogWithSource& net_log) {
   net_log_ = net_log;
   request_ = request_info;
 
-  ctrl_response_buffer_.reset(new FtpCtrlResponseBuffer(net_log_));
+  ctrl_response_buffer_ = base::MakeUnique<FtpCtrlResponseBuffer>(net_log_);
 
   if (request_->url.has_username()) {
     base::string16 username;
     base::string16 password;
     GetIdentityFromURL(request_->url, &username, &password);
     credentials_.Set(username, password);
   } else {
     credentials_.Set(base::ASCIIToUTF16("anonymous"),
                      base::ASCIIToUTF16("chrome@example.com"));
   }
@@ skipping 65 matching lines @@
 
 uint64_t FtpNetworkTransaction::GetUploadProgress() const {
   return 0;
 }
 
 void FtpNetworkTransaction::ResetStateForRestart() {
   command_sent_ = COMMAND_NONE;
   user_callback_.Reset();
   response_ = FtpResponseInfo();
   read_ctrl_buf_ = new IOBuffer(kCtrlBufLen);
-  ctrl_response_buffer_.reset(new FtpCtrlResponseBuffer(net_log_));
-  read_data_buf_ = NULL;
+  ctrl_response_buffer_ = base::MakeUnique<FtpCtrlResponseBuffer>(net_log_);
+  read_data_buf_ = nullptr;
   read_data_buf_len_ = 0;
   if (write_buf_.get())
     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_NONE;
 }
@@ skipping 306 matching lines @@
 
 int FtpNetworkTransaction::DoCtrlResolveHostComplete(int result) {
   if (result == OK)
     next_state_ = STATE_CTRL_CONNECT;
   return result;
 }
 
 int FtpNetworkTransaction::DoCtrlConnect() {
   next_state_ = STATE_CTRL_CONNECT_COMPLETE;
   ctrl_socket_ = socket_factory_->CreateTransportClientSocket(
-      addresses_, NULL, net_log_.net_log(), net_log_.source());
+      addresses_, nullptr, net_log_.net_log(), net_log_.source());
   net_log_.AddEvent(
       NetLogEventType::FTP_CONTROL_CONNECTION,
       ctrl_socket_->NetLog().source().ToEventParametersCallback());
   return ctrl_socket_->Connect(io_callback_);
 }
 
 int FtpNetworkTransaction::DoCtrlConnectComplete(int result) {
   if (result == OK) {
     // Put the peer's IP address and port into the response.
     IPEndPoint ip_endpoint;
@@ skipping 52 matching lines @@
       write_buf_.get(), write_buf_->BytesRemaining(), io_callback_);
 }
 
 int FtpNetworkTransaction::DoCtrlWriteComplete(int result) {
   if (result < 0)
     return result;
 
   write_buf_->DidConsume(result);
   if (write_buf_->BytesRemaining() == 0) {
     // Clear the write buffer.
-    write_buf_ = NULL;
-    write_command_buf_ = NULL;
+    write_buf_ = nullptr;
+    write_command_buf_ = nullptr;
 
     next_state_ = STATE_CTRL_READ;
   } else {
     next_state_ = STATE_CTRL_WRITE;
   }
   return OK;
 }
 
 // FTP Commands and responses
 
@@ skipping 458 matching lines @@
   IPEndPoint ip_endpoint;
   AddressList data_address;
   // Connect to the same host as the control socket to prevent PASV port
   // scanning attacks.
   int rv = ctrl_socket_->GetPeerAddress(&ip_endpoint);
   if (rv != OK)
     return Stop(rv);
   data_address = AddressList::CreateFromIPAddress(
       ip_endpoint.address(), data_connection_port_);
   data_socket_ = socket_factory_->CreateTransportClientSocket(
-      data_address, NULL, net_log_.net_log(), net_log_.source());
+      data_address, nullptr, net_log_.net_log(), net_log_.source());
   net_log_.AddEvent(
       NetLogEventType::FTP_DATA_CONNECTION,
       data_socket_->NetLog().source().ToEventParametersCallback());
   return data_socket_->Connect(io_callback_);
 }
 
 int FtpNetworkTransaction::DoDataConnectComplete(int result) {
   if (result != OK && use_epsv_) {
     // It's possible we hit a broken server, sadly. They can break in different
     // ways. Some time out, some reset a connection. Fall back to PASV.
@@ skipping 12 matching lines @@
     return Stop(result);
 
   next_state_ = state_after_data_connect_complete_;
   return OK;
 }
 
 int FtpNetworkTransaction::DoDataRead() {
   DCHECK(read_data_buf_.get());
   DCHECK_GT(read_data_buf_len_, 0);
 
-  if (data_socket_ == NULL || !data_socket_->IsConnected()) {
+  if (!data_socket_ || !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
     // to be closed on our side too.
     data_socket_.reset();
 
     if (ctrl_socket_->IsConnected()) {
       // Wait for the server's response, we should get it before sending QUIT.
       next_state_ = STATE_CTRL_READ;
       return OK;
     }
@@ skipping 94 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