| // TODO: Abstract this better for cross-platformability |
| |
| #ifdef _WINDOWS |
| #include "talk/base/win32.h" |
| #include <shlobj.h> |
| #endif |
| |
| #include "talk/base/httpcommon.h" |
| #include "talk/base/httpcommon-inl.h" |
| #include "talk/base/proxydetect.h" |
| #include "talk/base/stringutils.h" |
| #include "talk/base/basicdefs.h" |
| |
| #if _WINDOWS |
| #define _TRY_FIREFOX 1 |
| #define _TRY_WINHTTP 1 |
| #define _TRY_JSPROXY 0 |
| #define _TRY_WM_FINDPROXY 0 |
| #define _TRY_IE_LAN_SETTINGS 1 |
| #endif // _WINDOWS |
| |
| #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 |
| |
| using namespace talk_base; |
| |
| ////////////////////////////////////////////////////////////////////// |
| // Utility Functions |
| ////////////////////////////////////////////////////////////////////// |
| |
| #ifdef _WINDOWS |
| #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 // _WINDOWS |
| |
| ////////////////////////////////////////////////////////////////////// |
| // GetProxySettingsForUrl |
| ////////////////////////////////////////////////////////////////////// |
| |
| bool WildMatch(const char * target, const char * pattern) { |
| while (*pattern) { |
| if (*pattern == '*') { |
| if (!*++pattern) { |
| return true; |
| } |
| while (*target) { |
| if ((toupper(*pattern) == toupper(*target)) && WildMatch(target + 1, pattern + 1)) { |
| return true; |
| } |
| ++target; |
| } |
| return false; |
| } else { |
| if (toupper(*pattern) != toupper(*target)) { |
| return false; |
| } |
| ++target; |
| ++pattern; |
| } |
| } |
| return !*target; |
| } |
| |
| 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 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 mask = (m == 0) ? 0 : (~0UL) << (32 - m); |
| SocketAddress addr(url.server()); |
| return !addr.IsUnresolved() && ((addr.ip() & mask) == (ip & mask)); |
| } |
| |
| // .foo.com |
| if (*item == '.') { |
| size_t hostlen = url.server().length(); |
| return (hostlen > len) |
| && (stricmp(url.server().c_str() + (hostlen - len), item) == 0); |
| } |
| |
| // localhost or www.*.com |
| if (!WildMatch(url.server().c_str(), item)) |
| return false; |
| |
| return true; |
| } |
| |
| bool ProxyListMatch(const Url<char>& url, const std::string& slist, char sep) { |
| const size_t BUFSIZE = 256; |
| char buffer[BUFSIZE]; |
| const char* list = slist.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[4] = { 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 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 (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>(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((int)port); |
| } |
| } |
| |
| return (proxy.type != PROXY_NONE); |
| } |
| |
| #if _WINDOWS |
| 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; |
| |
| wchar_t* value = NULL; |
| DWORD size, type; |
| result = RegQueryValueEx(key, L"", 0, &type, NULL, &size); |
| if (REG_SZ != type) { |
| result = ERROR_ACCESS_DENIED; // Any error is fine |
| } else if (ERROR_SUCCESS == result) { |
| value = new wchar_t[size+1]; |
| BYTE* buffer = reinterpret_cast<BYTE*>(value); |
| result = RegQueryValueEx(key, L"", 0, &type, buffer, &size); |
| } |
| RegCloseKey(key); |
| |
| bool success = false; |
| if (ERROR_SUCCESS == result) { |
| 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; |
| return success; |
| } |
| #endif |
| |
| #if _TRY_FIREFOX |
| |
| #define USE_FIREFOX_PROFILES_INI 1 |
| |
| bool GetDefaultFirefoxProfile(std::wstring* profile) { |
| ASSERT(NULL != profile); |
| |
| wchar_t path[MAX_PATH]; |
| if (SHGetFolderPath(0, CSIDL_APPDATA, 0, SHGFP_TYPE_CURRENT, path) != S_OK) |
| return false; |
| |
| std::wstring profile_root(path); |
| profile_root.append(L"\\Mozilla\\Firefox\\"); |
| |
| #if USE_FIREFOX_PROFILES_INI |
| std::wstring tmp(profile_root); |
| tmp.append(L"profiles.ini"); |
| |
| FILE * fp = _wfopen(tmp.c_str(), L"rb"); |
| if (!fp) |
| return false; |
| |
| // [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 |
| |
| std::wstring candidate; |
| bool relative = true; |
| |
| char buffer[1024]; |
| while (fgets(buffer, sizeof(buffer), fp)) { |
| size_t len = strlen(buffer); |
| while ((len > 0) && isspace(buffer[len-1])) |
| buffer[--len] = 0; |
| if (buffer[0] == '[') { |
| relative = true; |
| candidate.clear(); |
| } else if (strnicmp(buffer, "IsRelative=", 11) == 0) { |
| relative = (buffer[11] != '0'); |
| } else if (strnicmp(buffer, "Path=", 5) == 0) { |
| if (relative) { |
| candidate = profile_root; |
| } else { |
| candidate.clear(); |
| } |
| candidate.append(ToUtf16(buffer + 5)); |
| candidate.append(L"\\"); |
| } else if (strnicmp(buffer, "Default=", 8) == 0) { |
| if ((buffer[8] != '0') && !candidate.empty()) { |
| break; |
| } |
| } |
| } |
| fclose(fp); |
| if (candidate.empty()) |
| return false; |
| *profile = candidate; |
| |
| #else // !USE_FIREFOX_PROFILES_INI |
| std::wstring tmp(profile_root); |
| tmp.append(L"Profiles\\*.default"); |
| WIN32_FIND_DATA fdata; |
| HANDLE hFind = FindFirstFile(tmp.c_str(), &fdata); |
| if (hFind == INVALID_HANDLE_VALUE) |
| return false; |
| |
| profile->assign(profile_root); |
| profile->append(L"Profiles\\"); |
| profile->append(fdata.cFileName); |
| profile->append(L"\\"); |
| FindClose(hFind); |
| #endif // !USE_FIREFOX_PROFILES_INI |
| |
| return true; |
| } |
| |
| 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_; |
| }; |
| |
| bool ReadFirefoxPrefs(const std::wstring& filename, |
| const char * prefix, |
| StringMap& settings) { |
| FILE * fp = _wfopen(filename.c_str(), L"rb"); |
| if (!fp) |
| return false; |
| |
| size_t prefix_len = strlen(prefix); |
| bool overlong_line = false; |
| |
| char buffer[1024]; |
| while (fgets(buffer, sizeof(buffer), fp)) { |
| size_t len = strlen(buffer); |
| bool missing_newline = (len > 0) && (buffer[len-1] != '\n'); |
| |
| if (missing_newline) { |
| overlong_line = true; |
| continue; |
| } else if (overlong_line) { |
| LOG_F(LS_INFO) << "Skipping long line"; |
| overlong_line = false; |
| continue; |
| } |
| |
| while ((len > 0) && isspace(buffer[len-1])) |
| buffer[--len] = 0; |
| |
| // Skip blank lines |
| if ((len == 0) || (buffer[0] == '#') |
| || (strncmp(buffer, "/*", 2) == 0) |
| || (strncmp(buffer, " *", 2) == 0)) |
| continue; |
| |
| 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 << "]"; |
| } |
| } |
| fclose(fp); |
| return true; |
| } |
| #endif // _TRY_FIREFOX |
| |
| #ifdef WIN32 |
| 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) { |
| LOG_GLEM(LERROR,WINHTTP) << "WinHttpGetProxyForUrl faulted!!"; |
| } |
| #else |
| success = pWHGPFU(hWinHttp, url, options, info); |
| #endif |
| |
| return success; |
| } |
| #endif |
| |
| bool GetProxySettingsForUrl(const char* agent, const char* url, |
| ProxyInfo& proxy, |
| bool long_operation) { |
| bool success = false; |
| Url<char> purl(url); |
| |
| #if 0 |
| assert( WildMatch(_T("A.B.C.D"), _T("a.b.c.d"))); |
| assert( WildMatch(_T("127.0.0.1"), _T("12*.0.*1"))); |
| assert(!WildMatch(_T("127.0.0.0"), _T("12*.0.*1"))); |
| assert(!WildMatch(_T("127.0.0.0"), _T("12*.0.*1"))); |
| assert( WildMatch(_T("127.1.0.21"), _T("12*.0.*1"))); |
| assert(!WildMatch(_T("127.1.1.21"), _T("12*.0.*1"))); |
| purl = PUrl(_T("http://a.b.c:500/")); |
| wchar_t item[256]; |
| _tcscpy(item, _T("a.b.c")); |
| assert( ProxyItemMatch(purl, item, _tcslen(item))); |
| _tcscpy(item, _T("a.x.c")); |
| assert(!ProxyItemMatch(purl, item, _tcslen(item))); |
| _tcscpy(item, _T("a.b.*")); |
| assert( ProxyItemMatch(purl, item, _tcslen(item))); |
| _tcscpy(item, _T("a.x.*")); |
| assert(!ProxyItemMatch(purl, item, _tcslen(item))); |
| _tcscpy(item, _T(".b.c")); |
| assert( ProxyItemMatch(purl, item, _tcslen(item))); |
| _tcscpy(item, _T(".x.c")); |
| assert(!ProxyItemMatch(purl, item, _tcslen(item))); |
| _tcscpy(item, _T("a.b.c:500")); |
| assert( ProxyItemMatch(purl, item, _tcslen(item))); |
| _tcscpy(item, _T("a.b.c:501")); |
| assert(!ProxyItemMatch(purl, item, _tcslen(item))); |
| purl = PUrl(_T("http://1.2.3.4/")); |
| _tcscpy(item, _T("1.2.3.4")); |
| assert( ProxyItemMatch(purl, item, _tcslen(item))); |
| _tcscpy(item, _T("1.2.3.5")); |
| assert(!ProxyItemMatch(purl, item, _tcslen(item))); |
| _tcscpy(item, _T("1.2.3.5/31")); |
| assert( ProxyItemMatch(purl, item, _tcslen(item))); |
| _tcscpy(item, _T("1.2.3.5/32")); |
| assert(!ProxyItemMatch(purl, item, _tcslen(item))); |
| #endif |
| |
| bool autoconfig = false; |
| bool use_firefox = false; |
| std::string autoconfig_url; |
| |
| #if _TRY_FIREFOX |
| use_firefox = IsDefaultBrowserFirefox(); |
| |
| if (use_firefox) { |
| std::wstring tmp; |
| if (GetDefaultFirefoxProfile(&tmp)) { |
| bool complete = true; |
| |
| StringMap settings; |
| tmp.append(L"prefs.js"); |
| if (ReadFirefoxPrefs(tmp, "network.proxy.", settings)) { |
| success = true; |
| if (settings.Get("type") == "1") { |
| if (ProxyListMatch(purl, settings.Get("no_proxies_on", "localhost, 127.0.0.1").c_str(), ',')) { |
| // 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") { |
| complete = success = false; |
| autoconfig_url = settings.Get("autoconfig_url").c_str(); |
| } else if (settings.Get("type") == "4") { |
| complete = success = false; |
| autoconfig = true; |
| } |
| } |
| if (complete) { // Otherwise fall through to IE autoproxy code |
| return success; |
| } |
| } |
| } |
| #endif // _TRY_FIREFOX |
| |
| #if _TRY_WINHTTP |
| if (!success) { |
| if (HMODULE hModWH = LoadLibrary(L"winhttp.dll")) { |
| pfnWinHttpOpen pWHO = reinterpret_cast<pfnWinHttpOpen>(GetProcAddress(hModWH, "WinHttpOpen")); |
| pfnWinHttpCloseHandle pWHCH = reinterpret_cast<pfnWinHttpCloseHandle>(GetProcAddress(hModWH, "WinHttpCloseHandle")); |
| pfnWinHttpGetProxyForUrl pWHGPFU = reinterpret_cast<pfnWinHttpGetProxyForUrl>(GetProcAddress(hModWH, "WinHttpGetProxyForUrl")); |
| pfnWinHttpGetIEProxyConfig pWHGIEPC = reinterpret_cast<pfnWinHttpGetIEProxyConfig>(GetProcAddress(hModWH, "WinHttpGetIEProxyConfigForCurrentUser")); |
| if (pWHO && pWHCH && pWHGPFU && pWHGIEPC) { |
| WINHTTP_CURRENT_USER_IE_PROXY_CONFIG iecfg; |
| memset(&iecfg, 0, sizeof(iecfg)); |
| if (!use_firefox && !pWHGIEPC(&iecfg)) { |
| LOG_GLEM(LERROR,WINHTTP) << "WinHttpGetIEProxyConfigForCurrentUser"; |
| } else { |
| success = true; |
| if (!use_firefox) { |
| if (iecfg.fAutoDetect) { |
| autoconfig = true; |
| } |
| if (iecfg.lpszAutoConfigUrl) { |
| autoconfig_url = ToUtf8(iecfg.lpszAutoConfigUrl); |
| } |
| } |
| if (!long_operation) { |
| // Unless we perform this operation in the background, don't allow |
| // it to take a long time. |
| autoconfig = false; |
| } |
| if (autoconfig || !autoconfig_url.empty()) { |
| if (HINTERNET hWinHttp = pWHO(ToUtf16(agent).c_str(), |
| WINHTTP_ACCESS_TYPE_NO_PROXY, |
| WINHTTP_NO_PROXY_NAME, |
| WINHTTP_NO_PROXY_BYPASS, |
| 0)) { |
| WINHTTP_AUTOPROXY_OPTIONS options; |
| memset(&options, 0, sizeof(options)); |
| if (autoconfig) { |
| options.dwFlags |= WINHTTP_AUTOPROXY_AUTO_DETECT; |
| options.dwAutoDetectFlags |= WINHTTP_AUTO_DETECT_TYPE_DHCP |
| | WINHTTP_AUTO_DETECT_TYPE_DNS_A; |
| } |
| std::wstring autoconfig_url16((ToUtf16)(autoconfig_url)); |
| if (!autoconfig_url.empty()) { |
| options.dwFlags |= WINHTTP_AUTOPROXY_CONFIG_URL; |
| options.lpszAutoConfigUrl = autoconfig_url16.c_str(); |
| } |
| options.fAutoLogonIfChallenged = TRUE; |
| WINHTTP_PROXY_INFO info; |
| memset(&info, 0, sizeof(info)); |
| |
| BOOL success = MyWinHttpGetProxyForUrl(pWHGPFU, |
| hWinHttp, ToUtf16(url).c_str(), &options, &info); |
| |
| if (!success) { |
| LOG_GLEM(LERROR,WINHTTP) << "WinHttpGetProxyForUrl"; |
| } else { |
| if (iecfg.lpszProxy) |
| GlobalFree(iecfg.lpszProxy); |
| if (iecfg.lpszProxyBypass) |
| GlobalFree(iecfg.lpszProxyBypass); |
| iecfg.lpszProxy = info.lpszProxy; |
| iecfg.lpszProxyBypass = info.lpszProxyBypass; |
| } |
| pWHCH(hWinHttp); |
| } |
| } |
| if (!ProxyListMatch(purl, ToUtf8(nonnull(iecfg.lpszProxyBypass)), ' ')) { |
| ParseProxy(ToUtf8(nonnull(iecfg.lpszProxy)), proxy); |
| } |
| if (iecfg.lpszAutoConfigUrl) |
| GlobalFree(iecfg.lpszAutoConfigUrl); |
| if (iecfg.lpszProxy) |
| GlobalFree(iecfg.lpszProxy); |
| if (iecfg.lpszProxyBypass) |
| GlobalFree(iecfg.lpszProxyBypass); |
| } |
| } |
| FreeLibrary(hModWH); |
| } |
| } |
| #endif // _TRY_WINHTTP |
| |
| #if _TRY_JSPROXY |
| if (!success) { |
| 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); |
| } |
| } |
| #endif // _TRY_JSPROXY |
| |
| #if _TRY_WM_FINDPROXY |
| if (!success) { |
| 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(); |
| } |
| } |
| #endif // _TRY_WM_FINDPROXY |
| |
| #if _TRY_IE_LAN_SETTINGS |
| if (!success) { |
| 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; |
| } |
| } |
| #endif // _TRY_IE_LAN_SETTINGS |
| |
| #if 0 |
| if (!success) { |
| 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); |
| } |
| } |
| #endif // 0 |
| |
| return success; |
| } |
