base/i18n/file_util_icu.cc

   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 // File utilities that use the ICU library go in this file.
   6
   7 #include "base/i18n/file_util_icu.h"
   8
   9 #include <stdint.h>
  10
  11 #include <memory>
  12
  13 #include "base/files/file_path.h"
  14 #include "base/i18n/icu_string_conversions.h"
  15 #include "base/i18n/string_compare.h"
  16 #include "base/logging.h"
  17 #include "base/macros.h"
  18 #include "base/memory/singleton.h"
  19 #include "base/strings/string_util.h"
  20 #include "base/strings/sys_string_conversions.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "build/build_config.h"
  23 #include "third_party/icu/source/common/unicode/uniset.h"
  24 #include "third_party/icu/source/i18n/unicode/coll.h"
  25
  26 namespace base {
  27 namespace i18n {
  28
  29 namespace {
  30
  31 class IllegalCharacters {
  32  public:
  33   static IllegalCharacters* GetInstance() {
  34     return Singleton<IllegalCharacters>::get();
  35   }
  36
  37   bool DisallowedEverywhere(UChar32 ucs4) {
  38     return !!illegal_anywhere_->contains(ucs4);
  39   }
  40
  41   bool DisallowedLeadingOrTrailing(UChar32 ucs4) {
  42     return !!illegal_at_ends_->contains(ucs4);
  43   }
  44
  45   bool IsAllowedName(const string16& s) {
  46     return s.empty() || (!!illegal_anywhere_->containsNone(
  47                              icu::UnicodeString(s.c_str(), s.size())) &&
  48                          !illegal_at_ends_->contains(*s.begin()) &&
  49                          !illegal_at_ends_->contains(*s.rbegin()));
  50   }
  51
  52  private:
  53   friend class Singleton<IllegalCharacters>;
  54   friend struct DefaultSingletonTraits<IllegalCharacters>;
  55
  56   IllegalCharacters();
  57   ~IllegalCharacters() = default;
  58
  59   // set of characters considered invalid anywhere inside a filename.
  60   std::unique_ptr<icu::UnicodeSet> illegal_anywhere_;
  61
  62   // set of characters considered invalid at either end of a filename.
  63   std::unique_ptr<icu::UnicodeSet> illegal_at_ends_;
  64
  65   DISALLOW_COPY_AND_ASSIGN(IllegalCharacters);
  66 };
  67
  68 IllegalCharacters::IllegalCharacters() {
  69   UErrorCode everywhere_status = U_ZERO_ERROR;
  70   UErrorCode ends_status = U_ZERO_ERROR;
  71   // Control characters, formatting characters, non-characters, path separators,
  72   // and some printable ASCII characters regarded as dangerous ('"*/:<>?\\').
  73   // See  http://blogs.msdn.com/michkap/archive/2006/11/03/941420.aspx
  74   // and http://msdn2.microsoft.com/en-us/library/Aa365247.aspx
  75   // Note that code points in the "Other, Format" (Cf) category are ignored on
  76   // HFS+ despite the ZERO_WIDTH_JOINER and ZERO_WIDTH_NON-JOINER being
  77   // legitimate in Arabic and some S/SE Asian scripts. In addition tilde (~) is
  78   // also excluded due to the possibility of interacting poorly with short
  79   // filenames on VFAT. (Related to CVE-2014-9390)
  80   illegal_anywhere_.reset(new icu::UnicodeSet(
  81       UNICODE_STRING_SIMPLE("[[\"~*/:<>?\\\\|][:Cc:][:Cf:]]"),
  82       everywhere_status));
  83   illegal_at_ends_.reset(new icu::UnicodeSet(
  84       UNICODE_STRING_SIMPLE("[[:WSpace:][.]]"), ends_status));
  85   DCHECK(U_SUCCESS(everywhere_status));
  86   DCHECK(U_SUCCESS(ends_status));
  87
  88   // Add non-characters. If this becomes a performance bottleneck by
  89   // any chance, do not add these to |set| and change IsFilenameLegal()
  90   // to check |ucs4 & 0xFFFEu == 0xFFFEu|, in addiition to calling
  91   // IsAllowedName().
  92   illegal_anywhere_->add(0xFDD0, 0xFDEF);
  93   for (int i = 0; i <= 0x10; ++i) {
  94     int plane_base = 0x10000 * i;
  95     illegal_anywhere_->add(plane_base + 0xFFFE, plane_base + 0xFFFF);
  96   }
  97   illegal_anywhere_->freeze();
  98   illegal_at_ends_->freeze();
  99 }
 100
 101 }  // namespace
 102
 103 bool IsFilenameLegal(const string16& file_name) {
 104   return IllegalCharacters::GetInstance()->IsAllowedName(file_name);
 105 }
 106
 107 void ReplaceIllegalCharactersInPath(FilePath::StringType* file_name,
 108                                     char replace_char) {
 109   IllegalCharacters* illegal = IllegalCharacters::GetInstance();
 110
 111   DCHECK(!(illegal->DisallowedEverywhere(replace_char)));
 112   DCHECK(!(illegal->DisallowedLeadingOrTrailing(replace_char)));
 113
 114   int cursor = 0;  // The ICU macros expect an int.
 115   while (cursor < static_cast<int>(file_name->size())) {
 116     int char_begin = cursor;
 117     uint32_t code_point;
 118 #if defined(OS_WIN)
 119     // Windows uses UTF-16 encoding for filenames.
 120     U16_NEXT(file_name->data(), cursor, static_cast<int>(file_name->length()),
 121              code_point);
 122 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
 123     // Mac and Chrome OS use UTF-8 encoding for filenames.
 124     // Linux doesn't actually define file system encoding. Try to parse as
 125     // UTF-8.
 126     U8_NEXT(file_name->data(), cursor, static_cast<int>(file_name->length()),
 127             code_point);
 128 #else
 129 #error Unsupported platform
 130 #endif
 131
 132     if (illegal->DisallowedEverywhere(code_point) ||
 133         ((char_begin == 0 || cursor == static_cast<int>(file_name->length())) &&
 134          illegal->DisallowedLeadingOrTrailing(code_point))) {
 135       file_name->replace(char_begin, cursor - char_begin, 1, replace_char);
 136       // We just made the potentially multi-byte/word char into one that only
 137       // takes one byte/word, so need to adjust the cursor to point to the next
 138       // character again.
 139       cursor = char_begin + 1;
 140     }
 141   }
 142 }
 143
 144 bool LocaleAwareCompareFilenames(const FilePath& a, const FilePath& b) {
 145   UErrorCode error_code = U_ZERO_ERROR;
 146   // Use the default collator. The default locale should have been properly
 147   // set by the time this constructor is called.
 148   std::unique_ptr<icu::Collator> collator(
 149       icu::Collator::createInstance(error_code));
 150   DCHECK(U_SUCCESS(error_code));
 151   // Make it case-sensitive.
 152   collator->setStrength(icu::Collator::TERTIARY);
 153
 154 #if defined(OS_WIN)
 155   return CompareString16WithCollator(*collator, WideToUTF16(a.value()),
 156                                      WideToUTF16(b.value())) == UCOL_LESS;
 157
 158 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
 159   // On linux, the file system encoding is not defined. We assume
 160   // SysNativeMBToWide takes care of it.
 161   return CompareString16WithCollator(
 162              *collator, WideToUTF16(SysNativeMBToWide(a.value())),
 163              WideToUTF16(SysNativeMBToWide(b.value()))) == UCOL_LESS;
 164 #endif
 165 }
 166
 167 void NormalizeFileNameEncoding(FilePath* file_name) {
 168 #if defined(OS_CHROMEOS)
 169   std::string normalized_str;
 170   if (ConvertToUtf8AndNormalize(file_name->BaseName().value(), kCodepageUTF8,
 171                                 &normalized_str) &&
 172       !normalized_str.empty()) {
 173     *file_name = file_name->DirName().Append(FilePath(normalized_str));
 174   }
 175 #endif
 176 }
 177
 178 }  // namespace i18n
 179 }  // namespace base