| // Licensed to the Software Freedom Conservancy (SFC) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The SFC licenses this file | |
| // to you under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "BrowserFactory.h" | |
| #include <ctime> | |
| #include <vector> | |
| #include <exdispid.h> | |
| #include <iepmapi.h> | |
| #include <psapi.h> | |
| #include <sddl.h> | |
| #include <shlguid.h> | |
| #include <shlobj.h> | |
| #include "logging.h" | |
| #include "FileUtilities.h" | |
| #include "RegistryUtilities.h" | |
| #include "StringUtilities.h" | |
| #include "WebDriverConstants.h" | |
| #define HTML_GETOBJECT_MSG L"WM_HTML_GETOBJECT" | |
| #define OLEACC_LIBRARY_NAME L"OLEACC.DLL" | |
| #define IEFRAME_LIBRARY_NAME L"ieframe.dll" | |
| #define IELAUNCHURL_FUNCTION_NAME "IELaunchURL" | |
| #define IE_FRAME_WINDOW_CLASS "IEFrame" | |
| #define SHELL_DOCOBJECT_VIEW_WINDOW_CLASS "Shell DocObject View" | |
| #define IE_SERVER_CHILD_WINDOW_CLASS "Internet Explorer_Server" | |
| #define ANDIE_FRAME_WINDOW_CLASS "Chrome_WidgetWin_1" | |
| #define EDGE_REGISTRY_KEY L"Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\msedge.exe" | |
| #define IE_CLSID_REGISTRY_KEY L"SOFTWARE\\Classes\\InternetExplorer.Application\\CLSID" | |
| #define IE_REDIRECT L"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Ext\\CLSID" | |
| #define IE_SECURITY_ZONES_REGISTRY_KEY L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Zones" | |
| #define IE_TABPROCGROWTH_REGISTRY_KEY L"Software\\Microsoft\\Internet Explorer\\Main" | |
| #define IE_PROTECTED_MODE_SETTING_VALUE_NAME L"2500" | |
| #define IELAUNCHURL_ERROR_MESSAGE "IELaunchURL() returned HRESULT %X ('%s') for URL '%s'" | |
| #define CREATEPROCESS_ERROR_MESSAGE "CreateProcess() failed for command line '%s'" | |
| #define CREATEPROCESS_EDGE_ERROR "CreateProcess() failed for edge with the following command: " | |
| #define NULL_PROCESS_ID_ERROR_MESSAGE " successfully launched Internet Explorer, but did not return a valid process ID." | |
| #define PROTECTED_MODE_SETTING_ERROR_MESSAGE "Protected Mode settings are not the same for all zones. Enable Protected Mode must be set to the same value (enabled or disabled) for all zones." | |
| #define ZOOM_SETTING_ERROR_MESSAGE "Browser zoom level was set to %d%%. It should be set to 100%%" | |
| #define ATTACH_TIMEOUT_ERROR_MESSAGE "Could not find an Internet Explorer window belonging to the process with ID %d within %d milliseconds." | |
| #define ATTACH_FAILURE_ERROR_MESSAGE "Found browser window using ShellWindows API, but could not attach to the browser IWebBrowser2 object." | |
| #define CREATEPROCESS_REGISTRY_ERROR_MESSAGE "Unable to use CreateProcess() API. To use CreateProcess() with Internet Explorer 8 or higher, the value of registry setting in HKEY_CURRENT_USER\\Software\\Microsoft\\Internet Explorer\\Main\\TabProcGrowth must be '0'." | |
| #define ZONE_MY_COMPUTER L"0" | |
| #define ZONE_LOCAL_INTRANET L"1" | |
| #define ZONE_TRUSTED_SITES L"2" | |
| #define ZONE_INTERNET L"3" | |
| #define ZONE_RESTRICTED_SITES L"4" | |
| #define IELAUNCHURL_API L"ielaunchurl" | |
| #define CREATEPROCESS_API L"createprocess" | |
| #define RUNDLL_EXE_NAME L"rundll32.exe" | |
| #define INTERNET_CONTROL_PANEL_APPLET_NAME L"inetcpl.cpl" | |
| #define CLEAR_CACHE_COMMAND_LINE_ARGS L"rundll32.exe %s,ClearMyTracksByProcess %u" | |
| // This magic value is the combination of the following bitflags: | |
| // #define CLEAR_HISTORY 0x0001 // Clears history | |
| // #define CLEAR_COOKIES 0x0002 // Clears cookies | |
| // #define CLEAR_CACHE 0x0004 // Clears Temporary Internet Files folder | |
| // #define CLEAR_CACHE_ALL 0x0008 // Clears offline favorites and download history | |
| // #define CLEAR_FORM_DATA 0x0010 // Clears saved form data for form auto-fill-in | |
| // #define CLEAR_PASSWORDS 0x0020 // Clears passwords saved for websites | |
| // #define CLEAR_PHISHING_FILTER 0x0040 // Clears phishing filter data | |
| // #define CLEAR_RECOVERY_DATA 0x0080 // Clears webpage recovery data | |
| // #define CLEAR_PRIVACY_ADVISOR 0x0800 // Clears tracking data | |
| // #define CLEAR_SHOW_NO_GUI 0x0100 // Do not show a GUI when running the cache clearing | |
| // | |
| // Bitflags available but not used in this magic value are as follows: | |
| // #define CLEAR_USE_NO_THREAD 0x0200 // Do not use multithreading for deletion | |
| // #define CLEAR_PRIVATE_CACHE 0x0400 // Valid only when browser is in private browsing mode | |
| // #define CLEAR_DELETE_ALL 0x1000 // Deletes data stored by add-ons | |
| // #define CLEAR_PRESERVE_FAVORITES 0x2000 // Preserves cached data for "favorite" websites | |
| #define CLEAR_CACHE_OPTIONS 0x09FF | |
| namespace webdriver { | |
| BrowserFactory::BrowserFactory(void) { | |
| // Must be done in the constructor. Do not move to Initialize(). | |
| this->GetEdgeExecutableLocation(); | |
| this->GetIEExecutableLocation(); | |
| this->GetIEVersion(); | |
| this->oleacc_instance_handle_ = NULL; | |
| this->edge_ie_mode_ = false; | |
| this->ignore_process_match_ = false; | |
| } | |
| BrowserFactory::~BrowserFactory(void) { | |
| if (this->oleacc_instance_handle_) { | |
| ::FreeLibrary(this->oleacc_instance_handle_); | |
| } | |
| } | |
| std::string BrowserFactory::initial_browser_url(void) { | |
| return StringUtilities::ToString(this->initial_browser_url_); | |
| } | |
| std::string BrowserFactory::browser_command_line_switches(void) { | |
| return StringUtilities::ToString(this->browser_command_line_switches_); | |
| } | |
| void BrowserFactory::Initialize(BrowserFactorySettings settings) { | |
| LOG(TRACE) << "Entering BrowserFactory::Initialize"; | |
| this->ignore_protected_mode_settings_ = settings.ignore_protected_mode_settings; | |
| this->browser_attach_timeout_ = settings.browser_attach_timeout; | |
| this->force_createprocess_api_ = settings.force_create_process_api; | |
| this->force_shell_windows_api_ = settings.force_shell_windows_api; | |
| this->clear_cache_ = settings.clear_cache_before_launch; | |
| this->browser_command_line_switches_ = StringUtilities::ToWString(settings.browser_command_line_switches); | |
| this->initial_browser_url_ = StringUtilities::ToWString(settings.initial_browser_url); | |
| this->edge_ie_mode_ = settings.attach_to_edge_ie || this->ie_redirects_edge_; | |
| this->ignore_process_match_ = settings.ignore_process_match; | |
| this->ignore_zoom_setting_ = settings.ignore_zoom_setting || this->edge_ie_mode_; | |
| LOG(DEBUG) << "path before was " << settings.edge_executable_path << "\n"; | |
| this->edge_executable_location_ = StringUtilities::ToWString(settings.edge_executable_path); | |
| LOG(DEBUG) << "path after was " << StringUtilities::ToString(this->edge_executable_location_) << "\n"; | |
| this->html_getobject_msg_ = ::RegisterWindowMessage(HTML_GETOBJECT_MSG); | |
| // Explicitly load MSAA so we know if it's installed | |
| this->oleacc_instance_handle_ = ::LoadLibrary(OLEACC_LIBRARY_NAME); | |
| } | |
| void BrowserFactory::ClearCache() { | |
| LOG(TRACE) << "Entering BrowserFactory::ClearCache"; | |
| if (this->clear_cache_) { | |
| if (IsWindowsVistaOrGreater()) { | |
| LOG(DEBUG) << "Clearing cache with low mandatory integrity level as required on Windows Vista or later."; | |
| this->InvokeClearCacheUtility(true); | |
| } | |
| LOG(DEBUG) << "Clearing cache with normal process execution."; | |
| this->InvokeClearCacheUtility(false); | |
| } | |
| } | |
| DWORD BrowserFactory::LaunchBrowserProcess(std::string* error_message) { | |
| LOG(TRACE) << "Entering BrowserFactory::LaunchBrowserProcess"; | |
| DWORD process_id = NULL; | |
| bool has_valid_protected_mode_settings = false; | |
| LOG(DEBUG) << "Ignoring Protected Mode Settings: " | |
| << this->ignore_protected_mode_settings_; | |
| if (!this->ignore_protected_mode_settings_) { | |
| LOG(DEBUG) << "Checking validity of Protected Mode settings."; | |
| has_valid_protected_mode_settings = this->ProtectedModeSettingsAreValid(); | |
| } | |
| LOG(DEBUG) << "Has Valid Protected Mode Settings: " | |
| << has_valid_protected_mode_settings; | |
| if (this->ignore_protected_mode_settings_ || has_valid_protected_mode_settings) { | |
| // Determine which launch API to use. | |
| bool use_createprocess_api = false; | |
| if (this->force_createprocess_api_) { | |
| if (this->IsCreateProcessApiAvailable()) { | |
| use_createprocess_api = true; | |
| } else { | |
| // The only time IsCreateProcessApiAvailable will return false | |
| // is when the user is using IE 8 or higher, and does not have | |
| // the correct registry key setting to force the same process | |
| // for the enclosing window and tab processes. | |
| *error_message = CREATEPROCESS_REGISTRY_ERROR_MESSAGE; | |
| return NULL; | |
| } | |
| } else { | |
| // If we have the IELaunchURL API, expressly use it. Otherwise, | |
| // fall back to using CreateProcess(). | |
| if (!this->IsIELaunchURLAvailable()) { | |
| use_createprocess_api = true; | |
| } | |
| } | |
| this->ClearCache(); | |
| PROCESS_INFORMATION proc_info; | |
| ::ZeroMemory(&proc_info, sizeof(proc_info)); | |
| if (this->edge_ie_mode_) { | |
| this->LaunchEdgeInIEMode(&proc_info, error_message); | |
| } else if (!use_createprocess_api) { | |
| this->LaunchBrowserUsingIELaunchURL(&proc_info, error_message); | |
| } else { | |
| this->LaunchBrowserUsingCreateProcess(&proc_info, error_message); | |
| } | |
| process_id = proc_info.dwProcessId; | |
| if (process_id == NULL) { | |
| // If whatever API we are using failed to launch the browser, we should | |
| // have a NULL value in the dwProcessId member of the PROCESS_INFORMATION | |
| // structure. In that case, we will have already set the approprate error | |
| // message. On the off chance that we haven't yet set the appropriate | |
| // error message, that means we successfully launched the browser (i.e., | |
| // the browser launch API returned a success code), but we still have a | |
| // NULL process ID. | |
| if (error_message->size() == 0) { | |
| std::string launch_api_name = use_createprocess_api ? "The CreateProcess API" : "The IELaunchURL API"; | |
| *error_message = launch_api_name + NULL_PROCESS_ID_ERROR_MESSAGE; | |
| } | |
| } else { | |
| ::WaitForInputIdle(proc_info.hProcess, 2000); | |
| std::string browser_launched = this->edge_ie_mode_ ? "Edge in IE Mode" : "IE"; | |
| LOG(DEBUG) << browser_launched << " launched successfully with process ID " << process_id; | |
| std::vector<wchar_t> image_buffer(MAX_PATH); | |
| int buffer_count = ::GetProcessImageFileName(proc_info.hProcess, &image_buffer[0], MAX_PATH); | |
| std::wstring full_image_path = &image_buffer[0]; | |
| size_t last_delimiter = full_image_path.find_last_of('\\'); | |
| std::string image_name = StringUtilities::ToString(full_image_path.substr(last_delimiter + 1, buffer_count - last_delimiter)); | |
| LOG(DEBUG) << "Process with ID " << process_id << " is executing " << image_name; | |
| } | |
| if (proc_info.hThread != NULL) { | |
| ::CloseHandle(proc_info.hThread); | |
| } | |
| if (proc_info.hProcess != NULL) { | |
| ::CloseHandle(proc_info.hProcess); | |
| } | |
| } else { | |
| *error_message = PROTECTED_MODE_SETTING_ERROR_MESSAGE; | |
| } | |
| return process_id; | |
| } | |
| bool BrowserFactory::IsIELaunchURLAvailable() { | |
| LOG(TRACE) << "Entering BrowserFactory::IsIELaunchURLAvailable"; | |
| bool api_is_available = false; | |
| HMODULE library_handle = ::LoadLibrary(IEFRAME_LIBRARY_NAME); | |
| if (library_handle != NULL) { | |
| FARPROC proc_address = 0; | |
| proc_address = ::GetProcAddress(library_handle, IELAUNCHURL_FUNCTION_NAME); | |
| if (proc_address == NULL || proc_address == 0) { | |
| LOGERR(DEBUG) << "Unable to get address of " << IELAUNCHURL_FUNCTION_NAME | |
| << " method in " << IEFRAME_LIBRARY_NAME; | |
| } else { | |
| api_is_available = true; | |
| } | |
| ::FreeLibrary(library_handle); | |
| } else { | |
| LOGERR(DEBUG) << "Unable to load library " << IEFRAME_LIBRARY_NAME; | |
| } | |
| return api_is_available; | |
| } | |
| void BrowserFactory::LaunchBrowserUsingIELaunchURL(PROCESS_INFORMATION* proc_info, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering BrowserFactory::LaunchBrowserUsingIELaunchURL"; | |
| LOG(DEBUG) << "Starting IE using the IELaunchURL API"; | |
| HRESULT launch_result = ::IELaunchURL(this->initial_browser_url_.c_str(), | |
| proc_info, | |
| NULL); | |
| if (FAILED(launch_result)) { | |
| LOGHR(WARN, launch_result) << "Error using IELaunchURL to start IE"; | |
| std::wstring hresult_msg = _com_error(launch_result).ErrorMessage(); | |
| *error_message = StringUtilities::Format(IELAUNCHURL_ERROR_MESSAGE, | |
| launch_result, | |
| StringUtilities::ToString(hresult_msg).c_str(), | |
| this->initial_browser_url().c_str()); | |
| } | |
| } | |
| bool BrowserFactory::IsCreateProcessApiAvailable() { | |
| LOG(TRACE) << "Entering BrowserFactory::IsCreateProcessApiAvailable"; | |
| if (this->ie_major_version_ >= 8) { | |
| // According to http://blogs.msdn.com/b/askie/archive/2009/03/09/opening-a-new-tab-may-launch-a-new-process-with-internet-explorer-8-0.aspx | |
| // If CreateProcess() is used and TabProcGrowth != 0 IE will use different tab and frame processes. | |
| // Such behaviour is not supported by AttachToBrowser(). | |
| // FYI, IELaunchURL() returns correct 'frame' process (but sometimes not). | |
| std::wstring tab_proc_growth; | |
| if (RegistryUtilities::GetRegistryValue(HKEY_CURRENT_USER, | |
| IE_TABPROCGROWTH_REGISTRY_KEY, | |
| L"TabProcGrowth", | |
| &tab_proc_growth)) { | |
| if (tab_proc_growth != L"0") { | |
| // Registry value has wrong value, return false | |
| return false; | |
| } | |
| } else { | |
| // Registry key or value not found, or another error condition getting the value. | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| void BrowserFactory::LaunchBrowserUsingCreateProcess(PROCESS_INFORMATION* proc_info, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering BrowserFactory::LaunchBrowserUsingCreateProcess"; | |
| LOG(DEBUG) << "Starting IE using the CreateProcess API"; | |
| STARTUPINFO start_info; | |
| ::ZeroMemory(&start_info, sizeof(start_info)); | |
| start_info.cb = sizeof(start_info); | |
| std::wstring executable_and_url = this->ie_executable_location_; | |
| if (this->browser_command_line_switches_.size() != 0) { | |
| executable_and_url.append(L" "); | |
| executable_and_url.append(this->browser_command_line_switches_); | |
| } | |
| executable_and_url.append(L" "); | |
| executable_and_url.append(this->initial_browser_url_); | |
| LOG(TRACE) << "IE starting command line is: '" | |
| << LOGWSTRING(executable_and_url) << "'."; | |
| LPWSTR command_line = new WCHAR[executable_and_url.size() + 1]; | |
| wcscpy_s(command_line, | |
| executable_and_url.size() + 1, | |
| executable_and_url.c_str()); | |
| command_line[executable_and_url.size()] = L'\0'; | |
| BOOL create_process_result = ::CreateProcess(NULL, | |
| command_line, | |
| NULL, | |
| NULL, | |
| FALSE, | |
| 0, | |
| NULL, | |
| NULL, | |
| &start_info, | |
| proc_info); | |
| if (!create_process_result) { | |
| *error_message = StringUtilities::Format(CREATEPROCESS_ERROR_MESSAGE, | |
| StringUtilities::ToString(command_line)); | |
| } | |
| delete[] command_line; | |
| } | |
| bool BrowserFactory::DirectoryExists(std::wstring& dir_name) { | |
| DWORD attribs = ::GetFileAttributes(dir_name.c_str()); | |
| if (attribs == INVALID_FILE_ATTRIBUTES) { | |
| return false; | |
| } | |
| return (attribs & FILE_ATTRIBUTE_DIRECTORY); | |
| } | |
| bool BrowserFactory::CreateUniqueTempDir(std::wstring &temp_dir) { | |
| // get temporary folder for the current user | |
| wchar_t temp_path_array[128]; | |
| ::GetTempPath(128, temp_path_array); | |
| std::wstring temp_path = temp_path_array; | |
| if (!DirectoryExists(temp_path)) { | |
| return false; | |
| } | |
| // create a IEDriver temporary folder inside the user level temporary folder | |
| bool temp_dir_created = false; | |
| for (int i = 0; i < 10; i++) { | |
| std::wstring output = | |
| temp_path + L"IEDriver-" + StringUtilities::CreateGuid(); | |
| if (DirectoryExists(output)) { | |
| continue; | |
| } | |
| ::CreateDirectory(output.c_str(), NULL); | |
| if (!DirectoryExists(output)) { | |
| continue; | |
| } | |
| temp_dir = output; | |
| temp_dir_created = true; | |
| break; | |
| } | |
| return temp_dir_created; | |
| } | |
| void BrowserFactory::LaunchEdgeInIEMode(PROCESS_INFORMATION* proc_info, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering BrowserFactory::LaunchEdgeInIEMode"; | |
| LOG(DEBUG) << "Starting Edge Chromium from the command line"; | |
| STARTUPINFO start_info; | |
| ::ZeroMemory(&start_info, sizeof(start_info)); | |
| start_info.cb = sizeof(start_info); | |
| std::wstring executable_and_url = this->edge_executable_location_; | |
| if (executable_and_url == L"") { | |
| executable_and_url = this->edge_executable_located_location_; // Locate Edge via Registry if not passed | |
| if (executable_and_url == L"") { | |
| executable_and_url = L"msedge.exe"; // Assume it's on the path | |
| } | |
| } | |
| // These flags force Edge into a mode where it will only run MSHTML | |
| executable_and_url.append(L" --ie-mode-force"); | |
| executable_and_url.append(L" --internet-explorer-integration=iemode"); | |
| // create a temporary directory for IEDriver test | |
| std::wstring temp_dir; | |
| if (CreateUniqueTempDir(temp_dir)) { | |
| LOG(TRACE) << L"Using temporary folder " << LOGWSTRING(temp_dir) << "."; | |
| executable_and_url.append(L" --user-data-dir=" + temp_dir); | |
| this->edge_user_data_dir_ = temp_dir; | |
| } | |
| // Prevent Edge from showing first run experience tab. | |
| executable_and_url.append(L" --no-first-run"); | |
| // Disable Edge prelaunch and other background processes on startup. | |
| executable_and_url.append(L" --no-service-autorun"); | |
| // Disable profile sync and implicit MS account sign-in. | |
| executable_and_url.append(L" --disable-sync"); | |
| executable_and_url.append(L" --disable-features=msImplicitSignin"); | |
| // ALways allow popups for testing. | |
| executable_and_url.append(L" --disable-popup-blocking"); | |
| // Ensure IE Mode tabs have a chance to shut down cleanly before the Edge process exits. | |
| executable_and_url.append(L" --enable-features=msIEModeAlwaysWaitForUnload"); | |
| executable_and_url.append(L" "); | |
| executable_and_url.append(this->initial_browser_url_); | |
| LOG(TRACE) << "Edge in IE Mode starting command line is: '" | |
| << LOGWSTRING(executable_and_url) << "'."; | |
| LPWSTR command_line = new WCHAR[executable_and_url.size() + 1]; | |
| wcscpy_s(command_line, | |
| executable_and_url.size() + 1, | |
| executable_and_url.c_str()); | |
| command_line[executable_and_url.size()] = L'\0'; | |
| BOOL create_process_result = ::CreateProcess(NULL, | |
| command_line, | |
| NULL, | |
| NULL, | |
| FALSE, | |
| 0, | |
| NULL, | |
| NULL, | |
| &start_info, | |
| proc_info); | |
| if (!create_process_result) { | |
| *error_message = CREATEPROCESS_EDGE_ERROR + StringUtilities::ToString(command_line); | |
| } | |
| delete[] command_line; | |
| } | |
| bool BrowserFactory::GetDocumentFromWindowHandle(HWND window_handle, | |
| IHTMLDocument2** document) { | |
| LOG(TRACE) << "Entering BrowserFactory::GetDocumentFromWindowHandle"; | |
| if (window_handle != NULL && this->oleacc_instance_handle_) { | |
| LRESULT result; | |
| ::SendMessageTimeout(window_handle, | |
| this->html_getobject_msg_, | |
| 0L, | |
| 0L, | |
| SMTO_ABORTIFHUNG, | |
| 1000, | |
| reinterpret_cast<PDWORD_PTR>(&result)); | |
| LPFNOBJECTFROMLRESULT object_pointer = reinterpret_cast<LPFNOBJECTFROMLRESULT>(::GetProcAddress(this->oleacc_instance_handle_, "ObjectFromLresult")); | |
| if (object_pointer != NULL) { | |
| HRESULT hr; | |
| hr = (*object_pointer)(result, | |
| IID_IHTMLDocument2, | |
| 0, | |
| reinterpret_cast<void**>(document)); | |
| if (SUCCEEDED(hr)) { | |
| return true; | |
| } else { | |
| LOGHR(WARN, hr) << "Unable to convert document object pointer to IHTMLDocument2 object via ObjectFromLresult"; | |
| } | |
| } else { | |
| LOG(WARN) << "Unable to get address of ObjectFromLresult method from library; GetProcAddress() for ObjectFromLresult returned NULL"; | |
| } | |
| } else { | |
| LOG(WARN) << "Window handle is invalid or OLEACC.DLL is not loaded properly"; | |
| } | |
| return false; | |
| } | |
| bool BrowserFactory::AttachToBrowser(ProcessWindowInfo* process_window_info, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering BrowserFactory::AttachToBrowser"; | |
| bool attached = false; | |
| // Attempt to attach to the browser using ActiveAccessibility API | |
| // first, if this fails fallback to using ShellWindows API. | |
| // ActiveAccessibility fails if the Windows Desktop runs out of | |
| // free space for GlobalAtoms. | |
| // ShellWindows might fail if there is an IE modal dialog blocking | |
| // execution (unverified). | |
| if (!this->force_shell_windows_api_) { | |
| LOG(DEBUG) << "Using Active Accessibility to find IWebBrowser2 interface"; | |
| attached = this->AttachToBrowserUsingActiveAccessibility(process_window_info, | |
| error_message); | |
| if (!attached) { | |
| LOG(DEBUG) << "Failed to find IWebBrowser2 using ActiveAccessibility: " | |
| << *error_message; | |
| // Reset the browser window handle to NULL, since we didn't attach | |
| // using Active Accessibility. | |
| process_window_info->hwndBrowser = NULL; | |
| } | |
| } | |
| if (!attached) { | |
| LOG(DEBUG) << "Using IShellWindows to find IWebBrowser2 interface"; | |
| attached = this->AttachToBrowserUsingShellWindows(process_window_info, | |
| error_message); | |
| } | |
| if (attached) { | |
| // Test for zoom level = 100% | |
| int zoom_level = 100; | |
| LOG(DEBUG) << "Ignoring zoom setting: " << this->ignore_zoom_setting_; | |
| if (!this->ignore_zoom_setting_) { | |
| zoom_level = this->GetBrowserZoomLevel(process_window_info->pBrowser); | |
| } | |
| if (zoom_level != 100) { | |
| std::string zoom_level_error = | |
| StringUtilities::Format(ZOOM_SETTING_ERROR_MESSAGE, zoom_level); | |
| LOG(WARN) << zoom_level_error; | |
| *error_message = zoom_level_error; | |
| return false; | |
| } | |
| } | |
| return attached; | |
| } | |
| bool BrowserFactory::IsBrowserProcessInitialized(DWORD process_id) { | |
| ProcessWindowInfo info; | |
| info.dwProcessId = process_id; | |
| info.hwndBrowser = NULL; | |
| info.pBrowser = NULL; | |
| ::EnumWindows(&BrowserFactory::FindBrowserWindow, | |
| reinterpret_cast<LPARAM>(&info)); | |
| return info.hwndBrowser != NULL; | |
| } | |
| bool BrowserFactory::AttachToBrowserUsingActiveAccessibility | |
| (ProcessWindowInfo* process_window_info, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering BrowserFactory::AttachToBrowserUsingActiveAccessibility"; | |
| clock_t end = clock() + (this->browser_attach_timeout_ / 1000 * CLOCKS_PER_SEC); | |
| while (process_window_info->hwndBrowser == NULL) { | |
| if (this->browser_attach_timeout_ > 0 && (clock() > end)) { | |
| break; | |
| } | |
| if (!this->edge_ie_mode_) { | |
| ::EnumWindows(&BrowserFactory::FindBrowserWindow, | |
| reinterpret_cast<LPARAM>(process_window_info)); | |
| } else { | |
| // If we're in edge_ie_mode, we need to look for different windows | |
| if (this->ignore_process_match_) { | |
| LOG(TRACE) << "Finding window handle for IE Mode on Edge, " | |
| << "ignoring process id match. This assumes only one " | |
| << "Edge instance is running on the host."; | |
| ::EnumWindows(&BrowserFactory::FindEdgeWindowIgnoringProcessMatch, | |
| reinterpret_cast<LPARAM>(process_window_info)); | |
| } else { | |
| LOG(TRACE) << "Finding window handle for IE Mode on Edge"; | |
| ::EnumWindows(&BrowserFactory::FindEdgeWindow, | |
| reinterpret_cast<LPARAM>(process_window_info)); | |
| } | |
| } | |
| if (process_window_info->hwndBrowser == NULL) { | |
| ::Sleep(250); | |
| } | |
| } | |
| if (process_window_info->hwndBrowser == NULL) { | |
| *error_message = StringUtilities::Format(ATTACH_TIMEOUT_ERROR_MESSAGE, | |
| process_window_info->dwProcessId, | |
| this->browser_attach_timeout_); | |
| return false; | |
| } else { | |
| LOG(DEBUG) << "Found window handle " << process_window_info->hwndBrowser | |
| << " for window with class 'Internet Explorer_Server' belonging" | |
| << " to process with id " << process_window_info->dwProcessId; | |
| } | |
| CComPtr<IHTMLDocument2> document; | |
| if (this->GetDocumentFromWindowHandle(process_window_info->hwndBrowser, | |
| &document)) { | |
| int get_parent_window_retry_count = 8; | |
| CComPtr<IHTMLWindow2> window; | |
| HRESULT hr = document->get_parentWindow(&window); | |
| while (FAILED(hr) && get_parent_window_retry_count > 0) { | |
| // We know we have a valid document. We *should* be able to do a | |
| // document.parentWindow call to get the window. However, on the off- | |
| // chance that the document exists, but IE is slow to initialize all | |
| // of the COM objects and the full DOM, we'll sleep up to 2 seconds, | |
| // retrying to get the parent window. | |
| ::Sleep(250); | |
| hr = document->get_parentWindow(&window); | |
| --get_parent_window_retry_count; | |
| } | |
| if (SUCCEEDED(hr)) { | |
| // http://support.microsoft.com/kb/257717 | |
| CComPtr<IServiceProvider> provider; | |
| window->QueryInterface<IServiceProvider>(&provider); | |
| if (provider) { | |
| CComPtr<IServiceProvider> child_provider; | |
| hr = provider->QueryService(SID_STopLevelBrowser, | |
| IID_IServiceProvider, | |
| reinterpret_cast<void**>(&child_provider)); | |
| if (SUCCEEDED(hr)) { | |
| CComPtr<IWebBrowser2> browser; | |
| hr = child_provider->QueryService(SID_SWebBrowserApp, | |
| IID_IWebBrowser2, | |
| reinterpret_cast<void**>(&browser)); | |
| if (SUCCEEDED(hr)) { | |
| process_window_info->pBrowser = browser.Detach(); | |
| return true; | |
| } else { | |
| LOGHR(WARN, hr) << "IServiceProvider::QueryService for SID_SWebBrowserApp failed"; | |
| } | |
| } else { | |
| LOGHR(WARN, hr) << "IServiceProvider::QueryService for SID_STopLevelBrowser failed"; | |
| } | |
| } else { | |
| LOG(WARN) << "QueryInterface for IServiceProvider failed"; | |
| } | |
| } else { | |
| LOGHR(WARN, hr) << "Call to IHTMLDocument2::get_parentWindow failed"; | |
| } | |
| } else { | |
| *error_message = "Could not get document from window handle"; | |
| } | |
| return false; | |
| } | |
| bool BrowserFactory::AttachToBrowserUsingShellWindows( | |
| ProcessWindowInfo* process_window_info, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entering BrowserFactory::AttachToBrowserUsingShellWindows"; | |
| CComPtr<IShellWindows> shell_windows; | |
| HRESULT hr = shell_windows.CoCreateInstance(CLSID_ShellWindows); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to create an object using the IShellWindows interface with CoCreateInstance"; | |
| return false; | |
| } | |
| CComPtr<IUnknown> enumerator_unknown; | |
| hr = shell_windows->_NewEnum(&enumerator_unknown); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to get enumerator from IShellWindows interface"; | |
| return false; | |
| } | |
| clock_t end = clock() + (this->browser_attach_timeout_ / 1000 * CLOCKS_PER_SEC); | |
| CComPtr<IEnumVARIANT> enumerator; | |
| enumerator_unknown->QueryInterface<IEnumVARIANT>(&enumerator); | |
| while (process_window_info->hwndBrowser == NULL) { | |
| if (this->browser_attach_timeout_ > 0 && (clock() > end)) { | |
| break; | |
| } | |
| enumerator->Reset(); | |
| for (CComVariant shell_window_variant; | |
| enumerator->Next(1, &shell_window_variant, NULL) == S_OK; | |
| shell_window_variant.Clear()) { | |
| if (shell_window_variant.vt != VT_DISPATCH) { | |
| continue; | |
| } | |
| CComPtr<IShellBrowser> shell_browser; | |
| hr = IUnknown_QueryService(shell_window_variant.pdispVal, | |
| SID_STopLevelBrowser, | |
| IID_PPV_ARGS(&shell_browser)); | |
| if (shell_browser) { | |
| HWND hwnd; | |
| hr = shell_browser->GetWindow(&hwnd); | |
| if (SUCCEEDED(hr)) { | |
| ::EnumChildWindows(hwnd, | |
| &BrowserFactory::FindChildWindowForProcess, | |
| reinterpret_cast<LPARAM>(process_window_info)); | |
| if (process_window_info->hwndBrowser != NULL) { | |
| LOG(DEBUG) << "Found window handle " | |
| << process_window_info->hwndBrowser | |
| << " for window with class 'Internet Explorer_Server'" | |
| << " belonging to process with id " | |
| << process_window_info->dwProcessId; | |
| CComPtr<IWebBrowser2> browser; | |
| hr = shell_window_variant.pdispVal->QueryInterface<IWebBrowser2>(&browser); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Found browser window using ShellWindows " | |
| << "API, but QueryInterface for IWebBrowser2 " | |
| << "failed, so could not attach to the browser."; | |
| } else { | |
| process_window_info->pBrowser = browser.Detach(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| if (process_window_info->hwndBrowser == NULL || | |
| process_window_info->pBrowser == NULL) { | |
| ::Sleep(250); | |
| } | |
| } | |
| if (process_window_info->hwndBrowser == NULL) { | |
| *error_message = StringUtilities::Format(ATTACH_TIMEOUT_ERROR_MESSAGE, | |
| process_window_info->dwProcessId, | |
| this->browser_attach_timeout_); | |
| return false; | |
| } | |
| if (process_window_info->pBrowser == NULL) { | |
| *error_message = ATTACH_FAILURE_ERROR_MESSAGE; | |
| return false; | |
| } | |
| return true; | |
| } | |
| int BrowserFactory::GetBrowserZoomLevel(IWebBrowser2* browser) { | |
| LOG(TRACE) << "Entering BrowserFactory::GetBrowserZoomLevel"; | |
| clock_t end = clock() + (this->browser_attach_timeout_ / 1000 * CLOCKS_PER_SEC); | |
| CComPtr<IDispatch> document_dispatch; | |
| while (!document_dispatch) { | |
| if (this->browser_attach_timeout_ > 0 && (clock() > end)) { | |
| break; | |
| } | |
| browser->get_Document(&document_dispatch); | |
| if (!document_dispatch) { | |
| ::Sleep(250); | |
| } | |
| } | |
| if (!document_dispatch) { | |
| LOG(WARN) << "Call to IWebBrowser2::get_Document failed"; | |
| return 0; | |
| } | |
| CComPtr<IHTMLDocument2> document; | |
| document_dispatch->QueryInterface(&document); | |
| if (!document) { | |
| LOG(WARN) << "QueryInterface for IHTMLDocument2 failed."; | |
| return 0; | |
| } | |
| CComPtr<IHTMLWindow2> window; | |
| HRESULT hr = document->get_parentWindow(&window); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IHTMLDocument2::get_parentWindow failed"; | |
| return 0; | |
| } | |
| // Test for zoom level = 100% | |
| int zoom_level = this->GetZoomLevel(document, window); | |
| return zoom_level; | |
| } | |
| int BrowserFactory::GetZoomLevel(IHTMLDocument2* document, IHTMLWindow2* window) { | |
| LOG(TRACE) << "Entering BrowserFactory::GetZoomLevel"; | |
| int zoom = 100; // Chances are the zoom level hasn't been modified.... | |
| HRESULT hr = S_OK; | |
| if (this->ie_major_version_ == 7) { | |
| CComPtr<IHTMLElement> body; | |
| hr = document->get_body(&body); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IHTMLDocument2::get_body failed"; | |
| return zoom; | |
| } | |
| long offset_width = 0; | |
| hr = body->get_offsetWidth(&offset_width); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IHTMLElement::get_offsetWidth failed"; | |
| return zoom; | |
| } | |
| CComPtr<IHTMLElement2> body2; | |
| hr = body.QueryInterface<IHTMLElement2>(&body2); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Attempt to QueryInterface for IHTMLElement2 failed"; | |
| return zoom; | |
| } | |
| CComPtr<IHTMLRect> rect; | |
| hr = body2->getBoundingClientRect(&rect); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IHTMLElement2::getBoundingClientRect failed"; | |
| return zoom; | |
| } | |
| long left = 0, right = 0; | |
| hr = rect->get_left(&left); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IHTMLRect::get_left failed"; | |
| return zoom; | |
| } | |
| hr = rect->get_right(&right); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IHTMLRect::get_right failed"; | |
| return zoom; | |
| } | |
| zoom = static_cast<int>((static_cast<double>(right - left) / offset_width) * 100.0); | |
| } else if (this->ie_major_version_ >= 8) { | |
| CComPtr<IHTMLScreen> screen; | |
| hr = window->get_screen(&screen); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IHTMLWindow2::get_screen failed"; | |
| return zoom; | |
| } | |
| CComPtr<IHTMLScreen2> screen2; | |
| hr = screen.QueryInterface<IHTMLScreen2>(&screen2); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Attempt to QueryInterface for IHTMLScreen2 failed"; | |
| return zoom; | |
| } | |
| long device_xdpi=0, logical_xdpi = 0; | |
| hr = screen2->get_deviceXDPI(&device_xdpi); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IHTMLScreen2::get_deviceXDPI failed"; | |
| return zoom; | |
| } | |
| hr = screen2->get_logicalXDPI(&logical_xdpi); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IHTMLScreen2::get_logicalXDPI failed"; | |
| return zoom; | |
| } | |
| zoom = static_cast<int>((static_cast<double>(device_xdpi) / logical_xdpi) * 100.0); | |
| } else { | |
| // IE6 case | |
| zoom = 100; | |
| } | |
| LOG(DEBUG) << "Browser zoom level is " << zoom << "%"; | |
| return zoom; | |
| } | |
| IWebBrowser2* BrowserFactory::CreateBrowser(bool is_protected_mode) { | |
| LOG(TRACE) << "Entering BrowserFactory::CreateBrowser"; | |
| IWebBrowser2* browser = NULL; | |
| DWORD context = CLSCTX_LOCAL_SERVER; | |
| if (this->ie_major_version_ == 7 && IsWindowsVistaOrGreater()) { | |
| // ONLY for IE 7 on Windows Vista. XP and below do not have Protected Mode; | |
| // Windows 7 shipped with IE8. | |
| context = context | CLSCTX_ENABLE_CLOAKING; | |
| } | |
| HRESULT hr = S_OK; | |
| if (is_protected_mode) { | |
| hr = ::CoCreateInstance(CLSID_InternetExplorer, | |
| NULL, | |
| context, | |
| IID_IWebBrowser2, | |
| reinterpret_cast<void**>(&browser)); | |
| } else { | |
| hr = ::CoCreateInstance(CLSID_InternetExplorerMedium, | |
| NULL, | |
| context, | |
| IID_IWebBrowser2, | |
| reinterpret_cast<void**>(&browser)); | |
| } | |
| // When IWebBrowser2::Quit() is called, the wrapper process doesn't | |
| // exit right away. When that happens, CoCreateInstance can fail while | |
| // the abandoned iexplore.exe instance is still valid. The "right" way | |
| // to do this would be to call ::EnumProcesses before calling | |
| // CoCreateInstance, finding all of the iexplore.exe processes, waiting | |
| // for one to exit, and then proceed. However, there is no way to tell | |
| // if a process ID belongs to an Internet Explorer instance, particularly | |
| // when a 32-bit process tries to enumerate 64-bit processes on 64-bit | |
| // Windows. So, we'll take the brute force way out, just retrying the call | |
| // to CoCreateInstance until it succeeds (the old iexplore.exe process has | |
| // exited), or we get a different error code. We'll also set a 45-second | |
| // timeout, with 45 seconds being chosen because it's below the default | |
| // 60 second HTTP request timeout of most language bindings. | |
| if (FAILED(hr) && HRESULT_CODE(hr) == ERROR_SHUTDOWN_IS_SCHEDULED) { | |
| LOG(DEBUG) << "CoCreateInstance for IWebBrowser2 failed due to a " | |
| << "browser process that has not yet fully exited. Retrying " | |
| << "until the browser process exits and a new instance can " | |
| << "be successfully created."; | |
| } | |
| clock_t timeout = clock() + (45 * CLOCKS_PER_SEC); | |
| while (FAILED(hr) && | |
| HRESULT_CODE(hr) == ERROR_SHUTDOWN_IS_SCHEDULED && | |
| clock() < timeout) { | |
| ::Sleep(500); | |
| hr = ::CoCreateInstance(CLSID_InternetExplorer, | |
| NULL, | |
| context, | |
| IID_IWebBrowser2, | |
| reinterpret_cast<void**>(&browser)); | |
| } | |
| if (FAILED(hr) && HRESULT_CODE(hr) != ERROR_SHUTDOWN_IS_SCHEDULED) { | |
| // If we hit this branch, the CoCreateInstance failed due to an unexpected | |
| // error, either before we looped, or at some point during the loop. In | |
| // in either case, there's not much else we can do except log the failure. | |
| LOGHR(WARN, hr) << "CoCreateInstance for IWebBrowser2 failed."; | |
| } | |
| if (browser != NULL) { | |
| browser->put_Visible(VARIANT_TRUE); | |
| } | |
| return browser; | |
| } | |
| bool BrowserFactory::CreateLowIntegrityLevelToken(HANDLE* process_token_handle, | |
| HANDLE* mic_token_handle, | |
| PSID* sid) { | |
| LOG(TRACE) << "Entering BrowserFactory::CreateLowIntegrityLevelToken"; | |
| BOOL result = TRUE; | |
| TOKEN_MANDATORY_LABEL tml = {0}; | |
| HANDLE process_handle = ::GetCurrentProcess(); | |
| result = ::OpenProcessToken(process_handle, | |
| MAXIMUM_ALLOWED, | |
| process_token_handle); | |
| if (result) { | |
| result = ::DuplicateTokenEx(*process_token_handle, | |
| MAXIMUM_ALLOWED, | |
| NULL, | |
| SecurityImpersonation, | |
| TokenPrimary, | |
| mic_token_handle); | |
| if (!result) { | |
| LOGERR(WARN) << "CreateLowIntegrityLevelToken: Could not duplicate token"; | |
| ::CloseHandle(*process_token_handle); | |
| } | |
| } | |
| if (result) { | |
| result = ::ConvertStringSidToSid(SDDL_ML_LOW, sid); | |
| if (result) { | |
| tml.Label.Attributes = SE_GROUP_INTEGRITY; | |
| tml.Label.Sid = *sid; | |
| } else { | |
| LOGERR(WARN) << "CreateLowIntegrityLevelToken: Could not convert string SID to SID"; | |
| ::CloseHandle(*process_token_handle); | |
| ::CloseHandle(*mic_token_handle); | |
| } | |
| } | |
| if(result) { | |
| result = ::SetTokenInformation(*mic_token_handle, | |
| TokenIntegrityLevel, | |
| &tml, | |
| sizeof(tml) + ::GetLengthSid(*sid)); | |
| if (!result) { | |
| LOGERR(WARN) << "CreateLowIntegrityLevelToken: Could not set token information to low level"; | |
| ::CloseHandle(*process_token_handle); | |
| ::CloseHandle(*mic_token_handle); | |
| ::LocalFree(*sid); | |
| } | |
| } | |
| ::CloseHandle(process_handle); | |
| return result == TRUE; | |
| } | |
| void BrowserFactory::InvokeClearCacheUtility(bool use_low_integrity_level) { | |
| LOG(TRACE) << "Entering BrowserFactory::InvokeClearCacheUtility"; | |
| HRESULT hr = S_OK; | |
| std::vector<wchar_t> system_path_buffer(MAX_PATH); | |
| std::vector<wchar_t> rundll_exe_path_buffer(MAX_PATH); | |
| std::vector<wchar_t> inetcpl_path_buffer(MAX_PATH); | |
| std::wstring args = L""; | |
| UINT system_path_size = ::GetSystemDirectory(&system_path_buffer[0], MAX_PATH); | |
| HANDLE process_token = NULL; | |
| HANDLE mic_token = NULL; | |
| PSID sid = NULL; | |
| bool can_create_process = true; | |
| if (!use_low_integrity_level || | |
| this->CreateLowIntegrityLevelToken(&process_token, &mic_token, &sid)) { | |
| if (0 != system_path_size && | |
| system_path_size <= static_cast<int>(system_path_buffer.size())) { | |
| if (::PathCombine(&rundll_exe_path_buffer[0], | |
| &system_path_buffer[0], | |
| RUNDLL_EXE_NAME) && | |
| ::PathCombine(&inetcpl_path_buffer[0], | |
| &system_path_buffer[0], | |
| INTERNET_CONTROL_PANEL_APPLET_NAME)) { | |
| // PathCombine will return NULL if the buffer would be exceeded. | |
| ::PathQuoteSpaces(&rundll_exe_path_buffer[0]); | |
| ::PathQuoteSpaces(&inetcpl_path_buffer[0]); | |
| args = StringUtilities::Format(CLEAR_CACHE_COMMAND_LINE_ARGS, | |
| &inetcpl_path_buffer[0], | |
| CLEAR_CACHE_OPTIONS); | |
| } else { | |
| LOG(WARN) << "Cannot combine paths to utilities required to clear cache."; | |
| can_create_process = false; | |
| } | |
| } else { | |
| LOG(WARN) << "Paths system directory exceeds MAX_PATH."; | |
| can_create_process = false; | |
| } | |
| if (can_create_process) { | |
| LOG(DEBUG) << "Launching inetcpl.cpl via rundll32.exe to clear cache"; | |
| STARTUPINFO start_info; | |
| ::ZeroMemory(&start_info, sizeof(start_info)); | |
| start_info.cb = sizeof(start_info); | |
| PROCESS_INFORMATION process_info; | |
| BOOL is_process_created = FALSE; | |
| start_info.dwFlags = STARTF_USESHOWWINDOW; | |
| start_info.wShowWindow = SW_SHOWNORMAL; | |
| std::vector<wchar_t> args_buffer(0); | |
| StringUtilities::ToBuffer(args, &args_buffer); | |
| // Create the process to run with low or medium rights | |
| if (use_low_integrity_level) { | |
| is_process_created = CreateProcessAsUser(mic_token, | |
| &rundll_exe_path_buffer[0], | |
| &args_buffer[0], | |
| NULL, | |
| NULL, | |
| FALSE, | |
| 0, | |
| NULL, | |
| NULL, | |
| &start_info, | |
| &process_info); | |
| } else { | |
| is_process_created = CreateProcess(&rundll_exe_path_buffer[0], | |
| &args_buffer[0], | |
| NULL, | |
| NULL, | |
| FALSE, | |
| 0, | |
| NULL, | |
| NULL, | |
| &start_info, | |
| &process_info); | |
| } | |
| if (is_process_created) { | |
| // Wait for the rundll32.exe process to exit. | |
| LOG(DEBUG) << "Waiting for rundll32.exe process to exit."; | |
| ::WaitForInputIdle(process_info.hProcess, 5000); | |
| ::WaitForSingleObject(process_info.hProcess, 30000); | |
| ::CloseHandle(process_info.hProcess); | |
| ::CloseHandle(process_info.hThread); | |
| LOG(DEBUG) << "Cache clearing complete."; | |
| } else { | |
| LOGERR(WARN) << "Could not create process for clearing cache."; | |
| } | |
| } | |
| // Close the handles opened when creating the | |
| // low integrity level token | |
| if (use_low_integrity_level) { | |
| ::CloseHandle(process_token); | |
| ::CloseHandle(mic_token); | |
| ::LocalFree(sid); | |
| } | |
| } | |
| } | |
| BOOL CALLBACK BrowserFactory::FindBrowserWindow(HWND hwnd, LPARAM arg) { | |
| // Could this be an IE instance? | |
| // 8 == "IeFrame\0" | |
| // 21 == "Shell DocObject View\0" | |
| // 19 == "Chrome_WidgetWin_1" | |
| char name[21]; | |
| if (::GetClassNameA(hwnd, name, 21) == 0) { | |
| // No match found. Skip | |
| return TRUE; | |
| } | |
| if (strcmp(IE_FRAME_WINDOW_CLASS, name) != 0 && | |
| strcmp(SHELL_DOCOBJECT_VIEW_WINDOW_CLASS, name) != 0 && | |
| strcmp(ANDIE_FRAME_WINDOW_CLASS, name) != 0) { | |
| return TRUE; | |
| } | |
| return EnumChildWindows(hwnd, FindChildWindowForProcess, arg); | |
| } | |
| BOOL CALLBACK BrowserFactory::FindEdgeWindow(HWND hwnd, LPARAM arg) { | |
| // Could this be an EdgeChrome window? | |
| // 19 == "Chrome_WidgetWin_1" | |
| char name[20]; | |
| if (::GetClassNameA(hwnd, name, 20) == 0) { | |
| // No match found. Skip | |
| return TRUE; | |
| } | |
| // continue if it is not "Chrome_WidgetWin_1" | |
| if (strcmp(ANDIE_FRAME_WINDOW_CLASS, name) != 0) return TRUE; | |
| // continue if window does not belong to the target process | |
| DWORD process_id = NULL; | |
| ::GetWindowThreadProcessId(hwnd, &process_id); | |
| ProcessWindowInfo* process_window_info = reinterpret_cast<ProcessWindowInfo*>(arg); | |
| if (process_window_info->dwProcessId != process_id) { | |
| return TRUE; | |
| } | |
| return EnumChildWindows(hwnd, FindEdgeChildWindowForProcess, arg); | |
| } | |
| BOOL CALLBACK BrowserFactory::FindEdgeWindowIgnoringProcessMatch(HWND hwnd, LPARAM arg) { | |
| // Could this be an EdgeChrome window? | |
| // 19 == "Chrome_WidgetWin_1" | |
| char name[20]; | |
| if (::GetClassNameA(hwnd, name, 20) == 0) { | |
| // No match found. Skip | |
| return TRUE; | |
| } | |
| // continue if it is not "Chrome_WidgetWin_1" | |
| if (strcmp(ANDIE_FRAME_WINDOW_CLASS, name) != 0) return TRUE; | |
| return EnumChildWindows(hwnd, FindEdgeChildWindowForProcess, arg); | |
| } | |
| BOOL CALLBACK BrowserFactory::FindIEBrowserHandles(HWND hwnd, LPARAM arg) { | |
| std::vector<HWND>* handles = reinterpret_cast<std::vector<HWND>*>(arg); | |
| // Could this be an Internet Explorer Server window? | |
| // 25 == "Internet Explorer_Server\0" | |
| char name[25]; | |
| if (::GetClassNameA(hwnd, name, 25) == 0) { | |
| // No match found. Skip | |
| return TRUE; | |
| } | |
| if (strcmp("Internet Explorer_Server", name) == 0) { | |
| handles->push_back(hwnd); | |
| } | |
| return TRUE; | |
| } | |
| BOOL CALLBACK BrowserFactory::FindEdgeBrowserHandles(HWND hwnd, LPARAM arg) { | |
| std::vector<HWND>* handles = reinterpret_cast<std::vector<HWND>*>(arg); | |
| // Could this be an Internet Explorer Server window? | |
| // 19 == "Chrome_WidgetWin_1\0" | |
| char name[20]; | |
| if (::GetClassNameA(hwnd, name, 20) == 0) { | |
| // No match found. Skip | |
| return TRUE; | |
| } | |
| if (strcmp("Chrome_WidgetWin_1", name) == 0) { | |
| handles->push_back(hwnd); | |
| } | |
| return TRUE; | |
| } | |
| BOOL CALLBACK BrowserFactory::FindChildWindowForProcess(HWND hwnd, LPARAM arg) { | |
| ProcessWindowInfo *process_window_info = reinterpret_cast<ProcessWindowInfo*>(arg); | |
| // Could this be an Internet Explorer Server window? | |
| // 25 == "Internet Explorer_Server\0" | |
| char name[25]; | |
| if (::GetClassNameA(hwnd, name, 25) == 0) { | |
| // No match found. Skip | |
| return TRUE; | |
| } | |
| if (strcmp(IE_SERVER_CHILD_WINDOW_CLASS, name) != 0) { | |
| return TRUE; | |
| } else { | |
| DWORD process_id = NULL; | |
| ::GetWindowThreadProcessId(hwnd, &process_id); | |
| LOG(DEBUG) << "Looking for " << process_window_info->dwProcessId; | |
| if (process_window_info->dwProcessId == process_id) { | |
| // Once we've found the first Internet Explorer_Server window | |
| // for the process we want, we can stop. | |
| process_window_info->hwndBrowser = hwnd; | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| BOOL CALLBACK BrowserFactory::FindEdgeChildWindowForProcess(HWND hwnd, LPARAM arg) { | |
| ProcessWindowInfo* process_window_info = reinterpret_cast<ProcessWindowInfo*>(arg); | |
| // Could this be an Internet Explorer Server window? | |
| // 25 == "Internet Explorer_Server\0" | |
| char name[25]; | |
| if (::GetClassNameA(hwnd, name, 25) == 0) { | |
| // No match found. Skip | |
| return TRUE; | |
| } | |
| if (strcmp(IE_SERVER_CHILD_WINDOW_CLASS, name) != 0) { | |
| return TRUE; | |
| } | |
| else { | |
| DWORD process_id = NULL; | |
| ::GetWindowThreadProcessId(hwnd, &process_id); | |
| LOG(DEBUG) << "Looking for " << process_window_info->dwProcessId; | |
| // Once we've found the first Internet Explorer_Server window | |
| // for the process we want, we can stop. | |
| process_window_info->hwndBrowser = hwnd; | |
| return FALSE; | |
| } | |
| return TRUE; | |
| } | |
| BOOL CALLBACK BrowserFactory::FindDialogWindowForProcess(HWND hwnd, LPARAM arg) { | |
| ProcessWindowInfo* process_win_info = reinterpret_cast<ProcessWindowInfo*>(arg); | |
| // Could this be an dialog window? | |
| // 7 == "#32770\0" | |
| // 29 == "Credential Dialog Xaml Host\0" | |
| // 34 == "Internet Explorer_TridentDlgFrame\0" | |
| char name[34]; | |
| if (::GetClassNameA(hwnd, name, 34) == 0) { | |
| // No match found. Skip | |
| return TRUE; | |
| } | |
| if (strcmp(ALERT_WINDOW_CLASS, name) != 0 && | |
| strcmp(HTML_DIALOG_WINDOW_CLASS, name) != 0 && | |
| strcmp(SECURITY_DIALOG_WINDOW_CLASS, name) != 0) { | |
| return TRUE; | |
| } else { | |
| // If the window style has the WS_DISABLED bit set or the | |
| // WS_VISIBLE bit unset, it can't be handled via the UI, | |
| // and must not be a visible dialog. Furthermore, if the | |
| // window style does not display a caption bar, it's not a | |
| // dialog displayed by the browser, but likely by an add-on | |
| // (like an antivirus toolbar). Note that checking the caption | |
| // window style is a hack, and may begin to fail if IE ever | |
| // changes the style of its alert windows. | |
| long window_long_style = ::GetWindowLong(hwnd, GWL_STYLE); | |
| if ((window_long_style & WS_DISABLED) != 0 || | |
| (window_long_style & WS_VISIBLE) == 0 || | |
| (window_long_style & WS_CAPTION) == 0) { | |
| return TRUE; | |
| } | |
| DWORD process_id = NULL; | |
| ::GetWindowThreadProcessId(hwnd, &process_id); | |
| if (process_win_info->dwProcessId == process_id) { | |
| // Once we've found the first dialog (#32770) window | |
| // for the process we want, we can stop. | |
| process_win_info->hwndBrowser = hwnd; | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| void BrowserFactory::GetIEExecutableLocation() { | |
| LOG(TRACE) << "Entering BrowserFactory::GetIEExecutableLocation"; | |
| std::wstring redirection; | |
| if (RegistryUtilities::GetRegistryValue(HKEY_LOCAL_MACHINE, | |
| IE_REDIRECT, | |
| L"{1FD49718-1D00-4B19-AF5F-070AF6D5D54C}", | |
| &redirection)) { | |
| this->ie_redirects_edge_ = redirection == L"1"; | |
| } | |
| else { | |
| LOG(WARN) << "Unable to determine IE to Edge Redirection"; | |
| } | |
| std::wstring class_id; | |
| if (RegistryUtilities::GetRegistryValue(HKEY_LOCAL_MACHINE, | |
| IE_CLSID_REGISTRY_KEY, | |
| L"", | |
| &class_id)) { | |
| std::wstring location_key = L"SOFTWARE\\Classes\\CLSID\\" + | |
| class_id + | |
| L"\\LocalServer32"; | |
| std::wstring executable_location; | |
| // If we are a 32-bit driver instance, running on 64-bit Windows, | |
| // we want to bypass the registry redirection so that we can get | |
| // the actual location of the browser executable. The primary place | |
| // this matters is when getting the browser version; the secondary | |
| // place is if the user specifies to use the CreateProcess API for | |
| // launching the browser, hence the 'true' argument in the following | |
| // call to RegistryUtilities::GetRegistryValue. | |
| if (RegistryUtilities::GetRegistryValue(HKEY_LOCAL_MACHINE, | |
| location_key, | |
| L"", | |
| true, | |
| &executable_location)) { | |
| // If the executable location in the registry has an environment | |
| // variable in it, expand the environment variable to an absolute | |
| // path. | |
| DWORD expanded_location_size = ::ExpandEnvironmentStrings(executable_location.c_str(), NULL, 0); | |
| std::vector<wchar_t> expanded_location(expanded_location_size); | |
| ::ExpandEnvironmentStrings(executable_location.c_str(), &expanded_location[0], expanded_location_size); | |
| executable_location = &expanded_location[0]; | |
| this->ie_executable_location_ = executable_location; | |
| size_t arg_start_pos = executable_location.find(L" -"); | |
| if (arg_start_pos != std::string::npos) { | |
| this->ie_executable_location_ = executable_location.substr(0, arg_start_pos); | |
| } | |
| if (this->ie_executable_location_.substr(0, 1) == L"\"") { | |
| this->ie_executable_location_.erase(0, 1); | |
| this->ie_executable_location_.erase(this->ie_executable_location_.size() - 1, 1); | |
| } | |
| } else { | |
| LOG(WARN) << "Unable to get IE executable location from registry"; | |
| } | |
| } else { | |
| LOG(WARN) << "Unable to get IE class id from registry"; | |
| } | |
| } | |
| void BrowserFactory::GetEdgeExecutableLocation() { | |
| LOG(TRACE) << "Entering BrowserFactory::GetEdgeExecutableLocation"; | |
| std::wstring edge_executable_location; | |
| if (RegistryUtilities::GetRegistryValue(HKEY_LOCAL_MACHINE, | |
| EDGE_REGISTRY_KEY, | |
| L"", | |
| true, | |
| &edge_executable_location)) { | |
| // If the executable location in the registry has an environment | |
| // variable in it, expand the environment variable to an absolute | |
| // path. | |
| DWORD expanded_location_size = ::ExpandEnvironmentStrings(edge_executable_location.c_str(), NULL, 0); | |
| std::vector<wchar_t> expanded_location(expanded_location_size); | |
| ::ExpandEnvironmentStrings(edge_executable_location.c_str(), &expanded_location[0], expanded_location_size); | |
| edge_executable_location = &expanded_location[0]; | |
| this->edge_executable_located_location_ = edge_executable_location; | |
| size_t arg_start_pos = edge_executable_location.find(L" -"); | |
| if (arg_start_pos != std::string::npos) { | |
| this->edge_executable_located_location_ = edge_executable_location.substr(0, arg_start_pos); | |
| } | |
| if (this->edge_executable_located_location_.substr(0, 1) == L"\"") { | |
| this->edge_executable_located_location_.erase(0, 1); | |
| this->edge_executable_located_location_.erase(this->edge_executable_located_location_.size() - 1, 1); | |
| } | |
| } else { | |
| LOG(WARN) << "Unable to get Edge executable location from registry"; | |
| } | |
| } | |
| void BrowserFactory::GetIEVersion() { | |
| LOG(TRACE) << "Entering BrowserFactory::GetIEVersion"; | |
| std::string ie_version = FileUtilities::GetFileVersion(this->ie_executable_location_); | |
| if (ie_version.size() == 0) { | |
| // 64-bit Windows 8 has a bug where it does not return the executable location properly | |
| this->ie_major_version_ = -1; | |
| LOG(WARN) << "Couldn't find IE version for executable " | |
| << LOGWSTRING(this->ie_executable_location_) | |
| << ", falling back to " | |
| << this->ie_major_version_; | |
| return; | |
| } | |
| std::stringstream version_stream(ie_version); | |
| version_stream >> this->ie_major_version_; | |
| } | |
| bool BrowserFactory::ProtectedModeSettingsAreValid() { | |
| LOG(TRACE) << "Entering BrowserFactory::ProtectedModeSettingsAreValid"; | |
| bool settings_are_valid = true; | |
| LOG(DEBUG) << "Detected IE version: " << this->ie_major_version_ | |
| << ", Windows version supports Protected Mode: " | |
| << IsWindowsVistaOrGreater() ? "true" : "false"; | |
| // Only need to check Protected Mode settings on IE 7 or higher | |
| // and on Windows Vista or higher. Otherwise, Protected Mode | |
| // doesn't come into play, and are valid. | |
| // Documentation of registry settings can be found at the following | |
| // Microsoft KnowledgeBase article: | |
| // http://support.microsoft.com/kb/182569 | |
| if (this->ie_major_version_ >= 7 && IsWindowsVistaOrGreater()) { | |
| HKEY key_handle; | |
| if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_CURRENT_USER, | |
| IE_SECURITY_ZONES_REGISTRY_KEY, | |
| 0, | |
| KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, | |
| &key_handle)) { | |
| DWORD subkey_count = 0; | |
| DWORD max_subkey_name_length = 0; | |
| if (ERROR_SUCCESS == ::RegQueryInfoKey(key_handle, | |
| NULL, | |
| NULL, | |
| NULL, | |
| &subkey_count, | |
| &max_subkey_name_length, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL)) { | |
| int protected_mode_value = -1; | |
| std::vector<wchar_t> subkey_name_buffer(max_subkey_name_length + 1); | |
| for (size_t index = 0; index < subkey_count; ++index) { | |
| DWORD number_of_characters_copied = max_subkey_name_length + 1; | |
| ::RegEnumKeyEx(key_handle, | |
| static_cast<DWORD>(index), | |
| &subkey_name_buffer[0], | |
| &number_of_characters_copied, | |
| NULL, | |
| NULL, | |
| NULL, | |
| NULL); | |
| std::wstring subkey_name = &subkey_name_buffer[0]; | |
| // Ignore the "My Computer" zone, since it's not displayed | |
| // in the UI. | |
| if (subkey_name != ZONE_MY_COMPUTER) { | |
| int value = this->GetZoneProtectedModeSetting(key_handle, | |
| subkey_name); | |
| if (protected_mode_value == -1) { | |
| protected_mode_value = value; | |
| } else { | |
| if (value != protected_mode_value) { | |
| settings_are_valid = false; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } else { | |
| LOG(WARN) << "RegQueryInfoKey to get count of zone setting subkeys failed"; | |
| } | |
| ::RegCloseKey(key_handle); | |
| } else { | |
| std::wstring registry_key_string = IE_SECURITY_ZONES_REGISTRY_KEY; | |
| LOG(WARN) << "RegOpenKeyEx for zone settings registry key " | |
| << LOGWSTRING(registry_key_string) | |
| << " in HKEY_CURRENT_USER failed"; | |
| } | |
| } | |
| return settings_are_valid; | |
| } | |
| int BrowserFactory::GetZoneProtectedModeSetting(const HKEY key_handle, | |
| const std::wstring& zone_subkey_name) { | |
| LOG(TRACE) << "Entering BrowserFactory::GetZoneProtectedModeSetting"; | |
| int protected_mode_value = 3; | |
| HKEY subkey_handle; | |
| if (ERROR_SUCCESS == ::RegOpenKeyEx(key_handle, | |
| zone_subkey_name.c_str(), | |
| 0, | |
| KEY_QUERY_VALUE, | |
| &subkey_handle)) { | |
| DWORD value = 0; | |
| DWORD value_length = sizeof(DWORD); | |
| if (ERROR_SUCCESS == ::RegQueryValueEx(subkey_handle, | |
| IE_PROTECTED_MODE_SETTING_VALUE_NAME, | |
| NULL, | |
| NULL, | |
| reinterpret_cast<LPBYTE>(&value), | |
| &value_length)) { | |
| LOG(DEBUG) << "Found Protected Mode setting value of " | |
| << value << " for zone " << LOGWSTRING(zone_subkey_name); | |
| protected_mode_value = value; | |
| } else { | |
| LOG(DEBUG) << "RegQueryValueEx failed for getting Protected Mode setting for a zone: " | |
| << LOGWSTRING(zone_subkey_name); | |
| } | |
| ::RegCloseKey(subkey_handle); | |
| } else { | |
| // The REG_DWORD value doesn't exist, so we have to return the default | |
| // value, which is "on" for the Internet and Restricted Sites zones and | |
| // is "on" for the Local Intranet zone in IE7 only (the default was | |
| // changed to "off" for Local Intranet in IE8), and "off" everywhere | |
| // else. | |
| // Note that a value of 0 in the registry value indicates that Protected | |
| // Mode is "on" for that zone; a value of 3 indicates that Protected Mode | |
| // is "off" for that zone. | |
| if (zone_subkey_name == ZONE_INTERNET || | |
| zone_subkey_name == ZONE_RESTRICTED_SITES || | |
| (zone_subkey_name == ZONE_LOCAL_INTRANET && this->ie_major_version_ == 7)) { | |
| protected_mode_value = 0; | |
| } | |
| LOG(DEBUG) << "Protected Mode zone setting value does not exist for zone " | |
| << LOGWSTRING(zone_subkey_name) << ". Using default value of " | |
| << protected_mode_value; | |
| } | |
| return protected_mode_value; | |
| } | |
| bool BrowserFactory::IsWindowsVersionOrGreater(unsigned short major_version, | |
| unsigned short minor_version, | |
| unsigned short service_pack) { | |
| OSVERSIONINFOEXW osvi = { sizeof(osvi), 0, 0, 0, 0,{ 0 }, 0, 0 }; | |
| DWORDLONG const dwlConditionMask = VerSetConditionMask( | |
| VerSetConditionMask( | |
| VerSetConditionMask( | |
| 0, VER_MAJORVERSION, VER_GREATER_EQUAL), | |
| VER_MINORVERSION, VER_GREATER_EQUAL), | |
| VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL); | |
| osvi.dwMajorVersion = major_version; | |
| osvi.dwMinorVersion = minor_version; | |
| osvi.wServicePackMajor = service_pack; | |
| return VerifyVersionInfoW(&osvi, | |
| VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR, | |
| dwlConditionMask) != FALSE; | |
| } | |
| bool BrowserFactory::IsWindowsVistaOrGreater() { | |
| return IsWindowsVersionOrGreater(HIBYTE(_WIN32_WINNT_VISTA), LOBYTE(_WIN32_WINNT_VISTA), 0); | |
| } | |
| bool BrowserFactory::IsEdgeMode() const { | |
| return this->edge_ie_mode_; | |
| } | |
| // delete a folder recursively | |
| int BrowserFactory::DeleteDirectory(const std::wstring &dir_name) { | |
| WIN32_FIND_DATA file_info; | |
| std::wstring file_pattern = dir_name + L"\\*.*"; | |
| HANDLE file_handle = ::FindFirstFile(file_pattern.c_str(), &file_info); | |
| if (file_handle != INVALID_HANDLE_VALUE) { | |
| do { | |
| if (file_info.cFileName[0] == '.') { | |
| continue; | |
| } | |
| std::wstring file_path = dir_name + L"\\" + file_info.cFileName; | |
| if (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { | |
| int return_value = DeleteDirectory(file_path); | |
| if (return_value) { | |
| return return_value; | |
| } | |
| } else { | |
| if (::SetFileAttributes(file_path.c_str(), FILE_ATTRIBUTE_NORMAL) == FALSE) { | |
| return ::GetLastError(); | |
| } | |
| if (::DeleteFile(file_path.c_str()) == FALSE) { | |
| return ::GetLastError(); | |
| } | |
| } | |
| } while (::FindNextFile(file_handle, &file_info) == TRUE); | |
| ::FindClose(file_handle); | |
| DWORD dwError = ::GetLastError(); | |
| if (dwError != ERROR_NO_MORE_FILES) { | |
| return dwError; | |
| } | |
| if (::SetFileAttributes(dir_name.c_str(), FILE_ATTRIBUTE_NORMAL) == FALSE) { | |
| return ::GetLastError(); | |
| } | |
| if (::RemoveDirectory(dir_name.c_str()) == FALSE) { | |
| return ::GetLastError(); | |
| } | |
| } | |
| return 0; | |
| } | |
| std::wstring BrowserFactory::GetEdgeTempDir() { | |
| return this->edge_user_data_dir_; | |
| } | |
| } // namespace webdriver |