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 "chrome/common/importer/firefox_importer_utils.h" 6 7 #include <algorithm> 8 #include <map> 9 #include <string> 10 11 #include "base/file_util.h" 12 #include "base/ini_parser.h" 13 #include "base/logging.h" 14 #include "base/strings/string_number_conversions.h" 15 #include "base/strings/string_split.h" 16 #include "base/strings/string_util.h" 17 #include "base/strings/stringprintf.h" 18 #include "base/strings/utf_string_conversions.h" 19 #include "base/values.h" 20 #include "grit/generated_resources.h" 21 #include "ui/base/l10n/l10n_util.h" 22 #include "url/gurl.h" 23 24 namespace { 25 26 // Retrieves the file system path of the profile name. 27 base::FilePath GetProfilePath(const base::DictionaryValue& root, 28 const std::string& profile_name) { 29 base::string16 path16; 30 std::string is_relative; 31 if (!root.GetStringASCII(profile_name + ".IsRelative", &is_relative) || 32 !root.GetString(profile_name + ".Path", &path16)) 33 return base::FilePath(); 34 35 #if defined(OS_WIN) 36 ReplaceSubstringsAfterOffset( 37 &path16, 0, base::ASCIIToUTF16("/"), base::ASCIIToUTF16("\\")); 38 #endif 39 base::FilePath path = base::FilePath::FromUTF16Unsafe(path16); 40 41 // IsRelative=1 means the folder path would be relative to the 42 // path of profiles.ini. IsRelative=0 refers to a custom profile 43 // location. 44 if (is_relative == "1") 45 path = GetProfilesINI().DirName().Append(path); 46 47 return path; 48 } 49 50 // Checks if the named profile is the default profile. 51 bool IsDefaultProfile(const base::DictionaryValue& root, 52 const std::string& profile_name) { 53 std::string is_default; 54 root.GetStringASCII(profile_name + ".Default", &is_default); 55 return is_default == "1"; 56 } 57 58 } // namespace 59 60 base::FilePath GetFirefoxProfilePath() { 61 base::FilePath ini_file = GetProfilesINI(); 62 std::string content; 63 base::ReadFileToString(ini_file, &content); 64 base::DictionaryValueINIParser ini_parser; 65 ini_parser.Parse(content); 66 return GetFirefoxProfilePathFromDictionary(ini_parser.root()); 67 } 68 69 base::FilePath GetFirefoxProfilePathFromDictionary( 70 const base::DictionaryValue& root) { 71 std::vector<std::string> profiles; 72 for (int i = 0; ; ++i) { 73 std::string current_profile = base::StringPrintf("Profile%d", i); 74 if (root.HasKey(current_profile)) { 75 profiles.push_back(current_profile); 76 } else { 77 // Profiles are continuously numbered. So we exit when we can't 78 // find the i-th one. 79 break; 80 } 81 } 82 83 if (profiles.empty()) 84 return base::FilePath(); 85 86 // When multiple profiles exist, the path to the default profile is returned, 87 // since the other profiles are used mostly by developers for testing. 88 for (std::vector<std::string>::const_iterator it = profiles.begin(); 89 it != profiles.end(); ++it) 90 if (IsDefaultProfile(root, *it)) 91 return GetProfilePath(root, *it); 92 93 // If no default profile is found, the path to Profile0 will be returned. 94 return GetProfilePath(root, profiles.front()); 95 } 96 97 #if defined(OS_MACOSX) 98 // Find the "*.app" component of the path and build up from there. 99 // The resulting path will be .../Firefox.app/Contents/MacOS. 100 // We do this because we don't trust LastAppDir to always be 101 // this particular path, without any subdirs, and we want to make 102 // our assumption about Firefox's root being in that path explicit. 103 bool ComposeMacAppPath(const std::string& path_from_file, 104 base::FilePath* output) { 105 base::FilePath path(path_from_file); 106 typedef std::vector<base::FilePath::StringType> ComponentVector; 107 ComponentVector path_components; 108 path.GetComponents(&path_components); 109 if (path_components.empty()) 110 return false; 111 // The first path component is special because it may be absolute. Calling 112 // Append with an absolute path component will trigger an assert, so we 113 // must handle it differently and initialize output with it. 114 *output = base::FilePath(path_components[0]); 115 // Append next path components untill we find the *.app component. When we do, 116 // append Contents/MacOS. 117 for (size_t i = 1; i < path_components.size(); ++i) { 118 *output = output->Append(path_components[i]); 119 if (EndsWith(path_components[i], ".app", true)) { 120 *output = output->Append("Contents"); 121 *output = output->Append("MacOS"); 122 return true; 123 } 124 } 125 LOG(ERROR) << path_from_file << " doesn't look like a valid Firefox " 126 << "installation path: missing /*.app/ directory."; 127 return false; 128 } 129 #endif // OS_MACOSX 130 131 bool GetFirefoxVersionAndPathFromProfile(const base::FilePath& profile_path, 132 int* version, 133 base::FilePath* app_path) { 134 bool ret = false; 135 base::FilePath compatibility_file = 136 profile_path.AppendASCII("compatibility.ini"); 137 std::string content; 138 base::ReadFileToString(compatibility_file, &content); 139 ReplaceSubstringsAfterOffset(&content, 0, "\r\n", "\n"); 140 std::vector<std::string> lines; 141 base::SplitString(content, '\n', &lines); 142 143 for (size_t i = 0; i < lines.size(); ++i) { 144 const std::string& line = lines[i]; 145 if (line.empty() || line[0] == '#' || line[0] == ';') 146 continue; 147 size_t equal = line.find('='); 148 if (equal != std::string::npos) { 149 std::string key = line.substr(0, equal); 150 if (key == "LastVersion") { 151 base::StringToInt(line.substr(equal + 1), version); 152 ret = true; 153 } else if (key == "LastAppDir") { 154 // TODO(evanm): If the path in question isn't convertible to 155 // UTF-8, what does Firefox do? If it puts raw bytes in the 156 // file, we could go straight from bytes -> filepath; 157 // otherwise, we're out of luck here. 158 #if defined(OS_MACOSX) 159 // Extract path from "LastAppDir=/actual/path" 160 size_t separator_pos = line.find_first_of('='); 161 const std::string& path_from_ini = line.substr(separator_pos + 1); 162 if (!ComposeMacAppPath(path_from_ini, app_path)) 163 return false; 164 #else // !OS_MACOSX 165 *app_path = base::FilePath::FromUTF8Unsafe(line.substr(equal + 1)); 166 #endif // OS_MACOSX 167 } 168 } 169 } 170 return ret; 171 } 172 173 bool ReadPrefFile(const base::FilePath& path, std::string* content) { 174 if (content == NULL) 175 return false; 176 177 base::ReadFileToString(path, content); 178 179 if (content->empty()) { 180 LOG(WARNING) << "Firefox preference file " << path.value() << " is empty."; 181 return false; 182 } 183 184 return true; 185 } 186 187 std::string ReadBrowserConfigProp(const base::FilePath& app_path, 188 const std::string& pref_key) { 189 std::string content; 190 if (!ReadPrefFile(app_path.AppendASCII("browserconfig.properties"), &content)) 191 return std::string(); 192 193 // This file has the syntax: key=value. 194 size_t prop_index = content.find(pref_key + "="); 195 if (prop_index == std::string::npos) 196 return std::string(); 197 198 size_t start = prop_index + pref_key.length(); 199 size_t stop = std::string::npos; 200 if (start != std::string::npos) 201 stop = content.find("\n", start + 1); 202 203 if (start == std::string::npos || 204 stop == std::string::npos || (start == stop)) { 205 LOG(WARNING) << "Firefox property " << pref_key << " could not be parsed."; 206 return std::string(); 207 } 208 209 return content.substr(start + 1, stop - start - 1); 210 } 211 212 std::string ReadPrefsJsValue(const base::FilePath& profile_path, 213 const std::string& pref_key) { 214 std::string content; 215 if (!ReadPrefFile(profile_path.AppendASCII("prefs.js"), &content)) 216 return std::string(); 217 218 return GetPrefsJsValue(content, pref_key); 219 } 220 221 GURL GetHomepage(const base::FilePath& profile_path) { 222 std::string home_page_list = 223 ReadPrefsJsValue(profile_path, "browser.startup.homepage"); 224 225 size_t seperator = home_page_list.find_first_of('|'); 226 if (seperator == std::string::npos) 227 return GURL(home_page_list); 228 229 return GURL(home_page_list.substr(0, seperator)); 230 } 231 232 bool IsDefaultHomepage(const GURL& homepage, const base::FilePath& app_path) { 233 if (!homepage.is_valid()) 234 return false; 235 236 std::string default_homepages = 237 ReadBrowserConfigProp(app_path, "browser.startup.homepage"); 238 239 size_t seperator = default_homepages.find_first_of('|'); 240 if (seperator == std::string::npos) 241 return homepage.spec() == GURL(default_homepages).spec(); 242 243 // Crack the string into separate homepage urls. 244 std::vector<std::string> urls; 245 base::SplitString(default_homepages, '|', &urls); 246 247 for (size_t i = 0; i < urls.size(); ++i) { 248 if (homepage.spec() == GURL(urls[i]).spec()) 249 return true; 250 } 251 252 return false; 253 } 254 255 std::string GetPrefsJsValue(const std::string& content, 256 const std::string& pref_key) { 257 // This file has the syntax: user_pref("key", value); 258 std::string search_for = std::string("user_pref(\"") + pref_key + 259 std::string("\", "); 260 size_t prop_index = content.find(search_for); 261 if (prop_index == std::string::npos) 262 return std::string(); 263 264 size_t start = prop_index + search_for.length(); 265 size_t stop = std::string::npos; 266 if (start != std::string::npos) { 267 // Stop at the last ')' on this line. 268 stop = content.find("\n", start + 1); 269 stop = content.rfind(")", stop); 270 } 271 272 if (start == std::string::npos || stop == std::string::npos || 273 stop < start) { 274 LOG(WARNING) << "Firefox property " << pref_key << " could not be parsed."; 275 return std::string(); 276 } 277 278 // String values have double quotes we don't need to return to the caller. 279 if (content[start] == '\"' && content[stop - 1] == '\"') { 280 ++start; 281 --stop; 282 } 283 284 return content.substr(start, stop - start); 285 } 286 287 // The branding name is obtained from the application.ini file from the Firefox 288 // application directory. A sample application.ini file is the following: 289 // [App] 290 // Vendor=Mozilla 291 // Name=Iceweasel 292 // Profile=mozilla/firefox 293 // Version=3.5.16 294 // BuildID=20120421070307 295 // Copyright=Copyright (c) 1998 - 2010 mozilla.org 296 // ID={ec8030f7-c20a-464f-9b0e-13a3a9e97384} 297 // ......................................... 298 // In this example the function returns "Iceweasel" (or a localized equivalent). 299 base::string16 GetFirefoxImporterName(const base::FilePath& app_path) { 300 const base::FilePath app_ini_file = app_path.AppendASCII("application.ini"); 301 std::string branding_name; 302 if (base::PathExists(app_ini_file)) { 303 std::string content; 304 base::ReadFileToString(app_ini_file, &content); 305 std::vector<std::string> lines; 306 base::SplitString(content, '\n', &lines); 307 const std::string name_attr("Name="); 308 bool in_app_section = false; 309 for (size_t i = 0; i < lines.size(); ++i) { 310 base::TrimWhitespace(lines[i], base::TRIM_ALL, &lines[i]); 311 if (lines[i] == "[App]") { 312 in_app_section = true; 313 } else if (in_app_section) { 314 if (lines[i].find(name_attr) == 0) { 315 branding_name = lines[i].substr(name_attr.size()); 316 break; 317 } else if (lines[i].length() > 0 && lines[i][0] == '[') { 318 // No longer in the [App] section. 319 break; 320 } 321 } 322 } 323 } 324 325 StringToLowerASCII(&branding_name); 326 if (branding_name.find("iceweasel") != std::string::npos) 327 return l10n_util::GetStringUTF16(IDS_IMPORT_FROM_ICEWEASEL); 328 return l10n_util::GetStringUTF16(IDS_IMPORT_FROM_FIREFOX); 329 } 330
