FTP: add more detailed error codes based on RFC 959.

net/ftp/ftp_network_transaction.cc

 // Copyright (c) 2010 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/compiler_specific.h"
 #include "base/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 25 matching lines @@
   // characters in the command if the request path contains them. To be
   // compatible, we do the same and allow non-ASCII characters in a command.
 
   // Protect agains newline injection attack.
   if (input.find_first_of("\r\n") != std::string::npos)
     return false;
 
   return true;
 }
 
+enum ErrorClass {
+  // The requested action was initiated. The client should expect another
+  // reply before issuing the next command.
+  ERROR_CLASS_INITIATED,
+
+  // The requested action has been successfully completed.
+  ERROR_CLASS_OK,
+
+  // The command has been accepted, but to complete the operation, more
+  // information must be sent by the client.
+  ERROR_CLASS_INFO_NEEDED,
+
+  // The command was not accepted and the requested action did not take place.
+  // This condition is temporary, and the client is encouraged to restart the
+  // command sequence.
+  ERROR_CLASS_TRANSIENT_ERROR,
+
+  // The command was not accepted and the requested action did not take place.
+  // This condition is rather permanent, and the client is discouraged from
+  // repeating the exact request.
+  ERROR_CLASS_PERMANENT_ERROR,
+};
+
+// Returns the error class for given response code. Caller should ensure
+// that |response_code| is in range 100-599.
+ErrorClass GetErrorClass(int response_code) {
+  if (response_code >= 100 && response_code <= 199)
+    return ERROR_CLASS_INITIATED;
+
+  if (response_code >= 200 && response_code <= 299)
+    return ERROR_CLASS_OK;
+
+  if (response_code >= 300 && response_code <= 399)
+    return ERROR_CLASS_INFO_NEEDED;
+
+  if (response_code >= 400 && response_code <= 499)
+    return ERROR_CLASS_TRANSIENT_ERROR;
+
+  if (response_code >= 500 && response_code <= 599)
+    return ERROR_CLASS_PERMANENT_ERROR;
+
+  // We should not be called on invalid error codes.
+  NOTREACHED() << response_code;
+  return ERROR_CLASS_PERMANENT_ERROR;
+}
+
+// Returns network error code for received FTP |response_code|.
+int GetNetErrorCodeForFtpResponseCode(int response_code) {
+  switch (response_code) {
+    case 421:
+      return net::ERR_FTP_SERVICE_UNAVAILABLE;
+    case 426:
+      return net::ERR_FTP_TRANSFER_ABORTED;
+    case 450:
+      return net::ERR_FTP_FILE_BUSY;
+    case 500:
+    case 501:
+      return net::ERR_FTP_SYNTAX_ERROR;
+    case 502:
+    case 504:
+      return net::ERR_FTP_COMMAND_NOT_SUPPORTED;
+    case 503:
+      return net::ERR_FTP_BAD_COMMAND_SEQUENCE;
+    default:
+      return net::ERR_FTP_FAILED;
+  }
+}
+
 // From RFC 2428 Section 3:
 //   The text returned in response to the EPSV command MUST be:
 //     <some text> (<d><d><d><tcp-port><d>)
 //   <d> is a delimiter character, ideally to be |
 bool ExtractPortFromEPSVResponse(const net::FtpCtrlResponse& response,
                                  int* port) {
   if (response.lines.size() != 1)
     return false;
   const char* ptr = response.lines[0].c_str();
   while (*ptr && *ptr != '(')
@@ skipping 120 matching lines @@
 
   next_state_ = STATE_CTRL_RESOLVE_HOST;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
 int FtpNetworkTransaction::RestartIgnoringLastError(
     CompletionCallback* callback) {
-  return ERR_FAILED;
+  return ERR_NOT_IMPLEMENTED;
 }
 
 int FtpNetworkTransaction::Read(IOBuffer* buf,
                                 int buf_len,
                                 CompletionCallback* callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   read_data_buf_ = buf;
   read_data_buf_len_ = buf_len;
@@ skipping 59 matching lines @@
   write_command_buf_ = new IOBufferWithSize(command.length() + 2);
   write_buf_ = new DrainableIOBuffer(write_command_buf_,
                                      write_command_buf_->size());
   memcpy(write_command_buf_->data(), command.data(), command.length());
   memcpy(write_command_buf_->data() + command.length(), kCRLF, 2);
 
   next_state_ = STATE_CTRL_WRITE;
   return OK;
 }
 
-// static
-FtpNetworkTransaction::ErrorClass FtpNetworkTransaction::GetErrorClass(
-    int response_code) {
-  if (response_code >= 100 && response_code <= 199)
-    return ERROR_CLASS_INITIATED;
-
-  if (response_code >= 200 && response_code <= 299)
-    return ERROR_CLASS_OK;
-
-  if (response_code >= 300 && response_code <= 399)
-    return ERROR_CLASS_INFO_NEEDED;
-
-  if (response_code >= 400 && response_code <= 499)
-    return ERROR_CLASS_TRANSIENT_ERROR;
-
-  if (response_code >= 500 && response_code <= 599)
-    return ERROR_CLASS_PERMANENT_ERROR;
-
-  // We should not be called on invalid error codes.
-  NOTREACHED();
-  return ERROR_CLASS_PERMANENT_ERROR;
-}
-
 int FtpNetworkTransaction::ProcessCtrlResponse() {
   FtpCtrlResponse response = ctrl_response_buffer_->PopResponse();
 
   int rv = OK;
   switch (command_sent_) {
     case COMMAND_NONE:
       // TODO(phajdan.jr): Check for errors in the welcome message.
       next_state_ = STATE_CTRL_WRITE_USER;
       break;
     case COMMAND_USER:
@@ skipping 368 matching lines @@
 int FtpNetworkTransaction::ProcessResponseUSER(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_OK:
       next_state_ = STATE_CTRL_WRITE_SYST;
       break;
     case ERROR_CLASS_INFO_NEEDED:
       next_state_ = STATE_CTRL_WRITE_PASS;
       break;
     case ERROR_CLASS_TRANSIENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_PERMANENT_ERROR:
       response_.needs_auth = true;
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // PASS command.
 int FtpNetworkTransaction::DoCtrlWritePASS() {
   std::string command = "PASS " + WideToUTF8(password_);
 
   if (!IsValidFTPCommandString(command))
     return Stop(ERR_MALFORMED_IDENTITY);
 
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_PASS);
 }
 
 int FtpNetworkTransaction::ProcessResponsePASS(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_OK:
       next_state_ = STATE_CTRL_WRITE_SYST;
       break;
     case ERROR_CLASS_INFO_NEEDED:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_TRANSIENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_PERMANENT_ERROR:
       response_.needs_auth = true;
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // SYST command.
 int FtpNetworkTransaction::DoCtrlWriteSYST() {
   std::string command = "SYST";
@@ skipping 28 matching lines @@
         } else if (line.find("vms") != std::string::npos) {
           system_type_ = SYSTEM_TYPE_VMS;
         }
       }
       next_state_ = STATE_CTRL_WRITE_PWD;
       break;
     }
     case ERROR_CLASS_INFO_NEEDED:
       return Stop(ERR_INVALID_RESPONSE);
     case ERROR_CLASS_TRANSIENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_PERMANENT_ERROR:
       // Server does not recognize the SYST command so proceed.
       next_state_ = STATE_CTRL_WRITE_PWD;
       break;
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
@@ skipping 26 matching lines @@
         line = FtpUtil::VMSPathToUnix(line);
       if (line.length() && line[line.length() - 1] == '/')
         line.erase(line.length() - 1);
       current_remote_directory_ = line;
       next_state_ = STATE_CTRL_WRITE_TYPE;
       break;
     }
     case ERROR_CLASS_INFO_NEEDED:
       return Stop(ERR_INVALID_RESPONSE);
     case ERROR_CLASS_TRANSIENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_PERMANENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // TYPE command.
 int FtpNetworkTransaction::DoCtrlWriteTYPE() {
   std::string command = "TYPE ";
@@ skipping 13 matching lines @@
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_INITIATED:
       return Stop(ERR_INVALID_RESPONSE);
     case ERROR_CLASS_OK:
       next_state_ = use_epsv_ ? STATE_CTRL_WRITE_EPSV : STATE_CTRL_WRITE_PASV;
       break;
     case ERROR_CLASS_INFO_NEEDED:
       return Stop(ERR_INVALID_RESPONSE);
     case ERROR_CLASS_TRANSIENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_PERMANENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // EPSV command
 int FtpNetworkTransaction::DoCtrlWriteEPSV() {
   const std::string command = "EPSV";
@@ skipping 44 matching lines @@
       if (!ExtractPortFromPASVResponse(response, &data_connection_port_))
         return Stop(ERR_INVALID_RESPONSE);
       if (data_connection_port_ < 1024 ||
           !IsPortAllowedByFtp(data_connection_port_))
         return Stop(ERR_UNSAFE_PORT);
       next_state_ = STATE_DATA_CONNECT;
       break;
     case ERROR_CLASS_INFO_NEEDED:
       return Stop(ERR_INVALID_RESPONSE);
     case ERROR_CLASS_TRANSIENT_ERROR:
-      return Stop(ERR_FTP_PASV_COMMAND_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_PERMANENT_ERROR:
-      return Stop(ERR_FTP_PASV_COMMAND_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // SIZE command
 int FtpNetworkTransaction::DoCtrlWriteSIZE() {
   std::string command = "SIZE " + GetRequestPathForFtpCommand(false);
@@ skipping 19 matching lines @@
     case ERROR_CLASS_INFO_NEEDED:
       break;
     case ERROR_CLASS_TRANSIENT_ERROR:
       break;
     case ERROR_CLASS_PERMANENT_ERROR:
       // It's possible that SIZE failed because the path is a directory.
       if (response.status_code == 550 &&
           resource_type_ == RESOURCE_TYPE_UNKNOWN) {
         resource_type_ = RESOURCE_TYPE_DIRECTORY;
       } else if (resource_type_ != RESOURCE_TYPE_DIRECTORY) {
-        return Stop(ERR_FAILED);
+        return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
       }
       break;
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
 
   if (resource_type_ == RESOURCE_TYPE_DIRECTORY)
     next_state_ = STATE_CTRL_WRITE_CWD;
   else
@@ skipping 15 matching lines @@
     case ERROR_CLASS_INITIATED:
       // We want the client to start reading the response at this point.
       // It got here either through Start or RestartWithAuth. We want that
       // method to complete. Not setting next state here will make DoLoop exit
       // and in turn make Start/RestartWithAuth complete.
       break;
     case ERROR_CLASS_OK:
       next_state_ = STATE_CTRL_WRITE_QUIT;
       break;
     case ERROR_CLASS_INFO_NEEDED:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_TRANSIENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_PERMANENT_ERROR:
       // Code 550 means "Failed to open file". Other codes are unrelated,
       // like "Not logged in" etc.
       if (response.status_code != 550)
-        return Stop(ERR_FAILED);
+        return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
 
       // It's possible that RETR failed because the path is a directory.
       resource_type_ = RESOURCE_TYPE_DIRECTORY;
 
       // We're going to try CWD next, but first send a PASV one more time,
       // because some FTP servers, including FileZilla, require that.
       // See http://crbug.com/25316.
       next_state_ = use_epsv_ ? STATE_CTRL_WRITE_EPSV : STATE_CTRL_WRITE_PASV;
       break;
     default:
@@ skipping 13 matching lines @@
 int FtpNetworkTransaction::ProcessResponseCWD(const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_INITIATED:
       return Stop(ERR_INVALID_RESPONSE);
     case ERROR_CLASS_OK:
       next_state_ = STATE_CTRL_WRITE_MLSD;
       break;
     case ERROR_CLASS_INFO_NEEDED:
       return Stop(ERR_INVALID_RESPONSE);
     case ERROR_CLASS_TRANSIENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_PERMANENT_ERROR:
       if (resource_type_ == RESOURCE_TYPE_DIRECTORY &&
           response.status_code == 550) {
         // 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);
       }
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // MLSD command
 int FtpNetworkTransaction::DoCtrlWriteMLSD() {
   next_state_ = STATE_CTRL_READ;
@@ skipping 46 matching lines @@
       // and in turn make Start/RestartWithAuth complete.
       response_.is_directory_listing = true;
       break;
     case ERROR_CLASS_OK:
       response_.is_directory_listing = true;
       next_state_ = STATE_CTRL_WRITE_QUIT;
       break;
     case ERROR_CLASS_INFO_NEEDED:
       return Stop(ERR_INVALID_RESPONSE);
     case ERROR_CLASS_TRANSIENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_PERMANENT_ERROR:
-      return Stop(ERR_FAILED);
+      return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // QUIT command
 int FtpNetworkTransaction::DoCtrlWriteQUIT() {
   std::string command = "QUIT";
@@ skipping 140 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