| // 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 |
