FTP: Detect the character encoding only after the entire listing is received.

net/ftp/ftp_directory_listing_parser_vms.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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_directory_listing_parser_vms.h"
 
 #include <vector>
 
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
+#include "base/time.h"
 #include "base/utf_string_conversions.h"
+#include "net/ftp/ftp_directory_listing_parser.h"
 #include "net/ftp/ftp_util.h"
 
 namespace {
 
 // Converts the filename component in listing to the filename we can display.
 // Returns true on success.
 bool ParseVmsFilename(const string16& raw_filename, string16* parsed_filename,
-                      bool* is_directory) {
+                      net::FtpDirectoryListingEntry::Type* type) {
   // On VMS, the files and directories are versioned. The version number is
   // separated from the file name by a semicolon. Example: ANNOUNCE.TXT;2.
   std::vector<string16> listing_parts;
   base::SplitString(raw_filename, ';', &listing_parts);
   if (listing_parts.size() != 2)
     return false;
   int version_number;
   if (!base::StringToInt(listing_parts[1], &version_number))
     return false;
   if (version_number < 0)
     return false;
 
   // Even directories have extensions in the listings. Don't display extensions
   // for directories; it's awkward for non-VMS users. Also, VMS is
   // case-insensitive, but generally uses uppercase characters. This may look
   // awkward, so we convert them to lower case.
   std::vector<string16> filename_parts;
   base::SplitString(listing_parts[0], '.', &filename_parts);
   if (filename_parts.size() != 2)
     return false;
   if (EqualsASCII(filename_parts[1], "DIR")) {
     *parsed_filename = StringToLowerASCII(filename_parts[0]);
-    *is_directory = true;
+    *type = net::FtpDirectoryListingEntry::DIRECTORY;
   } else {
     *parsed_filename = StringToLowerASCII(listing_parts[0]);
-    *is_directory = false;
+    *type = net::FtpDirectoryListingEntry::FILE;
   }
   return true;
 }
 
 bool ParseVmsFilesize(const string16& input, int64* size) {
   // VMS's directory listing gives us file size in blocks. We assume that
   // the block size is 512 bytes. It doesn't give accurate file size, but is the
   // best information we have.
   const int kBlockSize = 512;
 
@@ skipping 53 matching lines @@
       LooksLikeVmsFileProtectionListingPart(parts[2]) &&
       LooksLikeVmsFileProtectionListingPart(parts[3]);
 }
 
 bool LooksLikeVmsUserIdentificationCode(const string16& input) {
   if (input.length() < 2)
     return false;
   return input[0] == '[' && input[input.length() - 1] == ']';
 }
 
+bool LooksLikePermissionDeniedError(const string16& text) {
+  static const char* kPermissionDeniedMessages[] = {
+    "%RMS-E-PRV",
+    "privilege",
+  };
+
+  for (size_t i = 0; i < arraysize(kPermissionDeniedMessages); i++) {
+    if (text.find(ASCIIToUTF16(kPermissionDeniedMessages[i])) != string16::npos)
+      return true;
+  }
+
+  return false;
+}
+
 bool VmsDateListingToTime(const std::vector<string16>& columns,
                           base::Time* time) {
-  DCHECK_EQ(3U, columns.size());
+  DCHECK_EQ(4U, columns.size());
 
   base::Time::Exploded time_exploded = { 0 };
 
   // Date should be in format DD-MMM-YYYY.
   std::vector<string16> date_parts;
-  base::SplitString(columns[1], '-', &date_parts);
+  base::SplitString(columns[2], '-', &date_parts);
   if (date_parts.size() != 3)
     return false;
   if (!base::StringToInt(date_parts[0], &time_exploded.day_of_month))
     return false;
   if (!net::FtpUtil::ThreeLetterMonthToNumber(date_parts[1],
                                               &time_exploded.month))
     return false;
   if (!base::StringToInt(date_parts[2], &time_exploded.year))
     return false;
 
   // Time can be in format HH:MM, HH:MM:SS, or HH:MM:SS.mm. Try to recognize the
   // last type first. Do not parse the seconds, they will be ignored anyway.
-  string16 time_column(columns[2]);
+  string16 time_column(columns[3]);
   if (time_column.length() == 11 && time_column[8] == '.')
     time_column = time_column.substr(0, 8);
   if (time_column.length() == 8 && time_column[5] == ':')
     time_column = time_column.substr(0, 5);
   if (time_column.length() != 5)
     return false;
   std::vector<string16> time_parts;
   base::SplitString(time_column, ':', &time_parts);
   if (time_parts.size() != 2)
     return false;
   if (!base::StringToInt(time_parts[0], &time_exploded.hour))
     return false;
   if (!base::StringToInt(time_parts[1], &time_exploded.minute))
     return false;
 
   // We don't know the time zone of the server, so just use local time.
   *time = base::Time::FromLocalExploded(time_exploded);
   return true;
 }
 
 }  // namespace
 
 namespace net {

[eroman, 2011/03/24 23:09:35]

nit: i suggest moving this up, so the anonymous namespace is also enclosed
within net (avoids having to prefix the types with net::)

[Paweł Hajdan Jr., 2011/03/26 09:47:50]

Done.

 
-FtpDirectoryListingParserVms::FtpDirectoryListingParserVms()
-    : state_(STATE_INITIAL),
-      last_is_directory_(false) {
-}
+bool ParseFtpDirectoryListingVms(
+    const std::vector<string16>& lines,
+    std::vector<FtpDirectoryListingEntry>* entries) {
+  // The first non-empty line is the listing header. It often
+  // starts with "Directory ", but not always. We set a flag after
+  // seing the header.
+  bool seen_header = false;
 
-FtpDirectoryListingParserVms::~FtpDirectoryListingParserVms() {}
+  for (size_t i = 0; i < lines.size(); i++) {
+    if (lines[i].empty())
+      continue;
 
-FtpServerType FtpDirectoryListingParserVms::GetServerType() const {
-  return SERVER_VMS;
-}
+    if (StartsWith(lines[i], ASCIIToUTF16("Total of "), true)) {
+      // After the "total" line, all following lines must be empty.
+      for (size_t j = i + 1; j < lines.size(); j++)
+        if (!lines[j].empty())
+          return false;
 
-bool FtpDirectoryListingParserVms::ConsumeLine(const string16& line) {
-  switch (state_) {
-    case STATE_INITIAL:
-      DCHECK(last_filename_.empty());
-      if (line.empty())
-        return true;
-      if (StartsWith(line, ASCIIToUTF16("Total of "), true)) {
-        state_ = STATE_END;
-        return true;
-      }
-      // We assume that the first non-empty line is the listing header. It often
-      // starts with "Directory ", but not always.
-      state_ = STATE_RECEIVED_HEADER;
       return true;
-    case STATE_RECEIVED_HEADER:
-      DCHECK(last_filename_.empty());
-      if (line.empty())
-        return true;
-      state_ = STATE_ENTRIES;
-      return ConsumeEntryLine(line);
-    case STATE_ENTRIES:
-      if (line.empty()) {
-        if (!last_filename_.empty())
-          return false;
-        state_ = STATE_RECEIVED_LAST_ENTRY;
-        return true;
-      }
-      return ConsumeEntryLine(line);
-    case STATE_RECEIVED_LAST_ENTRY:
-      DCHECK(last_filename_.empty());
-      if (line.empty())
-        return true;
-      if (!StartsWith(line, ASCIIToUTF16("Total of "), true))
+    }
+
+    if (!seen_header) {
+      seen_header = true;
+      continue;
+    }
+
+    if (LooksLikePermissionDeniedError(lines[i]))
+      continue;
+
+    std::vector<string16> columns;
+    base::SplitString(CollapseWhitespace(lines[i], false), ' ', &columns);
+
+    if (columns.size() == 1) {
+      // There can be no continuation if the current line is the last one.
+      if (i == lines.size() - 1)
         return false;
-      state_ = STATE_END;
-      return true;
-    case STATE_END:
-      DCHECK(last_filename_.empty());
+
+      // Join the current and next line and split them into columns.
+      columns.clear();
+      base::SplitString(
+          CollapseWhitespace(lines[i] + ASCIIToUTF16(" ") + lines[i + 1],
+                             false),
+          ' ',
+          &columns);
+      i++;
+    }
+
+    FtpDirectoryListingEntry entry;
+    if (!ParseVmsFilename(columns[0], &entry.name, &entry.type))
       return false;
-    default:
-      NOTREACHED();
+
+    // There are different variants of a VMS listing. Some display
+    // the protection listing and user identification code, some do not.
+    if (columns.size() == 6) {
+      if (!LooksLikeVmsFileProtectionListing(columns[5]))
+        return false;
+      if (!LooksLikeVmsUserIdentificationCode(columns[4]))
+        return false;
+
+      // Drop the unneeded data, so that the following code can always expect
+      // just four columns.
+      columns.resize(4);
+    }
+
+    if (columns.size() != 4)
       return false;
-  }
-}
 
-bool FtpDirectoryListingParserVms::OnEndOfInput() {
-  return (state_ == STATE_END);
-}
+    if (!ParseVmsFilesize(columns[1], &entry.size))
+      return false;
+    if (entry.size < 0)
+      return false;
+    if (entry.type != FtpDirectoryListingEntry::FILE)
+      entry.size = -1;
+    if (!VmsDateListingToTime(columns, &entry.last_modified))
+      return false;
 
-bool FtpDirectoryListingParserVms::EntryAvailable() const {
-  return !entries_.empty();
-}
-
-FtpDirectoryListingEntry FtpDirectoryListingParserVms::PopEntry() {
-  FtpDirectoryListingEntry entry = entries_.front();
-  entries_.pop();
-  return entry;
-}
-
-bool FtpDirectoryListingParserVms::ConsumeEntryLine(const string16& line) {
-  std::vector<string16> columns;
-  base::SplitString(CollapseWhitespace(line, false), ' ', &columns);
-
-  if (columns.size() == 1) {
-    if (!last_filename_.empty())
-      return false;
-    return ParseVmsFilename(columns[0], &last_filename_, &last_is_directory_);
+    entries->push_back(entry);
   }
 
-  // Recognize listing entries which generate "access denied" message even when
-  // trying to list them. We don't display them in the final listing.
-  static const char* kAccessDeniedMessages[] = {
-    "%RMS-E-PRV",
-    "privilege",
-  };
-  for (size_t i = 0; i < arraysize(kAccessDeniedMessages); i++) {
-    if (line.find(ASCIIToUTF16(kAccessDeniedMessages[i])) != string16::npos) {
-      last_filename_.clear();
-      last_is_directory_ = false;
-      return true;
-    }
-  }
-
-  string16 filename;
-  bool is_directory = false;
-  if (last_filename_.empty()) {
-    if (!ParseVmsFilename(columns[0], &filename, &is_directory))
-      return false;
-    columns.erase(columns.begin());
-  } else {
-    filename = last_filename_;
-    is_directory = last_is_directory_;
-    last_filename_.clear();
-    last_is_directory_ = false;
-  }
-
-  if (columns.size() > 5)
-    return false;
-
-  if (columns.size() == 5) {
-    if (!LooksLikeVmsFileProtectionListing(columns[4]))
-      return false;
-    if (!LooksLikeVmsUserIdentificationCode(columns[3]))
-      return false;
-    columns.resize(3);
-  }
-
-  if (columns.size() != 3)
-    return false;
-
-  FtpDirectoryListingEntry entry;
-  entry.name = filename;
-  entry.type = is_directory ? FtpDirectoryListingEntry::DIRECTORY
-                            : FtpDirectoryListingEntry::FILE;
-  if (!ParseVmsFilesize(columns[0], &entry.size))
-    return false;
-  if (entry.size < 0)
-    return false;
-  if (entry.type != FtpDirectoryListingEntry::FILE)
-    entry.size = -1;
-  if (!VmsDateListingToTime(columns, &entry.last_modified))
-    return false;
-
-  entries_.push(entry);
-  return true;
+  // The only place where we return true is after receiving the "Total" line,
+  // that should be present in every VMS listing.
+  return false;
 }
 
 }  // namespace net