| /* |
| * Copyright 2004 The WebRTC Project Authors. All rights reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include "webrtc/base/proxydetect.h" |
| |
| #if defined(WEBRTC_WIN) |
| #include "webrtc/base/win32.h" |
| #include <shlobj.h> |
| #endif // WEBRTC_WIN |
| |
| #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
| #include <SystemConfiguration/SystemConfiguration.h> |
| #include <CoreFoundation/CoreFoundation.h> |
| #include <CoreServices/CoreServices.h> |
| #include <Security/Security.h> |
| #include "macconversion.h" |
| #endif |
| |
| #ifdef WEBRTC_IOS |
| #include <CFNetwork/CFNetwork.h> |
| #include "macconversion.h" |
| #endif |
| |
| #include <map> |
| #include <memory> |
| |
| #include "webrtc/base/arraysize.h" |
| #include "webrtc/base/fileutils.h" |
| #include "webrtc/base/httpcommon.h" |
| #include "webrtc/base/httpcommon-inl.h" |
| #include "webrtc/base/pathutils.h" |
| #include "webrtc/base/stringutils.h" |
| |
| #if defined(WEBRTC_WIN) |
| #define _TRY_WINHTTP 1 |
| #define _TRY_JSPROXY 0 |
| #define _TRY_WM_FINDPROXY 0 |
| #define _TRY_IE_LAN_SETTINGS 1 |
| #endif // WEBRTC_WIN |
| |
| // For all platforms try Firefox. |
| #define _TRY_FIREFOX 1 |
| |
| // Use profiles.ini to find the correct profile for this user. |
| // If not set, we'll just look for the default one. |
| #define USE_FIREFOX_PROFILES_INI 1 |
| |
| static const size_t kMaxLineLength = 1024; |
| static const char kFirefoxPattern[] = "Firefox"; |
| static const char kInternetExplorerPattern[] = "MSIE"; |
| |
| struct StringMap { |
| public: |
| void Add(const char * name, const char * value) { map_[name] = value; } |
| const std::string& Get(const char * name, const char * def = "") const { |
| std::map<std::string, std::string>::const_iterator it = |
| map_.find(name); |
| if (it != map_.end()) |
| return it->second; |
| def_ = def; |
| return def_; |
| } |
| bool IsSet(const char * name) const { |
| return (map_.find(name) != map_.end()); |
| } |
| private: |
| std::map<std::string, std::string> map_; |
| mutable std::string def_; |
| }; |
| |
| enum UserAgent { |
| UA_FIREFOX, |
| UA_INTERNETEXPLORER, |
| UA_OTHER, |
| UA_UNKNOWN |
| }; |
| |
| #if _TRY_WINHTTP |
| //#include <winhttp.h> |
| // Note: From winhttp.h |
| |
| const char WINHTTP[] = "winhttp"; |
| |
| typedef LPVOID HINTERNET; |
| |
| typedef struct { |
| DWORD dwAccessType; // see WINHTTP_ACCESS_* types below |
| LPWSTR lpszProxy; // proxy server list |
| LPWSTR lpszProxyBypass; // proxy bypass list |
| } WINHTTP_PROXY_INFO, * LPWINHTTP_PROXY_INFO; |
| |
| typedef struct { |
| DWORD dwFlags; |
| DWORD dwAutoDetectFlags; |
| LPCWSTR lpszAutoConfigUrl; |
| LPVOID lpvReserved; |
| DWORD dwReserved; |
| BOOL fAutoLogonIfChallenged; |
| } WINHTTP_AUTOPROXY_OPTIONS; |
| |
| typedef struct { |
| BOOL fAutoDetect; |
| LPWSTR lpszAutoConfigUrl; |
| LPWSTR lpszProxy; |
| LPWSTR lpszProxyBypass; |
| } WINHTTP_CURRENT_USER_IE_PROXY_CONFIG; |
| |
| extern "C" { |
| typedef HINTERNET (WINAPI * pfnWinHttpOpen) |
| ( |
| IN LPCWSTR pwszUserAgent, |
| IN DWORD dwAccessType, |
| IN LPCWSTR pwszProxyName OPTIONAL, |
| IN LPCWSTR pwszProxyBypass OPTIONAL, |
| IN DWORD dwFlags |
| ); |
| typedef BOOL (STDAPICALLTYPE * pfnWinHttpCloseHandle) |
| ( |
| IN HINTERNET hInternet |
| ); |
| typedef BOOL (STDAPICALLTYPE * pfnWinHttpGetProxyForUrl) |
| ( |
| IN HINTERNET hSession, |
| IN LPCWSTR lpcwszUrl, |
| IN WINHTTP_AUTOPROXY_OPTIONS * pAutoProxyOptions, |
| OUT WINHTTP_PROXY_INFO * pProxyInfo |
| ); |
| typedef BOOL (STDAPICALLTYPE * pfnWinHttpGetIEProxyConfig) |
| ( |
| IN OUT WINHTTP_CURRENT_USER_IE_PROXY_CONFIG * pProxyConfig |
| ); |
| |
| } // extern "C" |
| |
| #define WINHTTP_AUTOPROXY_AUTO_DETECT 0x00000001 |
| #define WINHTTP_AUTOPROXY_CONFIG_URL 0x00000002 |
| #define WINHTTP_AUTOPROXY_RUN_INPROCESS 0x00010000 |
| #define WINHTTP_AUTOPROXY_RUN_OUTPROCESS_ONLY 0x00020000 |
| #define WINHTTP_AUTO_DETECT_TYPE_DHCP 0x00000001 |
| #define WINHTTP_AUTO_DETECT_TYPE_DNS_A 0x00000002 |
| #define WINHTTP_ACCESS_TYPE_DEFAULT_PROXY 0 |
| #define WINHTTP_ACCESS_TYPE_NO_PROXY 1 |
| #define WINHTTP_ACCESS_TYPE_NAMED_PROXY 3 |
| #define WINHTTP_NO_PROXY_NAME NULL |
| #define WINHTTP_NO_PROXY_BYPASS NULL |
| |
| #endif // _TRY_WINHTTP |
| |
| #if _TRY_JSPROXY |
| extern "C" { |
| typedef BOOL (STDAPICALLTYPE * pfnInternetGetProxyInfo) |
| ( |
| LPCSTR lpszUrl, |
| DWORD dwUrlLength, |
| LPSTR lpszUrlHostName, |
| DWORD dwUrlHostNameLength, |
| LPSTR * lplpszProxyHostName, |
| LPDWORD lpdwProxyHostNameLength |
| ); |
| } // extern "C" |
| #endif // _TRY_JSPROXY |
| |
| #if _TRY_WM_FINDPROXY |
| #include <comutil.h> |
| #include <wmnetsourcecreator.h> |
| #include <wmsinternaladminnetsource.h> |
| #endif // _TRY_WM_FINDPROXY |
| |
| #if _TRY_IE_LAN_SETTINGS |
| #include <wininet.h> |
| #include <string> |
| #endif // _TRY_IE_LAN_SETTINGS |
| |
| namespace rtc { |
| |
| ////////////////////////////////////////////////////////////////////// |
| // Utility Functions |
| ////////////////////////////////////////////////////////////////////// |
| |
| #if defined(WEBRTC_WIN) |
| #ifdef _UNICODE |
| |
| typedef std::wstring tstring; |
| std::string Utf8String(const tstring& str) { return ToUtf8(str); } |
| |
| #else // !_UNICODE |
| |
| typedef std::string tstring; |
| std::string Utf8String(const tstring& str) { return str; } |
| |
| #endif // !_UNICODE |
| #endif // WEBRTC_WIN |
| |
| bool ProxyItemMatch(const Url<char>& url, char * item, size_t len) { |
| // hostname:443 |
| if (char * port = ::strchr(item, ':')) { |
| *port++ = '\0'; |
| if (url.port() != atol(port)) { |
| return false; |
| } |
| } |
| |
| // A.B.C.D or A.B.C.D/24 |
| int a, b, c, d, m; |
| int match = sscanf(item, "%d.%d.%d.%d/%d", &a, &b, &c, &d, &m); |
| if (match >= 4) { |
| uint32_t ip = ((a & 0xFF) << 24) | ((b & 0xFF) << 16) | ((c & 0xFF) << 8) | |
| (d & 0xFF); |
| if ((match < 5) || (m > 32)) |
| m = 32; |
| else if (m < 0) |
| m = 0; |
| uint32_t mask = (m == 0) ? 0 : (~0UL) << (32 - m); |
| SocketAddress addr(url.host(), 0); |
| // TODO: Support IPv6 proxyitems. This code block is IPv4 only anyway. |
| return !addr.IsUnresolvedIP() && |
| ((addr.ipaddr().v4AddressAsHostOrderInteger() & mask) == (ip & mask)); |
| } |
| |
| // .foo.com |
| if (*item == '.') { |
| size_t hostlen = url.host().length(); |
| return (hostlen > len) |
| && (stricmp(url.host().c_str() + (hostlen - len), item) == 0); |
| } |
| |
| // localhost or www.*.com |
| if (!string_match(url.host().c_str(), item)) |
| return false; |
| |
| return true; |
| } |
| |
| bool ProxyListMatch(const Url<char>& url, const std::string& proxy_list, |
| char sep) { |
| const size_t BUFSIZE = 256; |
| char buffer[BUFSIZE]; |
| const char* list = proxy_list.c_str(); |
| while (*list) { |
| // Remove leading space |
| if (isspace(*list)) { |
| ++list; |
| continue; |
| } |
| // Break on separator |
| size_t len; |
| const char * start = list; |
| if (const char * end = ::strchr(list, sep)) { |
| len = (end - list); |
| list += len + 1; |
| } else { |
| len = strlen(list); |
| list += len; |
| } |
| // Remove trailing space |
| while ((len > 0) && isspace(start[len-1])) |
| --len; |
| // Check for oversized entry |
| if (len >= BUFSIZE) |
| continue; |
| memcpy(buffer, start, len); |
| buffer[len] = 0; |
| if (!ProxyItemMatch(url, buffer, len)) |
| continue; |
| return true; |
| } |
| return false; |
| } |
| |
| bool Better(ProxyType lhs, const ProxyType rhs) { |
| // PROXY_NONE, PROXY_HTTPS, PROXY_SOCKS5, PROXY_UNKNOWN |
| const int PROXY_VALUE[5] = { 0, 2, 3, 1 }; |
| return (PROXY_VALUE[lhs] > PROXY_VALUE[rhs]); |
| } |
| |
| bool ParseProxy(const std::string& saddress, ProxyInfo* proxy) { |
| const size_t kMaxAddressLength = 1024; |
| // Allow semicolon, space, or tab as an address separator |
| const char* const kAddressSeparator = " ;\t"; |
| |
| ProxyType ptype; |
| std::string host; |
| uint16_t port; |
| |
| const char* address = saddress.c_str(); |
| while (*address) { |
| size_t len; |
| const char * start = address; |
| if (const char * sep = strchr(address, kAddressSeparator)) { |
| len = (sep - address); |
| address += len + 1; |
| while (*address != '\0' && ::strchr(kAddressSeparator, *address)) { |
| address += 1; |
| } |
| } else { |
| len = strlen(address); |
| address += len; |
| } |
| |
| if (len > kMaxAddressLength - 1) { |
| LOG(LS_WARNING) << "Proxy address too long [" << start << "]"; |
| continue; |
| } |
| |
| char buffer[kMaxAddressLength]; |
| memcpy(buffer, start, len); |
| buffer[len] = 0; |
| |
| char * colon = ::strchr(buffer, ':'); |
| if (!colon) { |
| LOG(LS_WARNING) << "Proxy address without port [" << buffer << "]"; |
| continue; |
| } |
| |
| *colon = 0; |
| char * endptr; |
| port = static_cast<uint16_t>(strtol(colon + 1, &endptr, 0)); |
| if (*endptr != 0) { |
| LOG(LS_WARNING) << "Proxy address with invalid port [" << buffer << "]"; |
| continue; |
| } |
| |
| if (char * equals = ::strchr(buffer, '=')) { |
| *equals = 0; |
| host = equals + 1; |
| if (_stricmp(buffer, "socks") == 0) { |
| ptype = PROXY_SOCKS5; |
| } else if (_stricmp(buffer, "https") == 0) { |
| ptype = PROXY_HTTPS; |
| } else { |
| LOG(LS_WARNING) << "Proxy address with unknown protocol [" |
| << buffer << "]"; |
| ptype = PROXY_UNKNOWN; |
| } |
| } else { |
| host = buffer; |
| ptype = PROXY_UNKNOWN; |
| } |
| |
| if (Better(ptype, proxy->type)) { |
| proxy->type = ptype; |
| proxy->address.SetIP(host); |
| proxy->address.SetPort(port); |
| } |
| } |
| |
| return proxy->type != PROXY_NONE; |
| } |
| |
| UserAgent GetAgent(const char* agent) { |
| if (agent) { |
| std::string agent_str(agent); |
| if (agent_str.find(kFirefoxPattern) != std::string::npos) { |
| return UA_FIREFOX; |
| } else if (agent_str.find(kInternetExplorerPattern) != std::string::npos) { |
| return UA_INTERNETEXPLORER; |
| } else if (agent_str.empty()) { |
| return UA_UNKNOWN; |
| } |
| } |
| return UA_OTHER; |
| } |
| |
| bool EndsWith(const std::string& a, const std::string& b) { |
| if (b.size() > a.size()) { |
| return false; |
| } |
| int result = a.compare(a.size() - b.size(), b.size(), b); |
| return result == 0; |
| } |
| |
| bool GetFirefoxProfilePath(Pathname* path) { |
| #if defined(WEBRTC_WIN) |
| wchar_t w_path[MAX_PATH]; |
| if (SHGetFolderPath(0, CSIDL_APPDATA, 0, SHGFP_TYPE_CURRENT, w_path) != |
| S_OK) { |
| LOG(LS_ERROR) << "SHGetFolderPath failed"; |
| return false; |
| } |
| path->SetFolder(ToUtf8(w_path, wcslen(w_path))); |
| path->AppendFolder("Mozilla"); |
| path->AppendFolder("Firefox"); |
| #elif defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
| FSRef fr; |
| if (0 != FSFindFolder(kUserDomain, kApplicationSupportFolderType, |
| kCreateFolder, &fr)) { |
| LOG(LS_ERROR) << "FSFindFolder failed"; |
| return false; |
| } |
| char buffer[NAME_MAX + 1]; |
| if (0 != FSRefMakePath(&fr, reinterpret_cast<uint8_t*>(buffer), |
| arraysize(buffer))) { |
| LOG(LS_ERROR) << "FSRefMakePath failed"; |
| return false; |
| } |
| path->SetFolder(std::string(buffer)); |
| path->AppendFolder("Firefox"); |
| #else |
| char* user_home = getenv("HOME"); |
| if (user_home == NULL) { |
| return false; |
| } |
| path->SetFolder(std::string(user_home)); |
| path->AppendFolder(".mozilla"); |
| path->AppendFolder("firefox"); |
| #endif // WEBRTC_WIN |
| return true; |
| } |
| |
| bool GetDefaultFirefoxProfile(Pathname* profile_path) { |
| ASSERT(NULL != profile_path); |
| Pathname path; |
| if (!GetFirefoxProfilePath(&path)) { |
| return false; |
| } |
| |
| #if USE_FIREFOX_PROFILES_INI |
| // [Profile0] |
| // Name=default |
| // IsRelative=1 |
| // Path=Profiles/2de53ejb.default |
| // Default=1 |
| |
| // Note: we are looking for the first entry with "Default=1", or the last |
| // entry in the file |
| path.SetFilename("profiles.ini"); |
| std::unique_ptr<FileStream> fs(Filesystem::OpenFile(path, "r")); |
| if (!fs) { |
| return false; |
| } |
| Pathname candidate; |
| bool relative = true; |
| std::string line; |
| while (fs->ReadLine(&line) == SR_SUCCESS) { |
| if (line.length() == 0) { |
| continue; |
| } |
| if (line.at(0) == '[') { |
| relative = true; |
| candidate.clear(); |
| } else if (line.find("IsRelative=") == 0 && |
| line.length() >= 12) { |
| // TODO: The initial Linux public launch revealed a fairly |
| // high number of machines where IsRelative= did not have anything after |
| // it. Perhaps that is legal profiles.ini syntax? |
| relative = (line.at(11) != '0'); |
| } else if (line.find("Path=") == 0 && |
| line.length() >= 6) { |
| if (relative) { |
| candidate = path; |
| } else { |
| candidate.clear(); |
| } |
| candidate.AppendFolder(line.substr(5)); |
| } else if (line.find("Default=") == 0 && |
| line.length() >= 9) { |
| if ((line.at(8) != '0') && !candidate.empty()) { |
| break; |
| } |
| } |
| } |
| fs->Close(); |
| if (candidate.empty()) { |
| return false; |
| } |
| profile_path->SetPathname(candidate.pathname()); |
| |
| #else // !USE_FIREFOX_PROFILES_INI |
| path.AppendFolder("Profiles"); |
| DirectoryIterator* it = Filesystem::IterateDirectory(); |
| it->Iterate(path); |
| std::string extension(".default"); |
| while (!EndsWith(it->Name(), extension)) { |
| if (!it->Next()) { |
| return false; |
| } |
| } |
| |
| profile_path->SetPathname(path); |
| profile->AppendFolder("Profiles"); |
| profile->AppendFolder(it->Name()); |
| delete it; |
| |
| #endif // !USE_FIREFOX_PROFILES_INI |
| |
| return true; |
| } |
| |
| bool ReadFirefoxPrefs(const Pathname& filename, |
| const char * prefix, |
| StringMap* settings) { |
| std::unique_ptr<FileStream> fs(Filesystem::OpenFile(filename, "r")); |
| if (!fs) { |
| LOG(LS_ERROR) << "Failed to open file: " << filename.pathname(); |
| return false; |
| } |
| |
| std::string line; |
| while (fs->ReadLine(&line) == SR_SUCCESS) { |
| size_t prefix_len = strlen(prefix); |
| |
| // Skip blank lines and too long lines. |
| if ((line.length() == 0) || (line.length() > kMaxLineLength) |
| || (line.at(0) == '#') || line.compare(0, 2, "/*") == 0 |
| || line.compare(0, 2, " *") == 0) { |
| continue; |
| } |
| |
| char buffer[kMaxLineLength]; |
| strcpyn(buffer, sizeof(buffer), line.c_str()); |
| int nstart = 0, nend = 0, vstart = 0, vend = 0; |
| sscanf(buffer, "user_pref(\"%n%*[^\"]%n\", %n%*[^)]%n);", |
| &nstart, &nend, &vstart, &vend); |
| if (vend > 0) { |
| char* name = buffer + nstart; |
| name[nend - nstart] = 0; |
| if ((vend - vstart >= 2) && (buffer[vstart] == '"')) { |
| vstart += 1; |
| vend -= 1; |
| } |
| char* value = buffer + vstart; |
| value[vend - vstart] = 0; |
| if ((strncmp(name, prefix, prefix_len) == 0) && *value) { |
| settings->Add(name + prefix_len, value); |
| } |
| } else { |
| LOG_F(LS_WARNING) << "Unparsed pref [" << buffer << "]"; |
| } |
| } |
| fs->Close(); |
| return true; |
| } |
| |
| bool GetFirefoxProxySettings(const char* url, ProxyInfo* proxy) { |
| Url<char> purl(url); |
| Pathname path; |
| bool success = false; |
| if (GetDefaultFirefoxProfile(&path)) { |
| StringMap settings; |
| path.SetFilename("prefs.js"); |
| if (ReadFirefoxPrefs(path, "network.proxy.", &settings)) { |
| success = true; |
| proxy->bypass_list = |
| settings.Get("no_proxies_on", "localhost, 127.0.0.1"); |
| if (settings.Get("type") == "1") { |
| // User has manually specified a proxy, try to figure out what |
| // type it is. |
| if (ProxyListMatch(purl, proxy->bypass_list.c_str(), ',')) { |
| // Our url is in the list of url's to bypass proxy. |
| } else if (settings.Get("share_proxy_settings") == "true") { |
| proxy->type = PROXY_UNKNOWN; |
| proxy->address.SetIP(settings.Get("http")); |
| proxy->address.SetPort(atoi(settings.Get("http_port").c_str())); |
| } else if (settings.IsSet("socks")) { |
| proxy->type = PROXY_SOCKS5; |
| proxy->address.SetIP(settings.Get("socks")); |
| proxy->address.SetPort(atoi(settings.Get("socks_port").c_str())); |
| } else if (settings.IsSet("ssl")) { |
| proxy->type = PROXY_HTTPS; |
| proxy->address.SetIP(settings.Get("ssl")); |
| proxy->address.SetPort(atoi(settings.Get("ssl_port").c_str())); |
| } else if (settings.IsSet("http")) { |
| proxy->type = PROXY_HTTPS; |
| proxy->address.SetIP(settings.Get("http")); |
| proxy->address.SetPort(atoi(settings.Get("http_port").c_str())); |
| } |
| } else if (settings.Get("type") == "2") { |
| // Browser is configured to get proxy settings from a given url. |
| proxy->autoconfig_url = settings.Get("autoconfig_url").c_str(); |
| } else if (settings.Get("type") == "4") { |
| // Browser is configured to auto detect proxy config. |
| proxy->autodetect = true; |
| } else { |
| // No proxy set. |
| } |
| } |
| } |
| return success; |
| } |
| |
| #if defined(WEBRTC_WIN) // Windows specific implementation for reading Internet |
| // Explorer proxy settings. |
| |
| void LogGetProxyFault() { |
| LOG_GLEM(LERROR, WINHTTP) << "WinHttpGetProxyForUrl faulted!!"; |
| } |
| |
| BOOL MyWinHttpGetProxyForUrl(pfnWinHttpGetProxyForUrl pWHGPFU, |
| HINTERNET hWinHttp, LPCWSTR url, |
| WINHTTP_AUTOPROXY_OPTIONS *options, |
| WINHTTP_PROXY_INFO *info) { |
| // WinHttpGetProxyForUrl() can call plugins which can crash. |
| // In the case of McAfee scriptproxy.dll, it does crash in |
| // older versions. Try to catch crashes here and treat as an |
| // error. |
| BOOL success = FALSE; |
| |
| #if (_HAS_EXCEPTIONS == 0) |
| __try { |
| success = pWHGPFU(hWinHttp, url, options, info); |
| } __except(EXCEPTION_EXECUTE_HANDLER) { |
| // This is a separate function to avoid |
| // Visual C++ error 2712 when compiling with C++ EH |
| LogGetProxyFault(); |
| } |
| #else |
| success = pWHGPFU(hWinHttp, url, options, info); |
| #endif // (_HAS_EXCEPTIONS == 0) |
| |
| return success; |
| } |
| |
| bool IsDefaultBrowserFirefox() { |
| HKEY key; |
| LONG result = RegOpenKeyEx(HKEY_CLASSES_ROOT, L"http\\shell\\open\\command", |
| 0, KEY_READ, &key); |
| if (ERROR_SUCCESS != result) |
| return false; |
| |
| DWORD size, type; |
| bool success = false; |
| result = RegQueryValueEx(key, L"", 0, &type, NULL, &size); |
| if (result == ERROR_SUCCESS && type == REG_SZ) { |
| wchar_t* value = new wchar_t[size+1]; |
| BYTE* buffer = reinterpret_cast<BYTE*>(value); |
| result = RegQueryValueEx(key, L"", 0, &type, buffer, &size); |
| if (result == ERROR_SUCCESS) { |
| // Size returned by RegQueryValueEx is in bytes, convert to number of |
| // wchar_t's. |
| size /= sizeof(value[0]); |
| value[size] = L'\0'; |
| for (size_t i = 0; i < size; ++i) { |
| value[i] = tolowercase(value[i]); |
| } |
| success = (NULL != strstr(value, L"firefox.exe")); |
| } |
| delete[] value; |
| } |
| |
| RegCloseKey(key); |
| return success; |
| } |
| |
| bool GetWinHttpProxySettings(const char* url, ProxyInfo* proxy) { |
| HMODULE winhttp_handle = LoadLibrary(L"winhttp.dll"); |
| if (winhttp_handle == NULL) { |
| LOG(LS_ERROR) << "Failed to load winhttp.dll."; |
| return false; |
| } |
| WINHTTP_CURRENT_USER_IE_PROXY_CONFIG iecfg; |
| memset(&iecfg, 0, sizeof(iecfg)); |
| Url<char> purl(url); |
| pfnWinHttpGetIEProxyConfig pWHGIEPC = |
| reinterpret_cast<pfnWinHttpGetIEProxyConfig>( |
| GetProcAddress(winhttp_handle, |
| "WinHttpGetIEProxyConfigForCurrentUser")); |
| bool success = false; |
| if (pWHGIEPC && pWHGIEPC(&iecfg)) { |
| // We were read proxy config successfully. |
| success = true; |
| if (iecfg.fAutoDetect) { |
| proxy->autodetect = true; |
| } |
| if (iecfg.lpszAutoConfigUrl) { |
| proxy->autoconfig_url = ToUtf8(iecfg.lpszAutoConfigUrl); |
| GlobalFree(iecfg.lpszAutoConfigUrl); |
| } |
| if (iecfg.lpszProxyBypass) { |
| proxy->bypass_list = ToUtf8(iecfg.lpszProxyBypass); |
| GlobalFree(iecfg.lpszProxyBypass); |
| } |
| if (iecfg.lpszProxy) { |
| if (!ProxyListMatch(purl, proxy->bypass_list, ';')) { |
| ParseProxy(ToUtf8(iecfg.lpszProxy), proxy); |
| } |
| GlobalFree(iecfg.lpszProxy); |
| } |
| } |
| FreeLibrary(winhttp_handle); |
| return success; |
| } |
| |
| // Uses the WinHTTP API to auto detect proxy for the given url. Firefox and IE |
| // have slightly different option dialogs for proxy settings. In Firefox, |
| // either a location of a proxy configuration file can be specified or auto |
| // detection can be selected. In IE theese two options can be independently |
| // selected. For the case where both options are selected (only IE) we try to |
| // fetch the config file first, and if that fails we'll perform an auto |
| // detection. |
| // |
| // Returns true if we successfully performed an auto detection not depending on |
| // whether we found a proxy or not. Returns false on error. |
| bool WinHttpAutoDetectProxyForUrl(const char* agent, const char* url, |
| ProxyInfo* proxy) { |
| Url<char> purl(url); |
| bool success = true; |
| HMODULE winhttp_handle = LoadLibrary(L"winhttp.dll"); |
| if (winhttp_handle == NULL) { |
| LOG(LS_ERROR) << "Failed to load winhttp.dll."; |
| return false; |
| } |
| pfnWinHttpOpen pWHO = |
| reinterpret_cast<pfnWinHttpOpen>(GetProcAddress(winhttp_handle, |
| "WinHttpOpen")); |
| pfnWinHttpCloseHandle pWHCH = |
| reinterpret_cast<pfnWinHttpCloseHandle>( |
| GetProcAddress(winhttp_handle, "WinHttpCloseHandle")); |
| pfnWinHttpGetProxyForUrl pWHGPFU = |
| reinterpret_cast<pfnWinHttpGetProxyForUrl>( |
| GetProcAddress(winhttp_handle, "WinHttpGetProxyForUrl")); |
| if (pWHO && pWHCH && pWHGPFU) { |
| if (HINTERNET hWinHttp = pWHO(ToUtf16(agent).c_str(), |
| WINHTTP_ACCESS_TYPE_NO_PROXY, |
| WINHTTP_NO_PROXY_NAME, |
| WINHTTP_NO_PROXY_BYPASS, |
| 0)) { |
| BOOL result = FALSE; |
| WINHTTP_PROXY_INFO info; |
| memset(&info, 0, sizeof(info)); |
| if (proxy->autodetect) { |
| // Use DHCP and DNS to try to find any proxy to use. |
| WINHTTP_AUTOPROXY_OPTIONS options; |
| memset(&options, 0, sizeof(options)); |
| options.fAutoLogonIfChallenged = TRUE; |
| |
| options.dwFlags |= WINHTTP_AUTOPROXY_AUTO_DETECT; |
| options.dwAutoDetectFlags |= WINHTTP_AUTO_DETECT_TYPE_DHCP |
| | WINHTTP_AUTO_DETECT_TYPE_DNS_A; |
| result = MyWinHttpGetProxyForUrl( |
| pWHGPFU, hWinHttp, ToUtf16(url).c_str(), &options, &info); |
| } |
| if (!result && !proxy->autoconfig_url.empty()) { |
| // We have the location of a proxy config file. Download it and |
| // execute it to find proxy settings for our url. |
| WINHTTP_AUTOPROXY_OPTIONS options; |
| memset(&options, 0, sizeof(options)); |
| memset(&info, 0, sizeof(info)); |
| options.fAutoLogonIfChallenged = TRUE; |
| |
| std::wstring autoconfig_url16((ToUtf16)(proxy->autoconfig_url)); |
| options.dwFlags |= WINHTTP_AUTOPROXY_CONFIG_URL; |
| options.lpszAutoConfigUrl = autoconfig_url16.c_str(); |
| |
| result = MyWinHttpGetProxyForUrl( |
| pWHGPFU, hWinHttp, ToUtf16(url).c_str(), &options, &info); |
| } |
| if (result) { |
| // Either the given auto config url was valid or auto |
| // detection found a proxy on this network. |
| if (info.lpszProxy) { |
| // TODO: Does this bypass list differ from the list |
| // retreived from GetWinHttpProxySettings earlier? |
| if (info.lpszProxyBypass) { |
| proxy->bypass_list = ToUtf8(info.lpszProxyBypass); |
| GlobalFree(info.lpszProxyBypass); |
| } else { |
| proxy->bypass_list.clear(); |
| } |
| if (!ProxyListMatch(purl, proxy->bypass_list, ';')) { |
| // Found proxy for this URL. If parsing the address turns |
| // out ok then we are successful. |
| success = ParseProxy(ToUtf8(info.lpszProxy), proxy); |
| } |
| GlobalFree(info.lpszProxy); |
| } |
| } else { |
| // We could not find any proxy for this url. |
| LOG(LS_INFO) << "No proxy detected for " << url; |
| } |
| pWHCH(hWinHttp); |
| } |
| } else { |
| LOG(LS_ERROR) << "Failed loading WinHTTP functions."; |
| success = false; |
| } |
| FreeLibrary(winhttp_handle); |
| return success; |
| } |
| |
| #if 0 // Below functions currently not used. |
| |
| bool GetJsProxySettings(const char* url, ProxyInfo* proxy) { |
| Url<char> purl(url); |
| bool success = false; |
| |
| if (HMODULE hModJS = LoadLibrary(_T("jsproxy.dll"))) { |
| pfnInternetGetProxyInfo pIGPI = |
| reinterpret_cast<pfnInternetGetProxyInfo>( |
| GetProcAddress(hModJS, "InternetGetProxyInfo")); |
| if (pIGPI) { |
| char proxy[256], host[256]; |
| memset(proxy, 0, sizeof(proxy)); |
| char * ptr = proxy; |
| DWORD proxylen = sizeof(proxy); |
| std::string surl = Utf8String(url); |
| DWORD hostlen = _snprintf(host, sizeof(host), "http%s://%S", |
| purl.secure() ? "s" : "", purl.server()); |
| if (pIGPI(surl.data(), surl.size(), host, hostlen, &ptr, &proxylen)) { |
| LOG(INFO) << "Proxy: " << proxy; |
| } else { |
| LOG_GLE(INFO) << "InternetGetProxyInfo"; |
| } |
| } |
| FreeLibrary(hModJS); |
| } |
| return success; |
| } |
| |
| bool GetWmProxySettings(const char* url, ProxyInfo* proxy) { |
| Url<char> purl(url); |
| bool success = false; |
| |
| INSNetSourceCreator * nsc = 0; |
| HRESULT hr = CoCreateInstance(CLSID_ClientNetManager, 0, CLSCTX_ALL, |
| IID_INSNetSourceCreator, (LPVOID *) &nsc); |
| if (SUCCEEDED(hr)) { |
| if (SUCCEEDED(hr = nsc->Initialize())) { |
| VARIANT dispatch; |
| VariantInit(&dispatch); |
| if (SUCCEEDED(hr = nsc->GetNetSourceAdminInterface(L"http", &dispatch))) { |
| IWMSInternalAdminNetSource * ians = 0; |
| if (SUCCEEDED(hr = dispatch.pdispVal->QueryInterface( |
| IID_IWMSInternalAdminNetSource, (LPVOID *) &ians))) { |
| _bstr_t host(purl.server()); |
| BSTR proxy = 0; |
| BOOL bProxyEnabled = FALSE; |
| DWORD port, context = 0; |
| if (SUCCEEDED(hr = ians->FindProxyForURL( |
| L"http", host, &bProxyEnabled, &proxy, &port, &context))) { |
| success = true; |
| if (bProxyEnabled) { |
| _bstr_t sproxy = proxy; |
| proxy->ptype = PT_HTTPS; |
| proxy->host = sproxy; |
| proxy->port = port; |
| } |
| } |
| SysFreeString(proxy); |
| if (FAILED(hr = ians->ShutdownProxyContext(context))) { |
| LOG(LS_INFO) << "IWMSInternalAdminNetSource::ShutdownProxyContext" |
| << "failed: " << hr; |
| } |
| ians->Release(); |
| } |
| } |
| VariantClear(&dispatch); |
| if (FAILED(hr = nsc->Shutdown())) { |
| LOG(LS_INFO) << "INSNetSourceCreator::Shutdown failed: " << hr; |
| } |
| } |
| nsc->Release(); |
| } |
| return success; |
| } |
| |
| bool GetIePerConnectionProxySettings(const char* url, ProxyInfo* proxy) { |
| Url<char> purl(url); |
| bool success = false; |
| |
| INTERNET_PER_CONN_OPTION_LIST list; |
| INTERNET_PER_CONN_OPTION options[3]; |
| memset(&list, 0, sizeof(list)); |
| memset(&options, 0, sizeof(options)); |
| |
| list.dwSize = sizeof(list); |
| list.dwOptionCount = 3; |
| list.pOptions = options; |
| options[0].dwOption = INTERNET_PER_CONN_FLAGS; |
| options[1].dwOption = INTERNET_PER_CONN_PROXY_SERVER; |
| options[2].dwOption = INTERNET_PER_CONN_PROXY_BYPASS; |
| DWORD dwSize = sizeof(list); |
| |
| if (!InternetQueryOption(0, INTERNET_OPTION_PER_CONNECTION_OPTION, &list, |
| &dwSize)) { |
| LOG(LS_INFO) << "InternetQueryOption failed: " << GetLastError(); |
| } else if ((options[0].Value.dwValue & PROXY_TYPE_PROXY) != 0) { |
| success = true; |
| if (!ProxyListMatch(purl, nonnull(options[2].Value.pszValue), _T(';'))) { |
| ParseProxy(nonnull(options[1].Value.pszValue), proxy); |
| } |
| } else if ((options[0].Value.dwValue & PROXY_TYPE_DIRECT) != 0) { |
| success = true; |
| } else { |
| LOG(LS_INFO) << "unknown internet access type: " |
| << options[0].Value.dwValue; |
| } |
| if (options[1].Value.pszValue) { |
| GlobalFree(options[1].Value.pszValue); |
| } |
| if (options[2].Value.pszValue) { |
| GlobalFree(options[2].Value.pszValue); |
| } |
| return success; |
| } |
| |
| #endif // 0 |
| |
| // Uses the InternetQueryOption function to retrieve proxy settings |
| // from the registry. This will only give us the 'static' settings, |
| // ie, not any information about auto config etc. |
| bool GetIeLanProxySettings(const char* url, ProxyInfo* proxy) { |
| Url<char> purl(url); |
| bool success = false; |
| |
| wchar_t buffer[1024]; |
| memset(buffer, 0, sizeof(buffer)); |
| INTERNET_PROXY_INFO * info = reinterpret_cast<INTERNET_PROXY_INFO *>(buffer); |
| DWORD dwSize = sizeof(buffer); |
| |
| if (!InternetQueryOption(0, INTERNET_OPTION_PROXY, info, &dwSize)) { |
| LOG(LS_INFO) << "InternetQueryOption failed: " << GetLastError(); |
| } else if (info->dwAccessType == INTERNET_OPEN_TYPE_DIRECT) { |
| success = true; |
| } else if (info->dwAccessType == INTERNET_OPEN_TYPE_PROXY) { |
| success = true; |
| if (!ProxyListMatch(purl, nonnull(reinterpret_cast<const char*>( |
| info->lpszProxyBypass)), ' ')) { |
| ParseProxy(nonnull(reinterpret_cast<const char*>(info->lpszProxy)), |
| proxy); |
| } |
| } else { |
| LOG(LS_INFO) << "unknown internet access type: " << info->dwAccessType; |
| } |
| return success; |
| } |
| |
| bool GetIeProxySettings(const char* agent, const char* url, ProxyInfo* proxy) { |
| bool success = GetWinHttpProxySettings(url, proxy); |
| if (!success) { |
| // TODO: Should always call this if no proxy were detected by |
| // GetWinHttpProxySettings? |
| // WinHttp failed. Try using the InternetOptionQuery method instead. |
| return GetIeLanProxySettings(url, proxy); |
| } |
| return true; |
| } |
| |
| #endif // WEBRTC_WIN |
| |
| #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) // WEBRTC_MAC && !defined(WEBRTC_IOS) specific implementation for reading system wide |
| // proxy settings. |
| |
| bool p_getProxyInfoForTypeFromDictWithKeys(ProxyInfo* proxy, |
| ProxyType type, |
| const CFDictionaryRef proxyDict, |
| const CFStringRef enabledKey, |
| const CFStringRef hostKey, |
| const CFStringRef portKey) { |
| // whether or not we set up the proxy info. |
| bool result = false; |
| |
| // we use this as a scratch variable for determining if operations |
| // succeeded. |
| bool converted = false; |
| |
| // the data we need to construct the SocketAddress for the proxy. |
| std::string hostname; |
| int port; |
| |
| if ((proxyDict != NULL) && |
| (CFGetTypeID(proxyDict) == CFDictionaryGetTypeID())) { |
| // CoreFoundation stuff that we'll have to get from |
| // the dictionaries and interpret or convert into more usable formats. |
| CFNumberRef enabledCFNum; |
| CFNumberRef portCFNum; |
| CFStringRef hostCFStr; |
| |
| enabledCFNum = (CFNumberRef)CFDictionaryGetValue(proxyDict, enabledKey); |
| |
| if (p_isCFNumberTrue(enabledCFNum)) { |
| // let's see if we can get the address and port. |
| hostCFStr = (CFStringRef)CFDictionaryGetValue(proxyDict, hostKey); |
| converted = p_convertHostCFStringRefToCPPString(hostCFStr, hostname); |
| if (converted) { |
| portCFNum = (CFNumberRef)CFDictionaryGetValue(proxyDict, portKey); |
| converted = p_convertCFNumberToInt(portCFNum, &port); |
| if (converted) { |
| // we have something enabled, with a hostname and a port. |
| // That's sufficient to set up the proxy info. |
| proxy->type = type; |
| proxy->address.SetIP(hostname); |
| proxy->address.SetPort(port); |
| result = true; |
| } |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| // Looks for proxy information in the given dictionary, |
| // return true if it found sufficient information to define one, |
| // false otherwise. This is guaranteed to not change the values in proxy |
| // unless a full-fledged proxy description was discovered in the dictionary. |
| // However, at the present time this does not support username or password. |
| // Checks first for a SOCKS proxy, then for HTTPS, then HTTP. |
| bool GetMacProxySettingsFromDictionary(ProxyInfo* proxy, |
| const CFDictionaryRef proxyDict) { |
| // the function result. |
| bool gotProxy = false; |
| |
| |
| // first we see if there's a SOCKS proxy in place. |
| gotProxy = p_getProxyInfoForTypeFromDictWithKeys(proxy, |
| PROXY_SOCKS5, |
| proxyDict, |
| kSCPropNetProxiesSOCKSEnable, |
| kSCPropNetProxiesSOCKSProxy, |
| kSCPropNetProxiesSOCKSPort); |
| |
| if (!gotProxy) { |
| // okay, no SOCKS proxy, let's look for https. |
| gotProxy = p_getProxyInfoForTypeFromDictWithKeys(proxy, |
| PROXY_HTTPS, |
| proxyDict, |
| kSCPropNetProxiesHTTPSEnable, |
| kSCPropNetProxiesHTTPSProxy, |
| kSCPropNetProxiesHTTPSPort); |
| if (!gotProxy) { |
| // Finally, try HTTP proxy. Note that flute doesn't |
| // differentiate between HTTPS and HTTP, hence we are using the |
| // same flute type here, ie. PROXY_HTTPS. |
| gotProxy = p_getProxyInfoForTypeFromDictWithKeys( |
| proxy, PROXY_HTTPS, proxyDict, kSCPropNetProxiesHTTPEnable, |
| kSCPropNetProxiesHTTPProxy, kSCPropNetProxiesHTTPPort); |
| } |
| } |
| return gotProxy; |
| } |
| |
| // TODO(hughv) Update keychain functions. They work on 10.8, but are depricated. |
| #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
| bool p_putPasswordInProxyInfo(ProxyInfo* proxy) { |
| bool result = true; // by default we assume we're good. |
| // for all we know there isn't any password. We'll set to false |
| // if we find a problem. |
| |
| // Ask the keychain for an internet password search for the given protocol. |
| OSStatus oss = 0; |
| SecKeychainAttributeList attrList; |
| attrList.count = 3; |
| SecKeychainAttribute attributes[3]; |
| attrList.attr = attributes; |
| |
| attributes[0].tag = kSecProtocolItemAttr; |
| attributes[0].length = sizeof(SecProtocolType); |
| SecProtocolType protocol; |
| switch (proxy->type) { |
| case PROXY_HTTPS : |
| protocol = kSecProtocolTypeHTTPS; |
| break; |
| case PROXY_SOCKS5 : |
| protocol = kSecProtocolTypeSOCKS; |
| break; |
| default : |
| LOG(LS_ERROR) << "asked for proxy password for unknown proxy type."; |
| result = false; |
| break; |
| } |
| attributes[0].data = &protocol; |
| |
| UInt32 port = proxy->address.port(); |
| attributes[1].tag = kSecPortItemAttr; |
| attributes[1].length = sizeof(UInt32); |
| attributes[1].data = &port; |
| |
| std::string ip = proxy->address.ipaddr().ToString(); |
| attributes[2].tag = kSecServerItemAttr; |
| attributes[2].length = ip.length(); |
| attributes[2].data = const_cast<char*>(ip.c_str()); |
| |
| if (result) { |
| LOG(LS_INFO) << "trying to get proxy username/password"; |
| SecKeychainSearchRef sref; |
| oss = SecKeychainSearchCreateFromAttributes(NULL, |
| kSecInternetPasswordItemClass, |
| &attrList, &sref); |
| if (0 == oss) { |
| LOG(LS_INFO) << "SecKeychainSearchCreateFromAttributes was good"; |
| // Get the first item, if there is one. |
| SecKeychainItemRef iref; |
| oss = SecKeychainSearchCopyNext(sref, &iref); |
| if (0 == oss) { |
| LOG(LS_INFO) << "...looks like we have the username/password data"; |
| // If there is, get the username and the password. |
| |
| SecKeychainAttributeInfo attribsToGet; |
| attribsToGet.count = 1; |
| UInt32 tag = kSecAccountItemAttr; |
| UInt32 format = CSSM_DB_ATTRIBUTE_FORMAT_STRING; |
| void *data; |
| UInt32 length; |
| SecKeychainAttributeList *localList; |
| |
| attribsToGet.tag = &tag; |
| attribsToGet.format = &format; |
| OSStatus copyres = SecKeychainItemCopyAttributesAndData(iref, |
| &attribsToGet, |
| NULL, |
| &localList, |
| &length, |
| &data); |
| if (0 == copyres) { |
| LOG(LS_INFO) << "...and we can pull it out."; |
| // now, we know from experimentation (sadly not from docs) |
| // that the username is in the local attribute list, |
| // and the password in the data, |
| // both without null termination but with info on their length. |
| // grab the password from the data. |
| std::string password; |
| password.append(static_cast<const char*>(data), length); |
| |
| // make the password into a CryptString |
| // huh, at the time of writing, you can't. |
| // so we'll skip that for now and come back to it later. |
| |
| // now put the username in the proxy. |
| if (1 <= localList->attr->length) { |
| proxy->username.append( |
| static_cast<const char*>(localList->attr->data), |
| localList->attr->length); |
| LOG(LS_INFO) << "username is " << proxy->username; |
| } else { |
| LOG(LS_ERROR) << "got keychain entry with no username"; |
| result = false; |
| } |
| } else { |
| LOG(LS_ERROR) << "couldn't copy info from keychain."; |
| result = false; |
| } |
| SecKeychainItemFreeAttributesAndData(localList, data); |
| } else if (errSecItemNotFound == oss) { |
| LOG(LS_INFO) << "...username/password info not found"; |
| } else { |
| // oooh, neither 0 nor itemNotFound. |
| LOG(LS_ERROR) << "Couldn't get keychain information, error code" << oss; |
| result = false; |
| } |
| } else if (errSecItemNotFound == oss) { // noop |
| } else { |
| // oooh, neither 0 nor itemNotFound. |
| LOG(LS_ERROR) << "Couldn't get keychain information, error code" << oss; |
| result = false; |
| } |
| } |
| |
| return result; |
| } |
| |
| bool GetMacProxySettings(ProxyInfo* proxy) { |
| // based on the Apple Technical Q&A QA1234 |
| // http://developer.apple.com/qa/qa2001/qa1234.html |
| CFDictionaryRef proxyDict = SCDynamicStoreCopyProxies(NULL); |
| bool result = false; |
| |
| if (proxyDict != NULL) { |
| // sending it off to another function makes it easier to unit test |
| // since we can make our own dictionary to hand to that function. |
| result = GetMacProxySettingsFromDictionary(proxy, proxyDict); |
| |
| if (result) { |
| result = p_putPasswordInProxyInfo(proxy); |
| } |
| |
| // We created the dictionary with something that had the |
| // word 'copy' in it, so we have to release it, according |
| // to the Carbon memory management standards. |
| CFRelease(proxyDict); |
| } else { |
| LOG(LS_ERROR) << "SCDynamicStoreCopyProxies failed"; |
| } |
| |
| return result; |
| } |
| #endif // WEBRTC_MAC && !defined(WEBRTC_IOS) |
| |
| #ifdef WEBRTC_IOS |
| // iOS has only http proxy |
| bool GetiOSProxySettings(ProxyInfo* proxy) { |
| |
| bool result = false; |
| |
| CFDictionaryRef proxy_dict = CFNetworkCopySystemProxySettings(); |
| if (!proxy_dict) { |
| LOG(LS_ERROR) << "CFNetworkCopySystemProxySettings failed"; |
| return false; |
| } |
| |
| CFNumberRef proxiesHTTPEnable = (CFNumberRef)CFDictionaryGetValue( |
| proxy_dict, kCFNetworkProxiesHTTPEnable); |
| if (!p_isCFNumberTrue(proxiesHTTPEnable)) { |
| CFRelease(proxy_dict); |
| return false; |
| } |
| |
| CFStringRef proxy_address = (CFStringRef)CFDictionaryGetValue( |
| proxy_dict, kCFNetworkProxiesHTTPProxy); |
| CFNumberRef proxy_port = (CFNumberRef)CFDictionaryGetValue( |
| proxy_dict, kCFNetworkProxiesHTTPPort); |
| |
| // the data we need to construct the SocketAddress for the proxy. |
| std::string hostname; |
| int port; |
| if (p_convertHostCFStringRefToCPPString(proxy_address, hostname) && |
| p_convertCFNumberToInt(proxy_port, &port)) { |
| // We have something enabled, with a hostname and a port. |
| // That's sufficient to set up the proxy info. |
| // Finally, try HTTP proxy. Note that flute doesn't |
| // differentiate between HTTPS and HTTP, hence we are using the |
| // same flute type here, ie. PROXY_HTTPS. |
| proxy->type = PROXY_HTTPS; |
| |
| proxy->address.SetIP(hostname); |
| proxy->address.SetPort(port); |
| result = true; |
| } |
| |
| // We created the dictionary with something that had the |
| // word 'copy' in it, so we have to release it, according |
| // to the Carbon memory management standards. |
| CFRelease(proxy_dict); |
| |
| return result; |
| } |
| #endif // WEBRTC_IOS |
| |
| bool AutoDetectProxySettings(const char* agent, const char* url, |
| ProxyInfo* proxy) { |
| #if defined(WEBRTC_WIN) |
| return WinHttpAutoDetectProxyForUrl(agent, url, proxy); |
| #else |
| LOG(LS_WARNING) << "Proxy auto-detection not implemented for this platform"; |
| return false; |
| #endif |
| } |
| |
| bool GetSystemDefaultProxySettings(const char* agent, const char* url, |
| ProxyInfo* proxy) { |
| #if defined(WEBRTC_WIN) |
| return GetIeProxySettings(agent, url, proxy); |
| #elif defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
| return GetMacProxySettings(proxy); |
| #elif defined(WEBRTC_IOS) |
| return GetiOSProxySettings(proxy); |
| #else |
| // TODO: Get System settings if browser is not firefox. |
| return GetFirefoxProxySettings(url, proxy); |
| #endif |
| } |
| |
| bool GetProxySettingsForUrl(const char* agent, const char* url, |
| ProxyInfo* proxy, bool long_operation) { |
| UserAgent a = GetAgent(agent); |
| bool result; |
| switch (a) { |
| case UA_FIREFOX: { |
| result = GetFirefoxProxySettings(url, proxy); |
| break; |
| } |
| #if defined(WEBRTC_WIN) |
| case UA_INTERNETEXPLORER: |
| result = GetIeProxySettings(agent, url, proxy); |
| break; |
| case UA_UNKNOWN: |
| // Agent not defined, check default browser. |
| if (IsDefaultBrowserFirefox()) { |
| result = GetFirefoxProxySettings(url, proxy); |
| } else { |
| result = GetIeProxySettings(agent, url, proxy); |
| } |
| break; |
| #endif // WEBRTC_WIN |
| default: |
| result = GetSystemDefaultProxySettings(agent, url, proxy); |
| break; |
| } |
| |
| // TODO: Consider using the 'long_operation' parameter to |
| // decide whether to do the auto detection. |
| if (result && (proxy->autodetect || |
| !proxy->autoconfig_url.empty())) { |
| // Use WinHTTP to auto detect proxy for us. |
| result = AutoDetectProxySettings(agent, url, proxy); |
| if (!result) { |
| // Either auto detection is not supported or we simply didn't |
| // find any proxy, reset type. |
| proxy->type = rtc::PROXY_NONE; |
| } |
| } |
| return result; |
| } |
| |
| } // namespace rtc |