| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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/app_installer/win/app_installer_util.h" | |
| 6 | |
| 7 #include <windows.h> | |
| 8 #include <urlmon.h> | |
| 9 #include <winhttp.h> | |
| 10 #pragma comment(lib, "urlmon.lib") | |
| 11 #pragma comment(lib, "winhttp.lib") | |
| 12 | |
| 13 #include "base/base_paths.h" | |
| 14 #include "base/basictypes.h" | |
| 15 #include "base/command_line.h" | |
| 16 #include "base/files/file_util.h" | |
| 17 #include "base/json/json_string_value_serializer.h" | |
| 18 #include "base/logging.h" | |
| 19 #include "base/memory/scoped_ptr.h" | |
| 20 #include "base/path_service.h" | |
| 21 #include "base/process/launch.h" | |
| 22 #include "base/strings/string16.h" | |
| 23 #include "base/strings/string_split.h" | |
| 24 #include "base/strings/string_util.h" | |
| 25 #include "base/strings/stringprintf.h" | |
| 26 #include "base/strings/sys_string_conversions.h" | |
| 27 #include "base/values.h" | |
| 28 #include "base/win/scoped_handle.h" | |
| 29 #include "chrome/common/chrome_switches.h" | |
| 30 #include "chrome/installer/launcher_support/chrome_launcher_support.h" | |
| 31 #include "chrome/installer/util/google_update_util.h" | |
| 32 #include "chrome/installer/util/html_dialog.h" | |
| 33 #include "chrome/installer/util/master_preferences_constants.h" | |
| 34 #include "chrome/installer/util/util_constants.h" | |
| 35 #include "net/base/escape.h" | |
| 36 #include "third_party/omaha/src/omaha/base/extractor.h" | |
| 37 | |
| 38 namespace app_installer { | |
| 39 | |
| 40 const char kInstallChromeApp[] = "install-chrome-app"; | |
| 41 | |
| 42 namespace { | |
| 43 | |
| 44 // Copied from google_chrome_distribution.cc. | |
| 45 const char kBrowserAppGuid[] = "{8A69D345-D564-463c-AFF1-A69D9E530F96}"; | |
| 46 | |
| 47 // Copied frome google_chrome_sxs_distribution.cc. | |
| 48 const char kSxSBrowserAppGuid[] = "{4ea16ac7-fd5a-47c3-875b-dbf4a2008c20}"; | |
| 49 | |
| 50 const int kMaxTagLength = 4096; | |
| 51 | |
| 52 const wchar_t kDownloadAndEulaPage[] = | |
| 53 L"https://tools.google.com/dlpage/chromeappinstaller"; | |
| 54 | |
| 55 const wchar_t kSxSDownloadAndEulaPage[] = | |
| 56 L"https://tools.google.com/dlpage/chromeappinstaller?sxs=true"; | |
| 57 | |
| 58 const wchar_t kDialogDimensions[] = L"dialogWidth:750px;dialogHeight:500px"; | |
| 59 | |
| 60 // This uses HTMLDialog to show a Chrome download page as a modal dialog. | |
| 61 // The page includes the EULA and returns a download URL. | |
| 62 class DownloadAndEulaHTMLDialog { | |
| 63 public: | |
| 64 explicit DownloadAndEulaHTMLDialog(bool is_canary, | |
| 65 const std::string& dialog_arguments) { | |
| 66 dialog_.reset(installer::CreateNativeHTMLDialog( | |
| 67 is_canary ? kSxSDownloadAndEulaPage : kDownloadAndEulaPage, | |
| 68 base::SysUTF8ToWide(dialog_arguments))); | |
| 69 } | |
| 70 ~DownloadAndEulaHTMLDialog() {} | |
| 71 | |
| 72 // Shows the dialog and blocks for user input. Returns the string passed back | |
| 73 // by the web page via |window.returnValue|. | |
| 74 base::string16 ShowModal() { | |
| 75 Customizer customizer; | |
| 76 dialog_->ShowModal(NULL, &customizer); | |
| 77 return dialog_->GetExtraResult(); | |
| 78 } | |
| 79 | |
| 80 private: | |
| 81 class Customizer : public installer::HTMLDialog::CustomizationCallback { | |
| 82 public: | |
| 83 void OnBeforeCreation(wchar_t** extra) override { | |
| 84 *extra = const_cast<wchar_t*>(kDialogDimensions); | |
| 85 } | |
| 86 | |
| 87 void OnBeforeDisplay(void* window) override { | |
| 88 // Customize the window by removing the close button and replacing the | |
| 89 // existing 'e' icon with the standard informational icon. | |
| 90 if (!window) | |
| 91 return; | |
| 92 HWND top_window = static_cast<HWND>(window); | |
| 93 LONG_PTR style = GetWindowLongPtrW(top_window, GWL_STYLE); | |
| 94 SetWindowLongPtrW(top_window, GWL_STYLE, style & ~WS_SYSMENU); | |
| 95 HICON ico = LoadIcon(NULL, IDI_INFORMATION); | |
| 96 SendMessageW( | |
| 97 top_window, WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>(ico)); | |
| 98 } | |
| 99 }; | |
| 100 | |
| 101 scoped_ptr<installer::HTMLDialog> dialog_; | |
| 102 DISALLOW_COPY_AND_ASSIGN(DownloadAndEulaHTMLDialog); | |
| 103 }; | |
| 104 | |
| 105 bool IsStringPrintable(const std::string& s) { | |
| 106 return std::find_if_not(s.begin(), s.end(), isprint) == s.end(); | |
| 107 } | |
| 108 | |
| 109 bool IsLegalDataKeyChar(int c) { | |
| 110 return isalnum(c) || c == '-' || c == '_' || c == '$'; | |
| 111 } | |
| 112 | |
| 113 bool IsDataKeyValid(const std::string& key) { | |
| 114 return std::find_if_not(key.begin(), key.end(), IsLegalDataKeyChar) == | |
| 115 key.end(); | |
| 116 } | |
| 117 | |
| 118 struct WinHttpHandleTraits { | |
| 119 typedef HINTERNET Handle; | |
| 120 static bool CloseHandle(Handle handle) { | |
| 121 return WinHttpCloseHandle(handle) != FALSE; | |
| 122 } | |
| 123 static bool IsHandleValid(Handle handle) { return !!handle; } | |
| 124 static Handle NullHandle() { return 0; } | |
| 125 | |
| 126 private: | |
| 127 DISALLOW_IMPLICIT_CONSTRUCTORS(WinHttpHandleTraits); | |
| 128 }; | |
| 129 typedef base::win::GenericScopedHandle<WinHttpHandleTraits, | |
| 130 base::win::DummyVerifierTraits> | |
| 131 ScopedWinHttpHandle; | |
| 132 | |
| 133 // Reads the data portion of an HTTP response. WinHttpReceiveResponse() must | |
| 134 // have already succeeded on this request. | |
| 135 bool ReadHttpData(HINTERNET request_handle, | |
| 136 std::vector<uint8_t>* response_data) { | |
| 137 BOOL result = TRUE; | |
| 138 do { | |
| 139 // Check for available data. | |
| 140 DWORD bytes_available = 0; | |
| 141 result = WinHttpQueryDataAvailable(request_handle, &bytes_available); | |
| 142 if (!result) { | |
| 143 PLOG(ERROR); | |
| 144 break; | |
| 145 } | |
| 146 | |
| 147 if (bytes_available == 0) | |
| 148 break; | |
| 149 | |
| 150 do { | |
| 151 // Allocate space for the buffer. | |
| 152 size_t offset = response_data->size(); | |
| 153 response_data->resize(offset + bytes_available); | |
| 154 | |
| 155 // Read the data. | |
| 156 DWORD bytes_read = 0; | |
| 157 result = WinHttpReadData(request_handle, &((*response_data)[offset]), | |
| 158 bytes_available, &bytes_read); | |
| 159 // MSDN for WinHttpQueryDataAvailable says: | |
| 160 // The amount of data that remains is not recalculated until all | |
| 161 // available data indicated by the call to WinHttpQueryDataAvailable is | |
| 162 // read. | |
| 163 // So we should either read all of |bytes_available| or bail out here. | |
| 164 if (!result) { | |
| 165 PLOG(ERROR); | |
| 166 response_data->resize(offset); | |
| 167 return false; | |
| 168 } | |
| 169 | |
| 170 // MSDN for WinHttpReadData says: | |
| 171 // If you are using WinHttpReadData synchronously, and the return value | |
| 172 // is TRUE and the number of bytes read is zero, the transfer has been | |
| 173 // completed and there are no more bytes to read on the handle. | |
| 174 // Not sure if that's possible while |bytes_available| > 0, but better to | |
| 175 // check and break out of both loops in this case. | |
| 176 if (!bytes_read) { | |
| 177 response_data->resize(offset); | |
| 178 return true; | |
| 179 } | |
| 180 | |
| 181 response_data->resize(offset + bytes_read); | |
| 182 bytes_available -= bytes_read; | |
| 183 } while (bytes_available); | |
| 184 } while (true); | |
| 185 | |
| 186 return result != FALSE; | |
| 187 } | |
| 188 | |
| 189 } // namespace | |
| 190 | |
| 191 // Gets the tag attached to a file by dl.google.com. This uses the same format | |
| 192 // as Omaha. Returns the empty string on failure. | |
| 193 std::string GetTag(const base::FilePath& file_name_path) { | |
| 194 base::string16 file_name = file_name_path.value(); | |
| 195 omaha::TagExtractor extractor; | |
| 196 if (!extractor.OpenFile(file_name.c_str())) | |
| 197 return std::string(); | |
| 198 | |
| 199 int tag_buffer_size = 0; | |
| 200 if (!extractor.ExtractTag(NULL, &tag_buffer_size) || tag_buffer_size <= 1) | |
| 201 return std::string(); | |
| 202 | |
| 203 if (tag_buffer_size - 1 > kMaxTagLength) { | |
| 204 LOG(ERROR) << "Tag length (" << tag_buffer_size - 1 << ") exceeds maximum (" | |
| 205 << kMaxTagLength << ")."; | |
| 206 return std::string(); | |
| 207 } | |
| 208 | |
| 209 scoped_ptr<char[]> tag_buffer(new char[tag_buffer_size]); | |
| 210 extractor.ExtractTag(tag_buffer.get(), &tag_buffer_size); | |
| 211 | |
| 212 return std::string(tag_buffer.get(), tag_buffer_size - 1); | |
| 213 } | |
| 214 | |
| 215 // Parses |tag| as key-value pairs and overwrites |parsed_pairs| with | |
| 216 // the result. |tag| should be a '&'-delimited list of '='-separated | |
| 217 // key-value pairs, e.g. "key1=value1&key2=value2". | |
| 218 // Returns true if the data could be parsed. | |
| 219 bool ParseTag(const std::string& tag, | |
| 220 std::map<std::string, std::string>* parsed_pairs) { | |
| 221 DCHECK(parsed_pairs); | |
| 222 | |
| 223 base::StringPairs kv_pairs; | |
| 224 if (!base::SplitStringIntoKeyValuePairs(tag, '=', '&', &kv_pairs)) { | |
| 225 LOG(ERROR) << "Failed to parse tag: " << tag; | |
| 226 return false; | |
| 227 } | |
| 228 | |
| 229 parsed_pairs->clear(); | |
| 230 for (const auto& pair : kv_pairs) { | |
| 231 const std::string& key(pair.first); | |
| 232 const std::string& value(pair.second); | |
| 233 if (IsDataKeyValid(key) && IsStringPrintable(value)) { | |
| 234 (*parsed_pairs)[key] = value; | |
| 235 } else { | |
| 236 LOG(ERROR) << "Illegal character found in tag."; | |
| 237 return false; | |
| 238 } | |
| 239 } | |
| 240 return true; | |
| 241 } | |
| 242 | |
| 243 bool IsValidAppId(const std::string& app_id) { | |
| 244 if (app_id.size() != 32) | |
| 245 return false; | |
| 246 | |
| 247 for (size_t i = 0; i < app_id.size(); ++i) { | |
| 248 char c = base::ToLowerASCII(app_id[i]); | |
| 249 if (c < 'a' || c > 'p') | |
| 250 return false; | |
| 251 } | |
| 252 | |
| 253 return true; | |
| 254 } | |
| 255 | |
| 256 bool FetchUrl(const base::string16& user_agent, | |
| 257 const base::string16& server_name, | |
| 258 uint16_t server_port, | |
| 259 const base::string16& object_name, | |
| 260 std::vector<uint8_t>* response_data) { | |
| 261 DCHECK(response_data); | |
| 262 | |
| 263 ScopedWinHttpHandle session_handle( | |
| 264 WinHttpOpen(user_agent.c_str(), WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, | |
| 265 WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0)); | |
| 266 if (!session_handle.IsValid()) { | |
| 267 PLOG(ERROR); | |
| 268 return false; | |
| 269 } | |
| 270 | |
| 271 ScopedWinHttpHandle connection_handle(WinHttpConnect( | |
| 272 session_handle.Get(), server_name.c_str(), server_port, 0)); | |
| 273 if (!connection_handle.IsValid()) { | |
| 274 PLOG(ERROR); | |
| 275 return false; | |
| 276 } | |
| 277 | |
| 278 ScopedWinHttpHandle request_handle(WinHttpOpenRequest( | |
| 279 connection_handle.Get(), L"GET", object_name.c_str(), NULL, | |
| 280 WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE)); | |
| 281 if (!request_handle.IsValid()) { | |
| 282 PLOG(ERROR); | |
| 283 return false; | |
| 284 } | |
| 285 | |
| 286 if (!WinHttpSendRequest(request_handle.Get(), WINHTTP_NO_ADDITIONAL_HEADERS, | |
| 287 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0)) { | |
| 288 PLOG(ERROR); | |
| 289 return false; | |
| 290 } | |
| 291 | |
| 292 if (!WinHttpReceiveResponse(request_handle.Get(), NULL)) { | |
| 293 PLOG(ERROR); | |
| 294 return false; | |
| 295 } | |
| 296 | |
| 297 response_data->clear(); | |
| 298 return ReadHttpData(request_handle.Get(), response_data); | |
| 299 } | |
| 300 | |
| 301 ExitCode GetChrome(bool is_canary, const std::string& inline_install_json) { | |
| 302 // Show UI to install Chrome. The UI returns a download URL. | |
| 303 base::string16 download_url = | |
| 304 DownloadAndEulaHTMLDialog(is_canary, inline_install_json).ShowModal(); | |
| 305 if (download_url.empty()) | |
| 306 return EULA_CANCELLED; | |
| 307 | |
| 308 DVLOG(1) << "Chrome download url: " << download_url; | |
| 309 | |
| 310 // Get a temporary file path. | |
| 311 base::FilePath setup_file; | |
| 312 if (!base::CreateTemporaryFile(&setup_file)) | |
| 313 return COULD_NOT_GET_TMP_FILE_PATH; | |
| 314 | |
| 315 // Download the Chrome installer. | |
| 316 HRESULT hr = URLDownloadToFile( | |
| 317 NULL, download_url.c_str(), setup_file.value().c_str(), 0, NULL); | |
| 318 if (FAILED(hr)) { | |
| 319 LOG(ERROR) << "Download failed: Error " << std::hex << hr << ". " | |
| 320 << setup_file.value(); | |
| 321 return FAILED_TO_DOWNLOAD_CHROME_SETUP; | |
| 322 } | |
| 323 | |
| 324 // Construct the command line to pass to the installer so that it will not | |
| 325 // launch Chrome upon completion. | |
| 326 base::DictionaryValue installerdata_dict; | |
| 327 base::DictionaryValue* distribution = new base::DictionaryValue(); | |
| 328 installerdata_dict.Set("distribution", distribution); | |
| 329 distribution->SetBoolean( | |
| 330 installer::master_preferences::kCreateAllShortcuts, false); | |
| 331 distribution->SetBoolean( | |
| 332 installer::master_preferences::kDoNotCreateDesktopShortcut, true); | |
| 333 distribution->SetBoolean( | |
| 334 installer::master_preferences::kDoNotCreateQuickLaunchShortcut, true); | |
| 335 distribution->SetBoolean( | |
| 336 installer::master_preferences::kDoNotCreateTaskbarShortcut, true); | |
| 337 distribution->SetBoolean( | |
| 338 installer::master_preferences::kDoNotLaunchChrome, true); | |
| 339 distribution->SetBoolean( | |
| 340 installer::master_preferences::kDoNotRegisterForUpdateLaunch, true); | |
| 341 distribution->SetBoolean( | |
| 342 installer::master_preferences::kDistroImportHistoryPref, false); | |
| 343 distribution->SetBoolean( | |
| 344 installer::master_preferences::kDistroImportSearchPref, false); | |
| 345 distribution->SetBoolean( | |
| 346 installer::master_preferences::kMakeChromeDefault, false); | |
| 347 distribution->SetBoolean( | |
| 348 installer::master_preferences::kSuppressFirstRunDefaultBrowserPrompt, | |
| 349 true); | |
| 350 std::string installerdata; | |
| 351 JSONStringValueSerializer serializer(&installerdata); | |
| 352 bool serialize_success = serializer.Serialize(installerdata_dict); | |
| 353 DCHECK(serialize_success); | |
| 354 std::string installerdata_url_encoded = | |
| 355 net::EscapeQueryParamValue(installerdata, false); | |
| 356 std::string appargs = | |
| 357 base::StringPrintf("appguid=%s&installerdata=%s", | |
| 358 is_canary ? kSxSBrowserAppGuid : kBrowserAppGuid, | |
| 359 installerdata_url_encoded.c_str()); | |
| 360 base::CommandLine command_line(setup_file); | |
| 361 command_line.AppendArg("/appargs"); | |
| 362 command_line.AppendArg(appargs); | |
| 363 command_line.AppendArg("/install"); // Must be last. | |
| 364 | |
| 365 DVLOG(1) << "Chrome installer command line: " | |
| 366 << command_line.GetCommandLineString(); | |
| 367 | |
| 368 // Install Chrome. Wait for the installer to finish before returning. | |
| 369 base::LaunchOptions options; | |
| 370 options.wait = true; | |
| 371 bool launch_success = base::LaunchProcess(command_line, options).IsValid(); | |
| 372 base::DeleteFile(setup_file, false); | |
| 373 return launch_success ? SUCCESS : FAILED_TO_LAUNCH_CHROME_SETUP; | |
| 374 } | |
| 375 | |
| 376 } // namespace app_installer | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1132873009:
Remove app_installer code. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master