| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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_util.h" | |
| 6 | |
| 7 #include <map> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/i18n/case_conversion.h" | |
| 11 #include "base/i18n/char_iterator.h" | |
| 12 #include "base/logging.h" | |
| 13 #include "base/memory/singleton.h" | |
| 14 #include "base/strings/string_number_conversions.h" | |
| 15 #include "base/strings/string_piece.h" | |
| 16 #include "base/strings/string_split.h" | |
| 17 #include "base/strings/string_tokenizer.h" | |
| 18 #include "base/strings/string_util.h" | |
| 19 #include "base/strings/utf_string_conversions.h" | |
| 20 #include "base/time/time.h" | |
| 21 #include "third_party/icu/source/common/unicode/uchar.h" | |
| 22 #include "third_party/icu/source/i18n/unicode/datefmt.h" | |
| 23 #include "third_party/icu/source/i18n/unicode/dtfmtsym.h" | |
| 24 | |
| 25 using base::ASCIIToUTF16; | |
| 26 using base::StringPiece16; | |
| 27 | |
| 28 // For examples of Unix<->VMS path conversions, see the unit test file. On VMS | |
| 29 // a path looks differently depending on whether it's a file or directory. | |
| 30 | |
| 31 namespace net { | |
| 32 | |
| 33 // static | |
| 34 std::string FtpUtil::UnixFilePathToVMS(const std::string& unix_path) { | |
| 35 if (unix_path.empty()) | |
| 36 return std::string(); | |
| 37 | |
| 38 base::StringTokenizer tokenizer(unix_path, "/"); | |
| 39 std::vector<std::string> tokens; | |
| 40 while (tokenizer.GetNext()) | |
| 41 tokens.push_back(tokenizer.token()); | |
| 42 | |
| 43 if (unix_path[0] == '/') { | |
| 44 // It's an absolute path. | |
| 45 | |
| 46 if (tokens.empty()) { | |
| 47 DCHECK_EQ(1U, unix_path.length()); | |
| 48 return "[]"; | |
| 49 } | |
| 50 | |
| 51 if (tokens.size() == 1) | |
| 52 return unix_path.substr(1); // Drop the leading slash. | |
| 53 | |
| 54 std::string result(tokens[0] + ":["); | |
| 55 if (tokens.size() == 2) { | |
| 56 // Don't ask why, it just works that way on VMS. | |
| 57 result.append("000000"); | |
| 58 } else { | |
| 59 result.append(tokens[1]); | |
| 60 for (size_t i = 2; i < tokens.size() - 1; i++) | |
| 61 result.append("." + tokens[i]); | |
| 62 } | |
| 63 result.append("]" + tokens[tokens.size() - 1]); | |
| 64 return result; | |
| 65 } | |
| 66 | |
| 67 if (tokens.size() == 1) | |
| 68 return unix_path; | |
| 69 | |
| 70 std::string result("["); | |
| 71 for (size_t i = 0; i < tokens.size() - 1; i++) | |
| 72 result.append("." + tokens[i]); | |
| 73 result.append("]" + tokens[tokens.size() - 1]); | |
| 74 return result; | |
| 75 } | |
| 76 | |
| 77 // static | |
| 78 std::string FtpUtil::UnixDirectoryPathToVMS(const std::string& unix_path) { | |
| 79 if (unix_path.empty()) | |
| 80 return std::string(); | |
| 81 | |
| 82 std::string path(unix_path); | |
| 83 | |
| 84 if (path[path.length() - 1] != '/') | |
| 85 path.append("/"); | |
| 86 | |
| 87 // Reuse logic from UnixFilePathToVMS by appending a fake file name to the | |
| 88 // real path and removing it after conversion. | |
| 89 path.append("x"); | |
| 90 path = UnixFilePathToVMS(path); | |
| 91 return path.substr(0, path.length() - 1); | |
| 92 } | |
| 93 | |
| 94 // static | |
| 95 std::string FtpUtil::VMSPathToUnix(const std::string& vms_path) { | |
| 96 if (vms_path.empty()) | |
| 97 return "."; | |
| 98 | |
| 99 if (vms_path[0] == '/') { | |
| 100 // This is not really a VMS path. Most likely the server is emulating UNIX. | |
| 101 // Return path as-is. | |
| 102 return vms_path; | |
| 103 } | |
| 104 | |
| 105 if (vms_path == "[]") | |
| 106 return "/"; | |
| 107 | |
| 108 std::string result(vms_path); | |
| 109 if (vms_path[0] == '[') { | |
| 110 // It's a relative path. | |
| 111 ReplaceFirstSubstringAfterOffset(&result, 0, "[.", std::string()); | |
| 112 } else { | |
| 113 // It's an absolute path. | |
| 114 result.insert(0, "/"); | |
| 115 ReplaceSubstringsAfterOffset(&result, 0, ":[000000]", "/"); | |
| 116 ReplaceSubstringsAfterOffset(&result, 0, ":[", "/"); | |
| 117 } | |
| 118 std::replace(result.begin(), result.end(), '.', '/'); | |
| 119 std::replace(result.begin(), result.end(), ']', '/'); | |
| 120 | |
| 121 // Make sure the result doesn't end with a slash. | |
| 122 if (result.length() && result[result.length() - 1] == '/') | |
| 123 result = result.substr(0, result.length() - 1); | |
| 124 | |
| 125 return result; | |
| 126 } | |
| 127 | |
| 128 namespace { | |
| 129 | |
| 130 // Lazy-initialized map of abbreviated month names. | |
| 131 class AbbreviatedMonthsMap { | |
| 132 public: | |
| 133 static AbbreviatedMonthsMap* GetInstance() { | |
| 134 return Singleton<AbbreviatedMonthsMap>::get(); | |
| 135 } | |
| 136 | |
| 137 // Converts abbreviated month name |text| to its number (in range 1-12). | |
| 138 // On success returns true and puts the number in |number|. | |
| 139 bool GetMonthNumber(const base::string16& text, int* number) { | |
| 140 // Ignore the case of the month names. The simplest way to handle that | |
| 141 // is to make everything lowercase. | |
| 142 base::string16 text_lower(base::i18n::ToLower(text)); | |
| 143 | |
| 144 if (map_.find(text_lower) == map_.end()) | |
| 145 return false; | |
| 146 | |
| 147 *number = map_[text_lower]; | |
| 148 return true; | |
| 149 } | |
| 150 | |
| 151 private: | |
| 152 friend struct DefaultSingletonTraits<AbbreviatedMonthsMap>; | |
| 153 | |
| 154 // Constructor, initializes the map based on ICU data. It is much faster | |
| 155 // to do that just once. | |
| 156 AbbreviatedMonthsMap() { | |
| 157 int32_t locales_count; | |
| 158 const icu::Locale* locales = | |
| 159 icu::DateFormat::getAvailableLocales(locales_count); | |
| 160 | |
| 161 for (int32_t locale = 0; locale < locales_count; locale++) { | |
| 162 UErrorCode status(U_ZERO_ERROR); | |
| 163 | |
| 164 icu::DateFormatSymbols format_symbols(locales[locale], status); | |
| 165 | |
| 166 // If we cannot get format symbols for some locale, it's not a fatal | |
| 167 // error. Just try another one. | |
| 168 if (U_FAILURE(status)) | |
| 169 continue; | |
| 170 | |
| 171 int32_t months_count; | |
| 172 const icu::UnicodeString* months = | |
| 173 format_symbols.getShortMonths(months_count); | |
| 174 | |
| 175 for (int32_t month = 0; month < months_count; month++) { | |
| 176 base::string16 month_name(months[month].getBuffer(), | |
| 177 static_cast<size_t>(months[month].length())); | |
| 178 | |
| 179 // Ignore the case of the month names. The simplest way to handle that | |
| 180 // is to make everything lowercase. | |
| 181 month_name = base::i18n::ToLower(month_name); | |
| 182 | |
| 183 map_[month_name] = month + 1; | |
| 184 | |
| 185 // Sometimes ICU returns longer strings, but in FTP listings a shorter | |
| 186 // abbreviation is used (for example for the Russian locale). Make sure | |
| 187 // we always have a map entry for a three-letter abbreviation. | |
| 188 map_[month_name.substr(0, 3)] = month + 1; | |
| 189 } | |
| 190 } | |
| 191 | |
| 192 // Fail loudly if the data returned by ICU is obviously incomplete. | |
| 193 // This is intended to catch cases like http://crbug.com/177428 | |
| 194 // much earlier. Note that the issue above turned out to be non-trivial | |
| 195 // to reproduce - crash data is much better indicator of a problem | |
| 196 // than incomplete bug reports. | |
| 197 CHECK_EQ(1, map_[ASCIIToUTF16("jan")]); | |
| 198 CHECK_EQ(2, map_[ASCIIToUTF16("feb")]); | |
| 199 CHECK_EQ(3, map_[ASCIIToUTF16("mar")]); | |
| 200 CHECK_EQ(4, map_[ASCIIToUTF16("apr")]); | |
| 201 CHECK_EQ(5, map_[ASCIIToUTF16("may")]); | |
| 202 CHECK_EQ(6, map_[ASCIIToUTF16("jun")]); | |
| 203 CHECK_EQ(7, map_[ASCIIToUTF16("jul")]); | |
| 204 CHECK_EQ(8, map_[ASCIIToUTF16("aug")]); | |
| 205 CHECK_EQ(9, map_[ASCIIToUTF16("sep")]); | |
| 206 CHECK_EQ(10, map_[ASCIIToUTF16("oct")]); | |
| 207 CHECK_EQ(11, map_[ASCIIToUTF16("nov")]); | |
| 208 CHECK_EQ(12, map_[ASCIIToUTF16("dec")]); | |
| 209 } | |
| 210 | |
| 211 // Maps lowercase month names to numbers in range 1-12. | |
| 212 std::map<base::string16, int> map_; | |
| 213 | |
| 214 DISALLOW_COPY_AND_ASSIGN(AbbreviatedMonthsMap); | |
| 215 }; | |
| 216 | |
| 217 } // namespace | |
| 218 | |
| 219 // static | |
| 220 bool FtpUtil::AbbreviatedMonthToNumber(const base::string16& text, | |
| 221 int* number) { | |
| 222 return AbbreviatedMonthsMap::GetInstance()->GetMonthNumber(text, number); | |
| 223 } | |
| 224 | |
| 225 // static | |
| 226 bool FtpUtil::LsDateListingToTime(const base::string16& month, | |
| 227 const base::string16& day, | |
| 228 const base::string16& rest, | |
| 229 const base::Time& current_time, | |
| 230 base::Time* result) { | |
| 231 base::Time::Exploded time_exploded = { 0 }; | |
| 232 | |
| 233 if (!AbbreviatedMonthToNumber(month, &time_exploded.month)) { | |
| 234 // Work around garbage sent by some servers in the same column | |
| 235 // as the month. Take just last 3 characters of the string. | |
| 236 if (month.length() < 3 || | |
| 237 !AbbreviatedMonthToNumber(month.substr(month.length() - 3), | |
| 238 &time_exploded.month)) { | |
| 239 return false; | |
| 240 } | |
| 241 } | |
| 242 | |
| 243 if (!base::StringToInt(day, &time_exploded.day_of_month)) | |
| 244 return false; | |
| 245 if (time_exploded.day_of_month > 31) | |
| 246 return false; | |
| 247 | |
| 248 if (!base::StringToInt(rest, &time_exploded.year)) { | |
| 249 // Maybe it's time. Does it look like time? Note that it can be any of | |
| 250 // "HH:MM", "H:MM", "HH:M" or maybe even "H:M". | |
| 251 if (rest.length() > 5) | |
| 252 return false; | |
| 253 | |
| 254 size_t colon_pos = rest.find(':'); | |
| 255 if (colon_pos == base::string16::npos) | |
| 256 return false; | |
| 257 if (colon_pos > 2) | |
| 258 return false; | |
| 259 | |
| 260 if (!base::StringToInt( | |
| 261 StringPiece16(rest.begin(), rest.begin() + colon_pos), | |
| 262 &time_exploded.hour)) { | |
| 263 return false; | |
| 264 } | |
| 265 if (!base::StringToInt( | |
| 266 StringPiece16(rest.begin() + colon_pos + 1, rest.end()), | |
| 267 &time_exploded.minute)) { | |
| 268 return false; | |
| 269 } | |
| 270 | |
| 271 // Guess the year. | |
| 272 base::Time::Exploded current_exploded; | |
| 273 current_time.LocalExplode(¤t_exploded); | |
| 274 | |
| 275 // If it's not possible for the parsed date to be in the current year, | |
| 276 // use the previous year. | |
| 277 if (time_exploded.month > current_exploded.month || | |
| 278 (time_exploded.month == current_exploded.month && | |
| 279 time_exploded.day_of_month > current_exploded.day_of_month)) { | |
| 280 time_exploded.year = current_exploded.year - 1; | |
| 281 } else { | |
| 282 time_exploded.year = current_exploded.year; | |
| 283 } | |
| 284 } | |
| 285 | |
| 286 // We don't know the time zone of the listing, so just use local time. | |
| 287 *result = base::Time::FromLocalExploded(time_exploded); | |
| 288 return true; | |
| 289 } | |
| 290 | |
| 291 // static | |
| 292 bool FtpUtil::WindowsDateListingToTime(const base::string16& date, | |
| 293 const base::string16& time, | |
| 294 base::Time* result) { | |
| 295 base::Time::Exploded time_exploded = { 0 }; | |
| 296 | |
| 297 // Date should be in format MM-DD-YY[YY]. | |
| 298 std::vector<base::string16> date_parts; | |
| 299 base::SplitString(date, '-', &date_parts); | |
| 300 if (date_parts.size() != 3) | |
| 301 return false; | |
| 302 if (!base::StringToInt(date_parts[0], &time_exploded.month)) | |
| 303 return false; | |
| 304 if (!base::StringToInt(date_parts[1], &time_exploded.day_of_month)) | |
| 305 return false; | |
| 306 if (!base::StringToInt(date_parts[2], &time_exploded.year)) | |
| 307 return false; | |
| 308 if (time_exploded.year < 0) | |
| 309 return false; | |
| 310 // If year has only two digits then assume that 00-79 is 2000-2079, | |
| 311 // and 80-99 is 1980-1999. | |
| 312 if (time_exploded.year < 80) | |
| 313 time_exploded.year += 2000; | |
| 314 else if (time_exploded.year < 100) | |
| 315 time_exploded.year += 1900; | |
| 316 | |
| 317 // Time should be in format HH:MM[(AM|PM)] | |
| 318 if (time.length() < 5) | |
| 319 return false; | |
| 320 | |
| 321 std::vector<base::string16> time_parts; | |
| 322 base::SplitString(time.substr(0, 5), ':', &time_parts); | |
| 323 if (time_parts.size() != 2) | |
| 324 return false; | |
| 325 if (!base::StringToInt(time_parts[0], &time_exploded.hour)) | |
| 326 return false; | |
| 327 if (!base::StringToInt(time_parts[1], &time_exploded.minute)) | |
| 328 return false; | |
| 329 if (!time_exploded.HasValidValues()) | |
| 330 return false; | |
| 331 | |
| 332 if (time.length() > 5) { | |
| 333 if (time.length() != 7) | |
| 334 return false; | |
| 335 base::string16 am_or_pm(time.substr(5, 2)); | |
| 336 if (EqualsASCII(am_or_pm, "PM")) { | |
| 337 if (time_exploded.hour < 12) | |
| 338 time_exploded.hour += 12; | |
| 339 } else if (EqualsASCII(am_or_pm, "AM")) { | |
| 340 if (time_exploded.hour == 12) | |
| 341 time_exploded.hour = 0; | |
| 342 } else { | |
| 343 return false; | |
| 344 } | |
| 345 } | |
| 346 | |
| 347 // We don't know the time zone of the server, so just use local time. | |
| 348 *result = base::Time::FromLocalExploded(time_exploded); | |
| 349 return true; | |
| 350 } | |
| 351 | |
| 352 // static | |
| 353 base::string16 FtpUtil::GetStringPartAfterColumns(const base::string16& text, | |
| 354 int columns) { | |
| 355 base::i18n::UTF16CharIterator iter(&text); | |
| 356 | |
| 357 // TODO(jshin): Is u_isspace the right function to use here? | |
| 358 for (int i = 0; i < columns; i++) { | |
| 359 // Skip the leading whitespace. | |
| 360 while (!iter.end() && u_isspace(iter.get())) | |
| 361 iter.Advance(); | |
| 362 | |
| 363 // Skip the actual text of i-th column. | |
| 364 while (!iter.end() && !u_isspace(iter.get())) | |
| 365 iter.Advance(); | |
| 366 } | |
| 367 | |
| 368 base::string16 result(text.substr(iter.array_pos())); | |
| 369 base::TrimWhitespace(result, base::TRIM_ALL, &result); | |
| 370 return result; | |
| 371 } | |
| 372 | |
| 373 } // namespace | |
| 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