Correctly talk to VMS servers (translate UNIX paths to VMS and vice versa).

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/ftp/ftp_util.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";
 
@@ skipping 27 matching lines @@
       user_callback_(NULL),
       session_(session),
       request_(NULL),
       resolver_(session->host_resolver()),
       read_ctrl_buf_(new IOBuffer(kCtrlBufLen)),
       ctrl_response_buffer_(new FtpCtrlResponseBuffer()),
       read_data_buf_len_(0),
       file_data_len_(0),
       write_command_buf_written_(0),
       last_error_(OK),
+      system_type_(SYSTEM_TYPE_UNKNOWN),
       retr_failed_(false),
       data_connection_port_(0),
       socket_factory_(socket_factory),
       next_state_(STATE_NONE) {
 }
 
 FtpNetworkTransaction::~FtpNetworkTransaction() {
 }
 
 int FtpNetworkTransaction::Start(const FtpRequestInfo* request_info,
@@ skipping 243 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() : "/");
+std::string FtpNetworkTransaction::GetRequestPathForFtpCommand(
+    bool is_directory) const {
+  std::string path(current_remote_directory_);
+  if (request_->url.has_path())
+    path.append(request_->url.path());
+  // Make sure that if the path is expected to be a file, it won't end
+  // with a trailing slash.
+  if (!is_directory && path.length() > 1 && path[path.length() - 1] == '/')
+    path.erase(path.length() - 1);
   UnescapeRule::Type unescape_rules = UnescapeRule::SPACES |
                                       UnescapeRule::URL_SPECIAL_CHARS;
   // This may unescape to non-ASCII characters, but we allow that. See the
   // comment for IsValidFTPCommandString.
   path = UnescapeURLComponent(path, unescape_rules);
+
+  if (system_type_ == SYSTEM_TYPE_VMS) {
+    if (is_directory)
+      path = FtpUtil::UnixDirectoryPathToVMS(path);
+    else
+      path = FtpUtil::UnixFilePathToVMS(path);
+  }
+
   DCHECK(IsValidFTPCommandString(path));
   return path;
 }
 
 int FtpNetworkTransaction::DoLoop(int result) {
   DCHECK(next_state_ != STATE_NONE);
 
   int rv = result;
   do {
     State state = next_state_;
@@ skipping 284 matching lines @@
   std::string command = "SYST";
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_SYST);
 }
 
 int FtpNetworkTransaction::ProcessResponseSYST(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_INITIATED:
       return Stop(ERR_INVALID_RESPONSE);
-    case ERROR_CLASS_OK:
-      // TODO(ibrar): Process SYST response properly.
+    case ERROR_CLASS_OK: {
+      // All important info should be on the first line.
+      std::string line = response.lines[0];
+      // The response should be ASCII, which allows us to do case-insensitive
+      // comparisons easily. If it is not ASCII, we leave the system type
+      // as unknown.
+      if (IsStringASCII(line)) {
+        line = StringToLowerASCII(line);
+        // The "magic" strings we test for below have been gathered by an
+        // empirical study.
+        if (line.find("l8") != std::string::npos ||
+            line.find("unix") != std::string::npos ||
+            line.find("bsd") != std::string::npos) {
+          system_type_ = SYSTEM_TYPE_UNIX;
+        } else if (line.find("win32") != std::string::npos ||
+                   line.find("windows") != std::string::npos) {
+          system_type_ = SYSTEM_TYPE_WINDOWS;
+        } else if (line.find("os/2") != std::string::npos) {
+          system_type_ = SYSTEM_TYPE_OS2;
+        } 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);
     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;
 }
 
 // PWD command.
 int FtpNetworkTransaction::DoCtrlWritePWD() {
   std::string command = "PWD";
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_PWD);
 }
 
 int FtpNetworkTransaction::ProcessResponsePWD(const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_INITIATED:
       return Stop(ERR_INVALID_RESPONSE);
-    case ERROR_CLASS_OK:
+    case ERROR_CLASS_OK: {
+      // The info we look for should be on the first line.
+      std::string line = response.lines[0];
+      if (line.empty())
+        return Stop(ERR_INVALID_RESPONSE);
+      std::string::size_type quote_pos = line.find('"');
+      if (quote_pos != std::string::npos) {
+        line = line.substr(quote_pos + 1);
+        quote_pos = line.find('"');
+        if (quote_pos == std::string::npos)
+          return Stop(ERR_INVALID_RESPONSE);
+        line = line.substr(0, quote_pos);
+      }
+      if (system_type_ == SYSTEM_TYPE_VMS)
+        line = FtpUtil::VMSPathToUnix(line);
+      if (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);
     case ERROR_CLASS_PERMANENT_ERROR:
       return Stop(ERR_FAILED);
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
@@ skipping 113 matching lines @@
       return Stop(ERR_FAILED);
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // SIZE command
 int FtpNetworkTransaction::DoCtrlWriteSIZE() {
-  std::string command = "SIZE " + GetRequestPathForFtpCommand();
+  std::string command = "SIZE " + GetRequestPathForFtpCommand(false);
   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 " + GetRequestPathForFtpCommand();
+  std::string command = "RETR " + GetRequestPathForFtpCommand(false);
   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 " + GetRequestPathForFtpCommand();
+  std::string command = "MDTM " + GetRequestPathForFtpCommand(false);
   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 " + GetRequestPathForFtpCommand();
+  std::string command = "CWD " + GetRequestPathForFtpCommand(true);
   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 13 matching lines @@
       return Stop(ERR_FAILED);
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
 // LIST command
 int FtpNetworkTransaction::DoCtrlWriteLIST() {
-  std::string command = "LIST";
+  std::string command(system_type_ == SYSTEM_TYPE_VMS ? "LIST *.*;0" : "LIST");
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_LIST);
 }
 
 int FtpNetworkTransaction::ProcessResponseLIST(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_INITIATED:
       response_.is_directory_listing = true;
       break;
@@ skipping 69 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