| // 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 "ProxyManager.h" |
| |
| #include <algorithm> |
| #include <vector> |
| |
| #include <wininet.h> |
| |
| #include "json.h" |
| #include "logging.h" |
| #include "messages.h" |
| |
| #include "HookProcessor.h" |
| #include "StringUtilities.h" |
| |
| #define WD_PROXY_TYPE_DIRECT "direct" |
| #define WD_PROXY_TYPE_SYSTEM "system" |
| #define WD_PROXY_TYPE_MANUAL "manual" |
| #define WD_PROXY_TYPE_AUTOCONFIGURE "pac" |
| #define WD_PROXY_TYPE_AUTODETECT "autodetect" |
| |
| #define HTTP_PROXY_MARKER "http=" |
| #define HTTPS_PROXY_MARKER "https=" |
| #define FTP_PROXY_MARKER "ftp=" |
| #define SOCKS_PROXY_MARKER "socks=" |
| #define BYPASS_PROXY_MARKER "|bypass=" |
| |
| namespace webdriver { |
| |
| ProxyManager::ProxyManager(void) { |
| this->proxy_type_ = ""; |
| this->http_proxy_ = ""; |
| this->ftp_proxy_ = ""; |
| this->ssl_proxy_ = ""; |
| this->socks_proxy_ = ""; |
| this->socks_user_name_ = ""; |
| this->socks_password_ = ""; |
| this->proxy_bypass_ = ""; |
| this->proxy_autoconfigure_url_ = ""; |
| this->is_proxy_modified_ = false; |
| this->is_proxy_authorization_modified_ = false; |
| this->use_per_process_proxy_ = false; |
| |
| this->current_autoconfig_url_ = L""; |
| this->current_proxy_auto_detect_flags_ = 0; |
| this->current_proxy_server_ = L""; |
| this->current_socks_user_name_ = L""; |
| this->current_socks_password_ = L""; |
| this->current_proxy_type_ = 0; |
| this->current_proxy_bypass_list_ = L""; |
| } |
| |
| ProxyManager::~ProxyManager(void) { |
| this->RestoreProxySettings(); |
| } |
| |
| void ProxyManager::Initialize(ProxySettings settings) { |
| LOG(TRACE) << "ProxyManager::Initialize"; |
| // The wire protocol specifies lower case for the proxy type, but |
| // language bindings have been sending upper case forever. Handle |
| // both cases, thus we will normalize to a lower-case string for |
| // proxy type. |
| this->proxy_type_ = settings.proxy_type; |
| std::transform(this->proxy_type_.begin(), |
| this->proxy_type_.end(), |
| this->proxy_type_.begin(), |
| ::tolower); |
| this->http_proxy_ = settings.http_proxy; |
| this->ftp_proxy_ = settings.ftp_proxy; |
| this->ssl_proxy_ = settings.ssl_proxy; |
| this->socks_proxy_ = settings.socks_proxy; |
| this->socks_user_name_ = settings.socks_user_name; |
| this->socks_password_ = settings.socks_password; |
| this->proxy_bypass_ = settings.proxy_bypass; |
| this->proxy_autoconfigure_url_ = settings.proxy_autoconfig_url; |
| if (this->proxy_type_ == WD_PROXY_TYPE_SYSTEM || |
| this->proxy_type_ == WD_PROXY_TYPE_DIRECT || |
| this->proxy_type_ == WD_PROXY_TYPE_MANUAL) { |
| this->use_per_process_proxy_ = settings.use_per_process_proxy; |
| } else { |
| // By definition, per-process proxy settings can only be used with the |
| // system proxy, direct connection, or with a manually specified proxy. |
| this->use_per_process_proxy_ = false; |
| } |
| } |
| |
| void ProxyManager::SetProxySettings(HWND browser_window_handle) { |
| LOG(TRACE) << "ProxyManager::SetProxySettings"; |
| if (this->proxy_type_.size() > 0 && this->proxy_type_ != WD_PROXY_TYPE_SYSTEM) { |
| if (this->use_per_process_proxy_) { |
| LOG(DEBUG) << "Setting proxy for individual IE instance."; |
| this->SetPerProcessProxySettings(browser_window_handle); |
| } else { |
| if (!this->is_proxy_modified_) { |
| LOG(DEBUG) << "Setting system proxy."; |
| this->GetCurrentProxySettings(); |
| this->SetGlobalProxySettings(); |
| } else { |
| LOG(DEBUG) << "Proxy settings already set by IE driver."; |
| } |
| } |
| this->is_proxy_modified_ = true; |
| } else { |
| LOG(DEBUG) << "Using existing system proxy settings."; |
| } |
| } |
| |
| Json::Value ProxyManager::GetProxyAsJson() { |
| LOG(TRACE) << "ProxyManager::GetProxyAsJson"; |
| Json::Value proxy_value; |
| proxy_value["proxyType"] = this->proxy_type_; |
| if (this->proxy_type_ == WD_PROXY_TYPE_MANUAL) { |
| if (this->http_proxy_.size() > 0) { |
| proxy_value["httpProxy"] = this->http_proxy_; |
| } |
| if (this->ftp_proxy_.size() > 0) { |
| proxy_value["ftpProxy"] = this->ftp_proxy_; |
| } |
| if (this->ssl_proxy_.size() > 0) { |
| proxy_value["sslProxy"] = this->ssl_proxy_; |
| } |
| if (this->socks_proxy_.size() > 0) { |
| proxy_value["socksProxy"] = this->socks_proxy_; |
| if (this->socks_user_name_.size() > 0) { |
| proxy_value["socksUsername"] = this->socks_user_name_; |
| } |
| if (this->socks_password_.size() > 0) { |
| proxy_value["socksPassword"] = this->socks_password_; |
| } |
| } |
| } else if (this->proxy_type_ == WD_PROXY_TYPE_AUTOCONFIGURE) { |
| proxy_value["proxyAutoconfigUrl"] = this->proxy_autoconfigure_url_; |
| } |
| return proxy_value; |
| } |
| |
| std::wstring ProxyManager::BuildProxySettingsString() { |
| LOG(TRACE) << "ProxyManager::BuildProxySettingsString"; |
| std::string proxy_string = ""; |
| if (this->proxy_type_ == WD_PROXY_TYPE_MANUAL) { |
| if (this->http_proxy_.size() > 0) { |
| proxy_string.append(HTTP_PROXY_MARKER).append(this->http_proxy_); |
| } |
| if (this->ftp_proxy_.size() > 0) { |
| if (proxy_string.size() > 0) { |
| proxy_string.append(" "); |
| } |
| proxy_string.append(FTP_PROXY_MARKER).append(this->ftp_proxy_); |
| } |
| if (this->ssl_proxy_.size() > 0) { |
| if (proxy_string.size() > 0) { |
| proxy_string.append(" "); |
| } |
| proxy_string.append(HTTPS_PROXY_MARKER).append(this->ssl_proxy_); |
| } |
| if (this->socks_proxy_.size() > 0) { |
| if (proxy_string.size() > 0) { |
| proxy_string.append(" "); |
| } |
| proxy_string.append(SOCKS_PROXY_MARKER).append(this->socks_proxy_); |
| } |
| if (this->proxy_bypass_.size() > 0) { |
| proxy_string.append(BYPASS_PROXY_MARKER).append(this->proxy_bypass_); |
| } |
| } else if (this->proxy_type_ == WD_PROXY_TYPE_AUTOCONFIGURE) { |
| proxy_string = this->proxy_autoconfigure_url_; |
| } else { |
| proxy_string = this->proxy_type_; |
| } |
| LOG(DEBUG) << "Built proxy settings string: '" << proxy_string << "'"; |
| return StringUtilities::ToWString(proxy_string); |
| } |
| |
| void ProxyManager::RestoreProxySettings() { |
| LOG(TRACE) << "ProxyManager::RestoreProxySettings"; |
| bool settings_restored = (!this->use_per_process_proxy_ && this->is_proxy_modified_) || this->is_proxy_authorization_modified_; |
| if (!this->use_per_process_proxy_ && this->is_proxy_modified_) { |
| INTERNET_PER_CONN_OPTION_LIST option_list; |
| std::vector<INTERNET_PER_CONN_OPTION> restore_options(5); |
| unsigned long list_size = sizeof(INTERNET_PER_CONN_OPTION_LIST); |
| |
| std::vector<wchar_t> autoconfig_url_buffer; |
| StringUtilities::ToBuffer(this->current_autoconfig_url_, &autoconfig_url_buffer); |
| restore_options[0].dwOption = INTERNET_PER_CONN_AUTOCONFIG_URL; |
| restore_options[0].Value.pszValue = &autoconfig_url_buffer[0]; |
| |
| restore_options[1].dwOption = INTERNET_PER_CONN_AUTODISCOVERY_FLAGS; |
| restore_options[1].Value.dwValue = this->current_proxy_auto_detect_flags_; |
| |
| restore_options[2].dwOption = INTERNET_PER_CONN_FLAGS; |
| restore_options[2].Value.dwValue = this->current_proxy_type_; |
| |
| std::vector<wchar_t> proxy_bypass_buffer; |
| StringUtilities::ToBuffer(this->current_proxy_bypass_list_, &proxy_bypass_buffer); |
| restore_options[3].dwOption = INTERNET_PER_CONN_PROXY_BYPASS; |
| restore_options[3].Value.pszValue = &proxy_bypass_buffer[0]; |
| |
| std::vector<wchar_t> proxy_server_buffer; |
| StringUtilities::ToBuffer(this->current_proxy_server_, &proxy_server_buffer); |
| restore_options[4].dwOption = INTERNET_PER_CONN_PROXY_SERVER; |
| restore_options[4].Value.pszValue = &proxy_server_buffer[0]; |
| |
| option_list.dwSize = sizeof(INTERNET_PER_CONN_OPTION_LIST); |
| option_list.pszConnection = NULL; |
| option_list.dwOptionCount = static_cast<int>(restore_options.size()); |
| option_list.dwOptionError = 0; |
| option_list.pOptions = &restore_options[0]; |
| |
| BOOL success = ::InternetSetOption(NULL, |
| INTERNET_OPTION_PER_CONNECTION_OPTION, |
| &option_list, |
| list_size); |
| if (!success) { |
| LOGERR(WARN) << "InternetSetOption failed setting INTERNET_OPTION_PER_CONNECTION_OPTION"; |
| } |
| this->is_proxy_modified_ = false; |
| } |
| if (this->is_proxy_authorization_modified_) { |
| this->SetProxyAuthentication(this->current_socks_user_name_, |
| this->current_socks_password_); |
| this->is_proxy_authorization_modified_ = false; |
| } |
| if (settings_restored) { |
| BOOL notify_success = ::InternetSetOption(NULL, |
| INTERNET_OPTION_PROXY_SETTINGS_CHANGED, |
| NULL, |
| 0); |
| if (!notify_success) { |
| LOGERR(WARN) << "InternetSetOption failed setting INTERNET_OPTION_PROXY_SETTINGS_CHANGED"; |
| } |
| } |
| } |
| |
| void ProxyManager::SetPerProcessProxySettings(HWND browser_window_handle) { |
| LOG(TRACE) << "ProxyManager::SetPerProcessProxySettings"; |
| std::wstring proxy = this->BuildProxySettingsString(); |
| |
| HookSettings hook_settings; |
| hook_settings.window_handle = browser_window_handle; |
| hook_settings.hook_procedure_name = "SetProxyWndProc"; |
| hook_settings.hook_procedure_type = WH_CALLWNDPROC; |
| hook_settings.communication_type = OneWay; |
| |
| HookProcessor hook; |
| if (!hook.CanSetWindowsHook(browser_window_handle)) { |
| LOG(WARN) << "Proxy will not be set! There is a mismatch in the " |
| << "bitness between the driver and browser. In particular, " |
| << "be sure you are not attempting to use a 64-bit " |
| << "IEDriverServer.exe against IE 10 or 11, even on 64-bit " |
| << "Windows."; |
| } |
| hook.Initialize(hook_settings); |
| hook.PushData(proxy); |
| LRESULT result = ::SendMessage(browser_window_handle, |
| WD_CHANGE_PROXY, |
| NULL, |
| NULL); |
| |
| if (this->socks_proxy_.size() > 0 && |
| (this->socks_user_name_.size() > 0 || this->socks_password_.size() > 0)) { |
| LOG(WARN) << "Windows APIs provide no way to set proxy user name and " |
| << "password on a per-process basis. Setting global setting."; |
| |
| this->SetProxyAuthentication(StringUtilities::ToWString(this->socks_user_name_), |
| StringUtilities::ToWString(this->socks_password_)); |
| this->is_proxy_authorization_modified_ = true; |
| |
| // Notify WinINet clients that the proxy options have changed. |
| BOOL success = ::InternetSetOption(NULL, |
| INTERNET_OPTION_PROXY_SETTINGS_CHANGED, |
| NULL, |
| 0); |
| if (!success) { |
| LOGERR(WARN) << "InternetSetOption failed setting INTERNET_OPTION_PROXY_SETTINGS_CHANGED"; |
| } |
| } |
| } |
| |
| void ProxyManager::SetGlobalProxySettings() { |
| LOG(TRACE) << "ProxyManager::SetGlobalProxySettings"; |
| std::wstring proxy_settings_string = this->BuildProxySettingsString(); |
| |
| std::vector<std::wstring> proxy_settings; |
| StringUtilities::Split(proxy_settings_string, |
| _TEXT(BYPASS_PROXY_MARKER), |
| &proxy_settings); |
| |
| std::wstring proxy = proxy_settings[0]; |
| std::wstring proxy_bypass = L""; |
| if (proxy_settings.size() > 1) { |
| proxy_bypass = proxy_settings[1]; |
| } |
| |
| INTERNET_PER_CONN_OPTION_LIST option_list; |
| unsigned long list_size = sizeof(INTERNET_PER_CONN_OPTION_LIST); |
| option_list.dwSize = sizeof(INTERNET_PER_CONN_OPTION_LIST); |
| |
| INTERNET_PER_CONN_OPTION proxy_options[3]; |
| if (this->proxy_type_ == WD_PROXY_TYPE_DIRECT) { |
| proxy_options[0].dwOption = INTERNET_PER_CONN_FLAGS; |
| proxy_options[0].Value.dwValue = PROXY_TYPE_DIRECT; |
| option_list.dwOptionCount = 1; |
| } else if (this->proxy_type_ == WD_PROXY_TYPE_AUTOCONFIGURE) { |
| proxy_options[0].dwOption = INTERNET_PER_CONN_AUTOCONFIG_URL; |
| proxy_options[0].Value.pszValue = const_cast<wchar_t*>(proxy.c_str()); |
| proxy_options[1].dwOption = INTERNET_PER_CONN_FLAGS; |
| proxy_options[1].Value.dwValue = PROXY_TYPE_AUTO_PROXY_URL; |
| option_list.dwOptionCount = 2; |
| } else if (this->proxy_type_ == WD_PROXY_TYPE_AUTODETECT) { |
| proxy_options[0].dwOption = INTERNET_PER_CONN_AUTODISCOVERY_FLAGS; |
| proxy_options[0].Value.dwValue = AUTO_PROXY_FLAG_ALWAYS_DETECT; |
| proxy_options[1].dwOption = INTERNET_PER_CONN_FLAGS; |
| proxy_options[1].Value.dwValue = PROXY_TYPE_AUTO_DETECT; |
| option_list.dwOptionCount = 2; |
| } else { |
| proxy_options[0].dwOption = INTERNET_PER_CONN_PROXY_SERVER; |
| proxy_options[0].Value.pszValue = const_cast<wchar_t*>(proxy.c_str()); |
| proxy_options[1].dwOption = INTERNET_PER_CONN_FLAGS; |
| proxy_options[1].Value.dwValue = PROXY_TYPE_PROXY | PROXY_TYPE_DIRECT; |
| proxy_options[2].dwOption = INTERNET_PER_CONN_PROXY_BYPASS; |
| proxy_options[2].Value.pszValue = const_cast<wchar_t*>(proxy_bypass.c_str());; |
| option_list.dwOptionCount = 3; |
| } |
| |
| option_list.pOptions = proxy_options; |
| option_list.pszConnection = NULL; |
| option_list.dwOptionError = 0; |
| BOOL success = ::InternetSetOption(NULL, |
| INTERNET_OPTION_PER_CONNECTION_OPTION, |
| &option_list, |
| list_size); |
| if (!success) { |
| LOGERR(WARN) << "InternetSetOption failed setting INTERNET_OPTION_PER_CONNECTION_OPTION"; |
| } |
| |
| // Only set proxy authentication for SOCKS proxies, and |
| // where the user name and password have been specified. |
| if (this->socks_proxy_.size() > 0 && |
| (this->socks_user_name_.size() > 0 || this->socks_password_.size() > 0)) { |
| this->SetProxyAuthentication(StringUtilities::ToWString(this->socks_user_name_), |
| StringUtilities::ToWString(this->socks_password_)); |
| this->is_proxy_authorization_modified_ = true; |
| } |
| |
| success = ::InternetSetOption(NULL, |
| INTERNET_OPTION_PROXY_SETTINGS_CHANGED, |
| NULL, |
| 0); |
| if (!success) { |
| LOGERR(WARN) << "InternetSetOption failed setting INTERNET_OPTION_PROXY_SETTINGS_CHANGED"; |
| } |
| } |
| |
| void ProxyManager::SetProxyAuthentication(const std::wstring& user_name, |
| const std::wstring& password) { |
| LOG(TRACE) << "ProxyManager::SetProxyAuthentication"; |
| BOOL success = ::InternetSetOption(NULL, |
| INTERNET_OPTION_PROXY_USERNAME, |
| const_cast<wchar_t*>(user_name.c_str()), |
| static_cast<int>(user_name.size()) + 1); |
| if (!success) { |
| LOGERR(WARN) << "InternetSetOption failed setting INTERNET_OPTION_PROXY_USERNAME"; |
| } |
| |
| success = ::InternetSetOption(NULL, |
| INTERNET_OPTION_PROXY_PASSWORD, |
| const_cast<wchar_t*>(password.c_str()), |
| static_cast<int>(password.size()) + 1); |
| if (!success) { |
| LOGERR(WARN) << "InternetSetOption failed setting INTERNET_OPTION_PROXY_PASSWORD"; |
| } |
| } |
| |
| void ProxyManager::GetCurrentProxySettings() { |
| LOG(TRACE) << "ProxyManager::GetCurrentProxySettings"; |
| this->GetCurrentProxyType(); |
| INTERNET_PER_CONN_OPTION_LIST option_list; |
| std::vector<INTERNET_PER_CONN_OPTION> options_to_get(4); |
| unsigned long list_size = sizeof(INTERNET_PER_CONN_OPTION_LIST); |
| |
| options_to_get[0].dwOption = INTERNET_PER_CONN_AUTOCONFIG_URL; |
| options_to_get[1].dwOption = INTERNET_PER_CONN_AUTODISCOVERY_FLAGS; |
| options_to_get[2].dwOption = INTERNET_PER_CONN_PROXY_BYPASS; |
| options_to_get[3].dwOption = INTERNET_PER_CONN_PROXY_SERVER; |
| |
| option_list.dwSize = sizeof(INTERNET_PER_CONN_OPTION_LIST); |
| option_list.pszConnection = NULL; |
| option_list.dwOptionCount = static_cast<int>(options_to_get.size()); |
| option_list.dwOptionError = 0; |
| option_list.pOptions = &options_to_get[0]; |
| |
| BOOL success = ::InternetQueryOption(NULL, |
| INTERNET_OPTION_PER_CONNECTION_OPTION, |
| &option_list, |
| &list_size); |
| if (!success) { |
| LOGERR(WARN) << "InternetQueryOption failed getting proxy settings"; |
| } |
| |
| if(options_to_get[0].Value.pszValue != NULL) { |
| this->current_autoconfig_url_ = options_to_get[0].Value.pszValue; |
| ::GlobalFree(options_to_get[0].Value.pszValue); |
| } |
| |
| this->current_proxy_auto_detect_flags_ = options_to_get[1].Value.dwValue; |
| |
| if(options_to_get[2].Value.pszValue != NULL) { |
| this->current_proxy_bypass_list_ = options_to_get[2].Value.pszValue; |
| ::GlobalFree(options_to_get[2].Value.pszValue); |
| } |
| |
| if(options_to_get[3].Value.pszValue != NULL) { |
| this->current_proxy_server_ = options_to_get[3].Value.pszValue; |
| ::GlobalFree(options_to_get[3].Value.pszValue); |
| } |
| |
| this->GetCurrentProxyAuthentication(); |
| } |
| |
| void ProxyManager::GetCurrentProxyAuthentication() { |
| LOG(TRACE) << "ProxyManager::GetCurrentProxyAuthentication"; |
| |
| DWORD user_name_length = 0; |
| BOOL success = ::InternetQueryOption(NULL, |
| INTERNET_OPTION_PROXY_USERNAME, |
| NULL, |
| &user_name_length); |
| if (user_name_length > 0) { |
| std::vector<wchar_t> user_name(user_name_length); |
| success = ::InternetQueryOption(NULL, |
| INTERNET_OPTION_PROXY_USERNAME, |
| &user_name[0], |
| &user_name_length); |
| this->current_socks_user_name_ = &user_name[0]; |
| } |
| |
| DWORD password_length = 0; |
| success = ::InternetQueryOption(NULL, |
| INTERNET_OPTION_PROXY_PASSWORD, |
| NULL, |
| &password_length); |
| if (password_length > 0) { |
| std::vector<wchar_t> password(password_length); |
| success = ::InternetQueryOption(NULL, |
| INTERNET_OPTION_PROXY_PASSWORD, |
| &password[0], |
| &password_length); |
| this->current_socks_password_ = &password[0]; |
| } |
| } |
| |
| void ProxyManager::GetCurrentProxyType() { |
| LOG(TRACE) << "ProxyManager::GetCurrentProxyType"; |
| INTERNET_PER_CONN_OPTION_LIST option_list; |
| std::vector<INTERNET_PER_CONN_OPTION> proxy_type_options(1); |
| unsigned long list_size = sizeof(INTERNET_PER_CONN_OPTION_LIST); |
| |
| proxy_type_options[0].dwOption = INTERNET_PER_CONN_FLAGS_UI; |
| |
| option_list.dwSize = sizeof(INTERNET_PER_CONN_OPTION_LIST); |
| option_list.pszConnection = NULL; |
| option_list.dwOptionCount = static_cast<int>(proxy_type_options.size()); |
| option_list.dwOptionError = 0; |
| option_list.pOptions = &proxy_type_options[0]; |
| |
| // First check for INTERNET_PER_CONN_FLAGS_UI, then if that fails |
| // check again using INTERNET_PER_CONN_FLAGS. This is documented at |
| // http://msdn.microsoft.com/en-us/library/windows/desktop/aa385145%28v=vs.85%29.aspx |
| BOOL success = ::InternetQueryOption(NULL, |
| INTERNET_OPTION_PER_CONNECTION_OPTION, |
| &option_list, |
| &list_size); |
| if (success) { |
| this->current_proxy_type_ = proxy_type_options[0].Value.dwValue; |
| return; |
| } |
| |
| proxy_type_options[0].dwOption = INTERNET_PER_CONN_FLAGS; |
| success = ::InternetQueryOption(NULL, |
| INTERNET_OPTION_PER_CONNECTION_OPTION, |
| &option_list, |
| &list_size); |
| if (success) { |
| this->current_proxy_type_ = proxy_type_options[0].Value.dwValue; |
| } |
| } |
| |
| } // namespace webdriver |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| LRESULT CALLBACK SetProxyWndProc(int nCode, WPARAM wParam, LPARAM lParam) { |
| CWPSTRUCT* call_window_proc_struct = reinterpret_cast<CWPSTRUCT*>(lParam); |
| if (WM_COPYDATA == call_window_proc_struct->message) { |
| COPYDATASTRUCT* data = reinterpret_cast<COPYDATASTRUCT*>(call_window_proc_struct->lParam); |
| webdriver::HookProcessor::CopyDataToBuffer(data->cbData, data->lpData); |
| } else if (WD_CHANGE_PROXY == call_window_proc_struct->message) { |
| // Allocate a buffer of the length of the data in the shared memory buffer, |
| // plus one extra wide char, to account for the null terminator. |
| int multibyte_buffer_size = webdriver::HookProcessor::GetDataBufferSize() + sizeof(wchar_t); |
| std::vector<char> multibyte_buffer(multibyte_buffer_size); |
| std::vector<char> multibyte_buffer_bypass(multibyte_buffer_size); |
| std::wstring proxy_settings = webdriver::HookProcessor::CopyWStringFromBuffer(); |
| std::wstring proxy = proxy_settings; |
| std::wstring proxy_bypass = L""; |
| |
| // Use the _TEXT macro to convert to a wstring literal |
| std::wstring bypass_marker = _TEXT(BYPASS_PROXY_MARKER); |
| size_t bypass_marker_index = proxy_settings.find(bypass_marker); |
| if (bypass_marker_index != std::wstring::npos) { |
| proxy = proxy_settings.substr(0, bypass_marker_index); |
| proxy_bypass = proxy_settings.substr(bypass_marker_index + bypass_marker.size()); |
| } |
| |
| INTERNET_PROXY_INFO proxy_info; |
| if (proxy == L"direct") { |
| proxy_info.dwAccessType = INTERNET_OPEN_TYPE_DIRECT; |
| proxy_info.lpszProxy = L""; |
| } else { |
| // UrlMkSetSessionOption only appears to work on either ASCII or |
| // multi-byte strings, not Unicode strings. Since the INTERNET_PROXY_INFO |
| // struct hard-codes to LPCTSTR, and that translates into LPCWSTR for the |
| // compiler settings we use, we must use the multi-byte version here. |
| // Note that for the count of input characters, we can use -1, since |
| // we've forced the string to be null-terminated. |
| ::WideCharToMultiByte(CP_UTF8, |
| 0, |
| proxy.c_str(), |
| -1, |
| &multibyte_buffer[0], |
| static_cast<int>(multibyte_buffer.size()), |
| NULL, |
| NULL); |
| proxy_info.dwAccessType = INTERNET_OPEN_TYPE_PROXY; |
| proxy_info.lpszProxy = reinterpret_cast<LPCTSTR>(&multibyte_buffer[0]); |
| } |
| |
| ::WideCharToMultiByte(CP_UTF8, |
| 0, |
| proxy_bypass.c_str(), |
| -1, |
| &multibyte_buffer_bypass[0], |
| static_cast<int>(multibyte_buffer_bypass.size()), |
| NULL, |
| NULL); |
| proxy_info.lpszProxyBypass = reinterpret_cast<LPCTSTR>(&multibyte_buffer_bypass[0]); |
| DWORD proxy_info_size = sizeof(proxy_info); |
| HRESULT hr = ::UrlMkSetSessionOption(INTERNET_OPTION_PROXY, |
| reinterpret_cast<void*>(&proxy_info), |
| proxy_info_size, |
| 0); |
| } |
| |
| return ::CallNextHookEx(NULL, nCode, wParam, lParam); |
| } |
| |
| #ifdef __cplusplus |
| } |
| #endif |
