// Must be done in the constructor. Do not move to Initialize().

this->GetExecutableLocation();

this->GetIEVersion();

this->oleacc_instance_handle_ = NULL;

this->edge_ie_mode_ = false;

LOG(TRACE) << "Entering BrowserFactory::Initialize";

this->ignore_protected_mode_settings_ = settings.ignore_protected_mode_settings;

this->ignore_zoom_setting_ = settings.ignore_zoom_setting;

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;

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 " << this->edge_executable_location_.c_str() << "\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);

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);

}

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);

LOG(DEBUG) << "IE 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;

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;

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());

}

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;

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;

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 = L"msedge.exe"; // Assume it's on the path if it's not passed

}

// 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");

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 = CREATEPROCESS_EDGE_ERROR + StringUtilities::ToString(command_line);

}

delete[] command_line;

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;

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;

ProcessWindowInfo info;

info.dwProcessId = process_id;

info.hwndBrowser = NULL;

info.pBrowser = NULL;

::EnumWindows(&BrowserFactory::FindBrowserWindow,

reinterpret_cast<LPARAM>(&info));

return info.hwndBrowser != NULL;

(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

::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;

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;

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;

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;

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;

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);