| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/ftp/ftp_directory_listing_parser_vms.h" | |
| 6 | |
| 7 #include <vector> | |
| 8 | |
| 9 #include "base/strings/string_number_conversions.h" | |
| 10 #include "base/strings/string_split.h" | |
| 11 #include "base/strings/string_util.h" | |
| 12 #include "base/strings/utf_string_conversions.h" | |
| 13 #include "base/time/time.h" | |
| 14 #include "net/ftp/ftp_directory_listing_parser.h" | |
| 15 #include "net/ftp/ftp_util.h" | |
| 16 | |
| 17 namespace net { | |
| 18 | |
| 19 namespace { | |
| 20 | |
| 21 // Converts the filename component in listing to the filename we can display. | |
| 22 // Returns true on success. | |
| 23 bool ParseVmsFilename(const base::string16& raw_filename, | |
| 24 base::string16* parsed_filename, | |
| 25 FtpDirectoryListingEntry::Type* type) { | |
| 26 // On VMS, the files and directories are versioned. The version number is | |
| 27 // separated from the file name by a semicolon. Example: ANNOUNCE.TXT;2. | |
| 28 std::vector<base::string16> listing_parts; | |
| 29 base::SplitString(raw_filename, ';', &listing_parts); | |
| 30 if (listing_parts.size() != 2) | |
| 31 return false; | |
| 32 int version_number; | |
| 33 if (!base::StringToInt(listing_parts[1], &version_number)) | |
| 34 return false; | |
| 35 if (version_number < 0) | |
| 36 return false; | |
| 37 | |
| 38 // Even directories have extensions in the listings. Don't display extensions | |
| 39 // for directories; it's awkward for non-VMS users. Also, VMS is | |
| 40 // case-insensitive, but generally uses uppercase characters. This may look | |
| 41 // awkward, so we convert them to lower case. | |
| 42 std::vector<base::string16> filename_parts; | |
| 43 base::SplitString(listing_parts[0], '.', &filename_parts); | |
| 44 if (filename_parts.size() != 2) | |
| 45 return false; | |
| 46 if (EqualsASCII(filename_parts[1], "DIR")) { | |
| 47 *parsed_filename = base::StringToLowerASCII(filename_parts[0]); | |
| 48 *type = FtpDirectoryListingEntry::DIRECTORY; | |
| 49 } else { | |
| 50 *parsed_filename = base::StringToLowerASCII(listing_parts[0]); | |
| 51 *type = FtpDirectoryListingEntry::FILE; | |
| 52 } | |
| 53 return true; | |
| 54 } | |
| 55 | |
| 56 bool ParseVmsFilesize(const base::string16& input, int64* size) { | |
| 57 if (base::ContainsOnlyChars(input, base::ASCIIToUTF16("*"))) { | |
| 58 // Response consisting of asterisks means unknown size. | |
| 59 *size = -1; | |
| 60 return true; | |
| 61 } | |
| 62 | |
| 63 // VMS's directory listing gives us file size in blocks. We assume that | |
| 64 // the block size is 512 bytes. It doesn't give accurate file size, but is the | |
| 65 // best information we have. | |
| 66 const int kBlockSize = 512; | |
| 67 | |
| 68 if (base::StringToInt64(input, size)) { | |
| 69 if (*size < 0) | |
| 70 return false; | |
| 71 *size *= kBlockSize; | |
| 72 return true; | |
| 73 } | |
| 74 | |
| 75 std::vector<base::string16> parts; | |
| 76 base::SplitString(input, '/', &parts); | |
| 77 if (parts.size() != 2) | |
| 78 return false; | |
| 79 | |
| 80 int64 blocks_used, blocks_allocated; | |
| 81 if (!base::StringToInt64(parts[0], &blocks_used)) | |
| 82 return false; | |
| 83 if (!base::StringToInt64(parts[1], &blocks_allocated)) | |
| 84 return false; | |
| 85 if (blocks_used > blocks_allocated) | |
| 86 return false; | |
| 87 if (blocks_used < 0 || blocks_allocated < 0) | |
| 88 return false; | |
| 89 | |
| 90 *size = blocks_used * kBlockSize; | |
| 91 return true; | |
| 92 } | |
| 93 | |
| 94 bool LooksLikeVmsFileProtectionListingPart(const base::string16& input) { | |
| 95 if (input.length() > 4) | |
| 96 return false; | |
| 97 | |
| 98 // On VMS there are four different permission bits: Read, Write, Execute, | |
| 99 // and Delete. They appear in that order in the permission listing. | |
| 100 std::string pattern("RWED"); | |
| 101 base::string16 match(input); | |
| 102 while (!match.empty() && !pattern.empty()) { | |
| 103 if (match[0] == pattern[0]) | |
| 104 match = match.substr(1); | |
| 105 pattern = pattern.substr(1); | |
| 106 } | |
| 107 return match.empty(); | |
| 108 } | |
| 109 | |
| 110 bool LooksLikeVmsFileProtectionListing(const base::string16& input) { | |
| 111 if (input.length() < 2) | |
| 112 return false; | |
| 113 if (input[0] != '(' || input[input.length() - 1] != ')') | |
| 114 return false; | |
| 115 | |
| 116 // We expect four parts of the file protection listing: for System, Owner, | |
| 117 // Group, and World. | |
| 118 std::vector<base::string16> parts; | |
| 119 base::SplitString(input.substr(1, input.length() - 2), ',', &parts); | |
| 120 if (parts.size() != 4) | |
| 121 return false; | |
| 122 | |
| 123 return LooksLikeVmsFileProtectionListingPart(parts[0]) && | |
| 124 LooksLikeVmsFileProtectionListingPart(parts[1]) && | |
| 125 LooksLikeVmsFileProtectionListingPart(parts[2]) && | |
| 126 LooksLikeVmsFileProtectionListingPart(parts[3]); | |
| 127 } | |
| 128 | |
| 129 bool LooksLikeVmsUserIdentificationCode(const base::string16& input) { | |
| 130 if (input.length() < 2) | |
| 131 return false; | |
| 132 return input[0] == '[' && input[input.length() - 1] == ']'; | |
| 133 } | |
| 134 | |
| 135 bool LooksLikeVMSError(const base::string16& text) { | |
| 136 static const char* const kPermissionDeniedMessages[] = { | |
| 137 "%RMS-E-FNF", // File not found. | |
| 138 "%RMS-E-PRV", // Access denied. | |
| 139 "%SYSTEM-F-NOPRIV", | |
| 140 "privilege", | |
| 141 }; | |
| 142 | |
| 143 for (size_t i = 0; i < arraysize(kPermissionDeniedMessages); i++) { | |
| 144 if (text.find(base::ASCIIToUTF16(kPermissionDeniedMessages[i])) != | |
| 145 base::string16::npos) | |
| 146 return true; | |
| 147 } | |
| 148 | |
| 149 return false; | |
| 150 } | |
| 151 | |
| 152 bool VmsDateListingToTime(const std::vector<base::string16>& columns, | |
| 153 base::Time* time) { | |
| 154 DCHECK_EQ(4U, columns.size()); | |
| 155 | |
| 156 base::Time::Exploded time_exploded = { 0 }; | |
| 157 | |
| 158 // Date should be in format DD-MMM-YYYY. | |
| 159 std::vector<base::string16> date_parts; | |
| 160 base::SplitString(columns[2], '-', &date_parts); | |
| 161 if (date_parts.size() != 3) | |
| 162 return false; | |
| 163 if (!base::StringToInt(date_parts[0], &time_exploded.day_of_month)) | |
| 164 return false; | |
| 165 if (!FtpUtil::AbbreviatedMonthToNumber(date_parts[1], | |
| 166 &time_exploded.month)) | |
| 167 return false; | |
| 168 if (!base::StringToInt(date_parts[2], &time_exploded.year)) | |
| 169 return false; | |
| 170 | |
| 171 // Time can be in format HH:MM, HH:MM:SS, or HH:MM:SS.mm. Try to recognize the | |
| 172 // last type first. Do not parse the seconds, they will be ignored anyway. | |
| 173 base::string16 time_column(columns[3]); | |
| 174 if (time_column.length() == 11 && time_column[8] == '.') | |
| 175 time_column = time_column.substr(0, 8); | |
| 176 if (time_column.length() == 8 && time_column[5] == ':') | |
| 177 time_column = time_column.substr(0, 5); | |
| 178 if (time_column.length() != 5) | |
| 179 return false; | |
| 180 std::vector<base::string16> time_parts; | |
| 181 base::SplitString(time_column, ':', &time_parts); | |
| 182 if (time_parts.size() != 2) | |
| 183 return false; | |
| 184 if (!base::StringToInt(time_parts[0], &time_exploded.hour)) | |
| 185 return false; | |
| 186 if (!base::StringToInt(time_parts[1], &time_exploded.minute)) | |
| 187 return false; | |
| 188 | |
| 189 // We don't know the time zone of the server, so just use local time. | |
| 190 *time = base::Time::FromLocalExploded(time_exploded); | |
| 191 return true; | |
| 192 } | |
| 193 | |
| 194 } // namespace | |
| 195 | |
| 196 bool ParseFtpDirectoryListingVms( | |
| 197 const std::vector<base::string16>& lines, | |
| 198 std::vector<FtpDirectoryListingEntry>* entries) { | |
| 199 // The first non-empty line is the listing header. It often | |
| 200 // starts with "Directory ", but not always. We set a flag after | |
| 201 // seing the header. | |
| 202 bool seen_header = false; | |
| 203 | |
| 204 // Sometimes the listing doesn't end with a "Total" line, but | |
| 205 // it's only okay when it contains some errors (it's needed | |
| 206 // to distinguish it from "ls -l" format). | |
| 207 bool seen_error = false; | |
| 208 | |
| 209 for (size_t i = 0; i < lines.size(); i++) { | |
| 210 if (lines[i].empty()) | |
| 211 continue; | |
| 212 | |
| 213 if (StartsWith(lines[i], base::ASCIIToUTF16("Total of "), true)) { | |
| 214 // After the "total" line, all following lines must be empty. | |
| 215 for (size_t j = i + 1; j < lines.size(); j++) | |
| 216 if (!lines[j].empty()) | |
| 217 return false; | |
| 218 | |
| 219 return true; | |
| 220 } | |
| 221 | |
| 222 if (!seen_header) { | |
| 223 seen_header = true; | |
| 224 continue; | |
| 225 } | |
| 226 | |
| 227 if (LooksLikeVMSError(lines[i])) { | |
| 228 seen_error = true; | |
| 229 continue; | |
| 230 } | |
| 231 | |
| 232 std::vector<base::string16> columns; | |
| 233 base::SplitString(base::CollapseWhitespace(lines[i], false), ' ', &columns); | |
| 234 | |
| 235 if (columns.size() == 1) { | |
| 236 // There can be no continuation if the current line is the last one. | |
| 237 if (i == lines.size() - 1) | |
| 238 return false; | |
| 239 | |
| 240 // Skip the next line. | |
| 241 i++; | |
| 242 | |
| 243 // This refers to the continuation line. | |
| 244 if (LooksLikeVMSError(lines[i])) { | |
| 245 seen_error = true; | |
| 246 continue; | |
| 247 } | |
| 248 | |
| 249 // Join the current and next line and split them into columns. | |
| 250 base::SplitString( | |
| 251 base::CollapseWhitespace( | |
| 252 lines[i - 1] + base::ASCIIToUTF16(" ") + lines[i], false), | |
| 253 ' ', | |
| 254 &columns); | |
| 255 } | |
| 256 | |
| 257 FtpDirectoryListingEntry entry; | |
| 258 if (!ParseVmsFilename(columns[0], &entry.name, &entry.type)) | |
| 259 return false; | |
| 260 | |
| 261 // There are different variants of a VMS listing. Some display | |
| 262 // the protection listing and user identification code, some do not. | |
| 263 if (columns.size() == 6) { | |
| 264 if (!LooksLikeVmsFileProtectionListing(columns[5])) | |
| 265 return false; | |
| 266 if (!LooksLikeVmsUserIdentificationCode(columns[4])) | |
| 267 return false; | |
| 268 | |
| 269 // Drop the unneeded data, so that the following code can always expect | |
| 270 // just four columns. | |
| 271 columns.resize(4); | |
| 272 } | |
| 273 | |
| 274 if (columns.size() != 4) | |
| 275 return false; | |
| 276 | |
| 277 if (!ParseVmsFilesize(columns[1], &entry.size)) | |
| 278 return false; | |
| 279 if (entry.type != FtpDirectoryListingEntry::FILE) | |
| 280 entry.size = -1; | |
| 281 if (!VmsDateListingToTime(columns, &entry.last_modified)) | |
| 282 return false; | |
| 283 | |
| 284 entries->push_back(entry); | |
| 285 } | |
| 286 | |
| 287 // The only place where we return true is after receiving the "Total" line, | |
| 288 // that should be present in every VMS listing. Alternatively, if the listing | |
| 289 // contains error messages, it's OK not to have the "Total" line. | |
| 290 return seen_error; | |
| 291 } | |
| 292 | |
| 293 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master