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