Unescape FTP URL paths, Firefox-compatible.

net/ftp/ftp_network_transaction.cc

 // Copyright (c) 2008 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/string_util.h"
 #include "net/base/connection_type_histograms.h"
+#include "net/base/escape.h"
 #include "net/base/load_log.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/ftp/ftp_network_session.h"
 #include "net/ftp/ftp_request_info.h"
 #include "net/socket/client_socket.h"
 #include "net/socket/client_socket_factory.h"
 
 // TODO(ibrar): Try to avoid sscanf.
 #if !defined(COMPILER_MSVC)
 #define sscanf_s sscanf
 #endif
 
 const char kCRLF[] = "\r\n";
 
 const int kCtrlBufLen = 1024;
 
 namespace {
 
 // Returns true if |input| can be safely used as a part of FTP command.
 bool IsValidFTPCommandString(const std::string& input) {
-  // RFC 959 only allows ASCII strings.

[eroman, 2009/09/18 22:51:23]

Please add a comment in IsValidFTPComment() that we allow non-ASCII, and the
empirical data that led to that decision.

-  if (!IsStringASCII(input))
-    return false;
-
   // Protect agains newline injection attack.
   if (input.find_first_of("\r\n") != std::string::npos)
     return false;
 
   return true;
 }
 
 }  // namespace
 
 namespace net {
@@ skipping 270 matching lines @@
   user_callback_ = NULL;
   c->Run(rv);
 }
 
 void FtpNetworkTransaction::OnIOComplete(int result) {
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
     DoCallback(rv);
 }
 
+std::string FtpNetworkTransaction::GetRequestPathForFtpCommand() const {
+  std::string path = (request_->url.has_path() ? request_->url.path() : "/");
+  UnescapeRule::Type unescape_rules = UnescapeRule::SPACES |
+                                      UnescapeRule::URL_SPECIAL_CHARS;
+  path = UnescapeURLComponent(path, unescape_rules);

[eroman, 2009/09/18 22:51:23]

 Please add a comment that escaping to non-ASCII is OK.

+  DCHECK(IsValidFTPCommandString(path));
+  return path;
+}
+
 int FtpNetworkTransaction::DoLoop(int result) {
   DCHECK(next_state_ != STATE_NONE);
 
   int rv = result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_CTRL_INIT:
         DCHECK(rv == OK);
@@ skipping 446 matching lines @@
       return Stop(ERR_FAILED);
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // SIZE command
 int FtpNetworkTransaction::DoCtrlWriteSIZE() {
-  std::string command = "SIZE";
-  if (request_->url.has_path()) {
-    command.append(" ");
-    command.append(request_->url.path());
-  }
+  std::string command = "SIZE " + GetRequestPathForFtpCommand();
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_SIZE);
 }
 
 int FtpNetworkTransaction::ProcessResponseSIZE(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_INITIATED:
       break;
     case ERROR_CLASS_OK:
@@ skipping 13 matching lines @@
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   next_state_ = STATE_CTRL_WRITE_MDTM;
   return OK;
 }
 
 // RETR command
 int FtpNetworkTransaction::DoCtrlWriteRETR() {
-  std::string command = "RETR";
-  if (request_->url.has_path()) {
-    command.append(" ");
-    command.append(request_->url.path());
-  } else {
-    command.append(" /");
-  }
+  std::string command = "RETR " + GetRequestPathForFtpCommand();
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_RETR);
 }
 
 int FtpNetworkTransaction::ProcessResponseRETR(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     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
@@ skipping 26 matching lines @@
       break;
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // MDMT command
 int FtpNetworkTransaction::DoCtrlWriteMDTM() {
-  std::string command = "MDTM";
-  if (request_->url.has_path()) {
-    command.append(" ");
-    command.append(request_->url.path());
-  } else {
-    command.append(" /");
-  }
+  std::string command = "MDTM " + GetRequestPathForFtpCommand();
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_MDTM);
 }
 
 int FtpNetworkTransaction::ProcessResponseMDTM(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_INITIATED:
       return Stop(ERR_FAILED);
     case ERROR_CLASS_OK:
       next_state_ = STATE_CTRL_WRITE_RETR;
       break;
     case ERROR_CLASS_INFO_NEEDED:
       return Stop(ERR_FAILED);
     case ERROR_CLASS_TRANSIENT_ERROR:
       return Stop(ERR_FAILED);
     case ERROR_CLASS_PERMANENT_ERROR:
       next_state_ = STATE_CTRL_WRITE_RETR;
       break;
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 
 // CWD command
 int FtpNetworkTransaction::DoCtrlWriteCWD() {
-  std::string command = "CWD";
-  if (request_->url.has_path()) {
-    command.append(" ");
-    command.append(request_->url.path());
-  } else {
-    command.append(" /");
-  }
+  std::string command = "CWD " + GetRequestPathForFtpCommand();
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_CWD);
 }
 
 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_LIST;
@@ skipping 103 matching lines @@
   read_data_buf_->data()[0] = 0;
   return data_socket_->Read(read_data_buf_, read_data_buf_len_,
                             &io_callback_);
 }
 
 int FtpNetworkTransaction::DoDataReadComplete(int result) {
   return result;
 }
 
 }  // namespace net