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 "ui/base/resource/data_pack.h" 6 7 #include <errno.h> 8 9 #include "base/files/file_util.h" 10 #include "base/files/memory_mapped_file.h" 11 #include "base/logging.h" 12 #include "base/memory/ref_counted_memory.h" 13 #include "base/metrics/histogram.h" 14 #include "base/strings/string_piece.h" 15 16 // For details of the file layout, see 17 // http://dev.chromium.org/developers/design-documents/linuxresourcesandlocalizedstrings 18 19 namespace { 20 21 static const uint32 kFileFormatVersion = 4; 22 // Length of file header: version, entry count and text encoding type. 23 static const size_t kHeaderLength = 2 * sizeof(uint32) + sizeof(uint8); 24 25 #pragma pack(push,2) 26 struct DataPackEntry { 27 uint16 resource_id; 28 uint32 file_offset; 29 30 static int CompareById(const void* void_key, const void* void_entry) { 31 uint16 key = *reinterpret_cast<const uint16*>(void_key); 32 const DataPackEntry* entry = 33 reinterpret_cast<const DataPackEntry*>(void_entry); 34 if (key < entry->resource_id) { 35 return -1; 36 } else if (key > entry->resource_id) { 37 return 1; 38 } else { 39 return 0; 40 } 41 } 42 }; 43 #pragma pack(pop) 44 45 COMPILE_ASSERT(sizeof(DataPackEntry) == 6, size_of_entry_must_be_six); 46 47 // We're crashing when trying to load a pak file on Windows. Add some error 48 // codes for logging. 49 // http://crbug.com/58056 50 enum LoadErrors { 51 INIT_FAILED = 1, 52 BAD_VERSION, 53 INDEX_TRUNCATED, 54 ENTRY_NOT_FOUND, 55 HEADER_TRUNCATED, 56 WRONG_ENCODING, 57 INIT_FAILED_FROM_FILE, 58 59 LOAD_ERRORS_COUNT, 60 }; 61 62 } // namespace 63 64 namespace ui { 65 66 DataPack::DataPack(ui::ScaleFactor scale_factor) 67 : resource_count_(0), 68 text_encoding_type_(BINARY), 69 scale_factor_(scale_factor) { 70 } 71 72 DataPack::~DataPack() { 73 } 74 75 bool DataPack::LoadFromPath(const base::FilePath& path) { 76 mmap_.reset(new base::MemoryMappedFile); 77 if (!mmap_->Initialize(path)) { 78 DLOG(ERROR) << "Failed to mmap datapack"; 79 UMA_HISTOGRAM_ENUMERATION("DataPack.Load", INIT_FAILED, 80 LOAD_ERRORS_COUNT); 81 mmap_.reset(); 82 return false; 83 } 84 return LoadImpl(); 85 } 86 87 bool DataPack::LoadFromFile(base::File file) { 88 return LoadFromFileRegion(file.Pass(), 89 base::MemoryMappedFile::Region::kWholeFile); 90 } 91 92 bool DataPack::LoadFromFileRegion( 93 base::File file, 94 const base::MemoryMappedFile::Region& region) { 95 mmap_.reset(new base::MemoryMappedFile); 96 if (!mmap_->Initialize(file.Pass(), region)) { 97 DLOG(ERROR) << "Failed to mmap datapack"; 98 UMA_HISTOGRAM_ENUMERATION("DataPack.Load", INIT_FAILED_FROM_FILE, 99 LOAD_ERRORS_COUNT); 100 mmap_.reset(); 101 return false; 102 } 103 return LoadImpl(); 104 } 105 106 bool DataPack::LoadImpl() { 107 // Sanity check the header of the file. 108 if (kHeaderLength > mmap_->length()) { 109 DLOG(ERROR) << "Data pack file corruption: incomplete file header."; 110 UMA_HISTOGRAM_ENUMERATION("DataPack.Load", HEADER_TRUNCATED, 111 LOAD_ERRORS_COUNT); 112 mmap_.reset(); 113 return false; 114 } 115 116 // Parse the header of the file. 117 // First uint32: version; second: resource count; 118 const uint32* ptr = reinterpret_cast<const uint32*>(mmap_->data()); 119 uint32 version = ptr[0]; 120 if (version != kFileFormatVersion) { 121 LOG(ERROR) << "Bad data pack version: got " << version << ", expected " 122 << kFileFormatVersion; 123 UMA_HISTOGRAM_ENUMERATION("DataPack.Load", BAD_VERSION, 124 LOAD_ERRORS_COUNT); 125 mmap_.reset(); 126 return false; 127 } 128 resource_count_ = ptr[1]; 129 130 // third: text encoding. 131 const uint8* ptr_encoding = reinterpret_cast<const uint8*>(ptr + 2); 132 text_encoding_type_ = static_cast<TextEncodingType>(*ptr_encoding); 133 if (text_encoding_type_ != UTF8 && text_encoding_type_ != UTF16 && 134 text_encoding_type_ != BINARY) { 135 LOG(ERROR) << "Bad data pack text encoding: got " << text_encoding_type_ 136 << ", expected between " << BINARY << " and " << UTF16; 137 UMA_HISTOGRAM_ENUMERATION("DataPack.Load", WRONG_ENCODING, 138 LOAD_ERRORS_COUNT); 139 mmap_.reset(); 140 return false; 141 } 142 143 // Sanity check the file. 144 // 1) Check we have enough entries. There's an extra entry after the last item 145 // which gives the length of the last item. 146 if (kHeaderLength + (resource_count_ + 1) * sizeof(DataPackEntry) > 147 mmap_->length()) { 148 LOG(ERROR) << "Data pack file corruption: too short for number of " 149 "entries specified."; 150 UMA_HISTOGRAM_ENUMERATION("DataPack.Load", INDEX_TRUNCATED, 151 LOAD_ERRORS_COUNT); 152 mmap_.reset(); 153 return false; 154 } 155 // 2) Verify the entries are within the appropriate bounds. There's an extra 156 // entry after the last item which gives us the length of the last item. 157 for (size_t i = 0; i < resource_count_ + 1; ++i) { 158 const DataPackEntry* entry = reinterpret_cast<const DataPackEntry*>( 159 mmap_->data() + kHeaderLength + (i * sizeof(DataPackEntry))); 160 if (entry->file_offset > mmap_->length()) { 161 LOG(ERROR) << "Entry #" << i << " in data pack points off end of file. " 162 << "Was the file corrupted?"; 163 UMA_HISTOGRAM_ENUMERATION("DataPack.Load", ENTRY_NOT_FOUND, 164 LOAD_ERRORS_COUNT); 165 mmap_.reset(); 166 return false; 167 } 168 } 169 170 return true; 171 } 172 173 bool DataPack::HasResource(uint16 resource_id) const { 174 return !!bsearch(&resource_id, mmap_->data() + kHeaderLength, resource_count_, 175 sizeof(DataPackEntry), DataPackEntry::CompareById); 176 } 177 178 bool DataPack::GetStringPiece(uint16 resource_id, 179 base::StringPiece* data) const { 180 // It won't be hard to make this endian-agnostic, but it's not worth 181 // bothering to do right now. 182 #if defined(__BYTE_ORDER) 183 // Linux check 184 COMPILE_ASSERT(__BYTE_ORDER == __LITTLE_ENDIAN, 185 datapack_assumes_little_endian); 186 #elif defined(__BIG_ENDIAN__) 187 // Mac check 188 #error DataPack assumes little endian 189 #endif 190 191 const DataPackEntry* target = reinterpret_cast<const DataPackEntry*>( 192 bsearch(&resource_id, mmap_->data() + kHeaderLength, resource_count_, 193 sizeof(DataPackEntry), DataPackEntry::CompareById)); 194 if (!target) { 195 return false; 196 } 197 198 const DataPackEntry* next_entry = target + 1; 199 // If the next entry points beyond the end of the file this data pack's entry 200 // table is corrupt. Log an error and return false. See 201 // http://crbug.com/371301. 202 if (next_entry->file_offset > mmap_->length()) { 203 size_t entry_index = target - 204 reinterpret_cast<const DataPackEntry*>(mmap_->data() + kHeaderLength); 205 LOG(ERROR) << "Entry #" << entry_index << " in data pack points off end " 206 << "of file. This should have been caught when loading. Was the " 207 << "file modified?"; 208 return false; 209 } 210 211 size_t length = next_entry->file_offset - target->file_offset; 212 data->set(reinterpret_cast<const char*>(mmap_->data() + target->file_offset), 213 length); 214 return true; 215 } 216 217 base::RefCountedStaticMemory* DataPack::GetStaticMemory( 218 uint16 resource_id) const { 219 base::StringPiece piece; 220 if (!GetStringPiece(resource_id, &piece)) 221 return NULL; 222 223 return new base::RefCountedStaticMemory(piece.data(), piece.length()); 224 } 225 226 ResourceHandle::TextEncodingType DataPack::GetTextEncodingType() const { 227 return text_encoding_type_; 228 } 229 230 ui::ScaleFactor DataPack::GetScaleFactor() const { 231 return scale_factor_; 232 } 233 234 // static 235 bool DataPack::WritePack(const base::FilePath& path, 236 const std::map<uint16, base::StringPiece>& resources, 237 TextEncodingType textEncodingType) { 238 FILE* file = base::OpenFile(path, "wb"); 239 if (!file) 240 return false; 241 242 if (fwrite(&kFileFormatVersion, sizeof(kFileFormatVersion), 1, file) != 1) { 243 LOG(ERROR) << "Failed to write file version"; 244 base::CloseFile(file); 245 return false; 246 } 247 248 // Note: the python version of this function explicitly sorted keys, but 249 // std::map is a sorted associative container, we shouldn't have to do that. 250 uint32 entry_count = resources.size(); 251 if (fwrite(&entry_count, sizeof(entry_count), 1, file) != 1) { 252 LOG(ERROR) << "Failed to write entry count"; 253 base::CloseFile(file); 254 return false; 255 } 256 257 if (textEncodingType != UTF8 && textEncodingType != UTF16 && 258 textEncodingType != BINARY) { 259 LOG(ERROR) << "Invalid text encoding type, got " << textEncodingType 260 << ", expected between " << BINARY << " and " << UTF16; 261 base::CloseFile(file); 262 return false; 263 } 264 265 uint8 write_buffer = textEncodingType; 266 if (fwrite(&write_buffer, sizeof(uint8), 1, file) != 1) { 267 LOG(ERROR) << "Failed to write file text resources encoding"; 268 base::CloseFile(file); 269 return false; 270 } 271 272 // Each entry is a uint16 + a uint32. We have an extra entry after the last 273 // item so we can compute the size of the list item. 274 uint32 index_length = (entry_count + 1) * sizeof(DataPackEntry); 275 uint32 data_offset = kHeaderLength + index_length; 276 for (std::map<uint16, base::StringPiece>::const_iterator it = 277 resources.begin(); 278 it != resources.end(); ++it) { 279 uint16 resource_id = it->first; 280 if (fwrite(&resource_id, sizeof(resource_id), 1, file) != 1) { 281 LOG(ERROR) << "Failed to write id for " << resource_id; 282 base::CloseFile(file); 283 return false; 284 } 285 286 if (fwrite(&data_offset, sizeof(data_offset), 1, file) != 1) { 287 LOG(ERROR) << "Failed to write offset for " << resource_id; 288 base::CloseFile(file); 289 return false; 290 } 291 292 data_offset += it->second.length(); 293 } 294 295 // We place an extra entry after the last item that allows us to read the 296 // size of the last item. 297 uint16 resource_id = 0; 298 if (fwrite(&resource_id, sizeof(resource_id), 1, file) != 1) { 299 LOG(ERROR) << "Failed to write extra resource id."; 300 base::CloseFile(file); 301 return false; 302 } 303 304 if (fwrite(&data_offset, sizeof(data_offset), 1, file) != 1) { 305 LOG(ERROR) << "Failed to write extra offset."; 306 base::CloseFile(file); 307 return false; 308 } 309 310 for (std::map<uint16, base::StringPiece>::const_iterator it = 311 resources.begin(); 312 it != resources.end(); ++it) { 313 if (fwrite(it->second.data(), it->second.length(), 1, file) != 1) { 314 LOG(ERROR) << "Failed to write data for " << it->first; 315 base::CloseFile(file); 316 return false; 317 } 318 } 319 320 base::CloseFile(file); 321 322 return true; 323 } 324 325 } // namespace ui 326
