--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/network/kernel/qnetworkproxy_win.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,412 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtNetwork module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qnetworkproxy.h"
+
+#ifndef QT_NO_NETWORKPROXY
+
+#include <qmutex.h>
+#include <qstringlist.h>
+#include <qregexp.h>
+#include <qurl.h>
+
+#include <string.h>
+#include <qt_windows.h>
+#include <wininet.h>
+
+/*
+ * Information on the WinHTTP DLL:
+ * http://msdn.microsoft.com/en-us/library/aa384122(VS.85).aspx example for WPAD
+ *
+ * http://msdn.microsoft.com/en-us/library/aa384097(VS.85).aspx WinHttpGetProxyForUrl
+ * http://msdn.microsoft.com/en-us/library/aa384096(VS.85).aspx WinHttpGetIEProxyConfigForCurrentUs
+ * http://msdn.microsoft.com/en-us/library/aa384095(VS.85).aspx WinHttpGetDefaultProxyConfiguration
+ */
+
+// We don't want to include winhttp.h because that's not
+// present in some Windows SDKs (I don't know why)
+// So, instead, copy the definitions here
+
+typedef struct {
+ DWORD dwFlags;
+ DWORD dwAutoDetectFlags;
+ LPCWSTR lpszAutoConfigUrl;
+ LPVOID lpvReserved;
+ DWORD dwReserved;
+ BOOL fAutoLogonIfChallenged;
+} WINHTTP_AUTOPROXY_OPTIONS;
+
+typedef struct {
+ DWORD dwAccessType;
+ LPWSTR lpszProxy;
+ LPWSTR lpszProxyBypass;
+} WINHTTP_PROXY_INFO;
+
+typedef struct {
+ BOOL fAutoDetect;
+ LPWSTR lpszAutoConfigUrl;
+ LPWSTR lpszProxy;
+ LPWSTR lpszProxyBypass;
+} WINHTTP_CURRENT_USER_IE_PROXY_CONFIG;
+
+#define WINHTTP_AUTOPROXY_AUTO_DETECT 0x00000001
+#define WINHTTP_AUTOPROXY_CONFIG_URL 0x00000002
+
+#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
+
+QT_BEGIN_NAMESPACE
+
+typedef BOOL (WINAPI * PtrWinHttpGetProxyForUrl)(HINTERNET, LPCWSTR, WINHTTP_AUTOPROXY_OPTIONS*, WINHTTP_PROXY_INFO*);
+typedef HINTERNET (WINAPI * PtrWinHttpOpen)(LPCWSTR, DWORD, LPCWSTR, LPCWSTR,DWORD);
+typedef BOOL (WINAPI * PtrWinHttpGetDefaultProxyConfiguration)(WINHTTP_PROXY_INFO*);
+typedef BOOL (WINAPI * PtrWinHttpGetIEProxyConfigForCurrentUser)(WINHTTP_CURRENT_USER_IE_PROXY_CONFIG*);
+typedef BOOL (WINAPI * PtrWinHttpCloseHandle)(HINTERNET);
+static PtrWinHttpGetProxyForUrl ptrWinHttpGetProxyForUrl = 0;
+static PtrWinHttpOpen ptrWinHttpOpen = 0;
+static PtrWinHttpGetDefaultProxyConfiguration ptrWinHttpGetDefaultProxyConfiguration = 0;
+static PtrWinHttpGetIEProxyConfigForCurrentUser ptrWinHttpGetIEProxyConfigForCurrentUser = 0;
+static PtrWinHttpCloseHandle ptrWinHttpCloseHandle = 0;
+
+
+static QStringList splitSpaceSemicolon(const QString &source)
+{
+ QStringList list;
+ int start = 0;
+ int end;
+ while (true) {
+ int space = source.indexOf(QLatin1Char(' '), start);
+ int semicolon = source.indexOf(QLatin1Char(';'), start);
+ end = space;
+ if (semicolon != -1 && (end == -1 || semicolon < end))
+ end = semicolon;
+
+ if (end == -1) {
+ if (start != source.length())
+ list.append(source.mid(start));
+ return list;
+ }
+ if (start != end)
+ list.append(source.mid(start, end - start));
+ start = end + 1;
+ }
+ return list;
+}
+
+static bool isBypassed(const QString &host, const QStringList &bypassList)
+{
+ if (host.isEmpty())
+ return true;
+
+ bool isSimple = !host.contains(QLatin1Char('.')) && !host.contains(QLatin1Char(':'));
+
+ QHostAddress ipAddress;
+ bool isIpAddress = ipAddress.setAddress(host);
+
+ // does it match the list of exclusions?
+ foreach (const QString &entry, bypassList) {
+ if (isSimple && entry == QLatin1String("<local>"))
+ return true;
+ if (isIpAddress && ipAddress.isInSubnet(QHostAddress::parseSubnet(entry))) {
+ return true; // excluded
+ } else {
+ // do wildcard matching
+ QRegExp rx(entry, Qt::CaseInsensitive, QRegExp::Wildcard);
+ if (rx.exactMatch(host))
+ return true;
+ }
+ }
+
+ // host was not excluded
+ return false;
+}
+
+static QList<QNetworkProxy> parseServerList(const QNetworkProxyQuery &query, const QStringList &proxyList)
+{
+ // Reference documentation from Microsoft:
+ // http://msdn.microsoft.com/en-us/library/aa383912(VS.85).aspx
+ //
+ // According to the website, the proxy server list is
+ // one or more of the space- or semicolon-separated strings in the format:
+ // ([<scheme>=][<scheme>"://"]<server>[":"<port>])
+
+ QList<QNetworkProxy> result;
+ foreach (const QString &entry, proxyList) {
+ int server = 0;
+
+ int pos = entry.indexOf(QLatin1Char('='));
+ if (pos != -1) {
+ QStringRef scheme = entry.leftRef(pos);
+ if (scheme != query.protocolTag())
+ continue;
+
+ server = pos + 1;
+ }
+
+ QNetworkProxy::ProxyType proxyType = QNetworkProxy::HttpProxy;
+ quint16 port = 8080;
+
+ pos = entry.indexOf(QLatin1String("://"), server);
+ if (pos != -1) {
+ QStringRef scheme = entry.midRef(server, pos - server);
+ if (scheme == QLatin1String("http") || scheme == QLatin1String("https")) {
+ // no-op
+ // defaults are above
+ } else if (scheme == QLatin1String("socks") || scheme == QLatin1String("socks5")) {
+ proxyType = QNetworkProxy::Socks5Proxy;
+ port = 1080;
+ } else {
+ // unknown proxy type
+ continue;
+ }
+
+ server = pos + 3;
+ }
+
+ pos = entry.indexOf(QLatin1Char(':'), server);
+ if (pos != -1) {
+ bool ok;
+ uint value = entry.mid(pos + 1).toUInt(&ok);
+ if (!ok || value > 65535)
+ continue; // invalid port number
+
+ port = value;
+ } else {
+ pos = entry.length();
+ }
+
+ result << QNetworkProxy(proxyType, entry.mid(server, pos - server), port);
+ }
+
+ return result;
+}
+
+class QWindowsSystemProxy
+{
+public:
+ QWindowsSystemProxy();
+ ~QWindowsSystemProxy();
+ void init();
+
+ QMutex mutex;
+
+ HINTERNET hHttpSession;
+ WINHTTP_AUTOPROXY_OPTIONS autoProxyOptions;
+
+ QString autoConfigUrl;
+ QStringList proxyServerList;
+ QStringList proxyBypass;
+ QList<QNetworkProxy> defaultResult;
+
+ bool initialized;
+ bool functional;
+ bool isAutoConfig;
+};
+
+Q_GLOBAL_STATIC(QWindowsSystemProxy, systemProxy)
+
+QWindowsSystemProxy::QWindowsSystemProxy()
+ : initialized(false), functional(false), isAutoConfig(false)
+{
+ defaultResult << QNetworkProxy::NoProxy;
+}
+
+QWindowsSystemProxy::~QWindowsSystemProxy()
+{
+ if (hHttpSession)
+ ptrWinHttpCloseHandle(hHttpSession);
+}
+
+void QWindowsSystemProxy::init()
+{
+ if (initialized)
+ return;
+ initialized = true;
+
+#ifdef Q_OS_WINCE
+ // Windows CE does not have any of the following API
+ return;
+#else
+ // load the winhttp.dll library
+ HINSTANCE winhttpHnd = LoadLibrary(L"winhttp");
+ if (!winhttpHnd)
+ return; // failed to load
+
+ ptrWinHttpOpen = (PtrWinHttpOpen)GetProcAddress(winhttpHnd, "WinHttpOpen");
+ ptrWinHttpCloseHandle = (PtrWinHttpCloseHandle)GetProcAddress(winhttpHnd, "WinHttpCloseHandle");
+ ptrWinHttpGetProxyForUrl = (PtrWinHttpGetProxyForUrl)GetProcAddress(winhttpHnd, "WinHttpGetProxyForUrl");
+ ptrWinHttpGetDefaultProxyConfiguration = (PtrWinHttpGetDefaultProxyConfiguration)GetProcAddress(winhttpHnd, "WinHttpGetDefaultProxyConfiguration");
+ ptrWinHttpGetIEProxyConfigForCurrentUser = (PtrWinHttpGetIEProxyConfigForCurrentUser)GetProcAddress(winhttpHnd, "WinHttpGetIEProxyConfigForCurrentUser");
+
+ // Try to obtain the Internet Explorer configuration.
+ WINHTTP_CURRENT_USER_IE_PROXY_CONFIG ieProxyConfig;
+ if (ptrWinHttpGetIEProxyConfigForCurrentUser(&ieProxyConfig)) {
+ if (ieProxyConfig.lpszAutoConfigUrl) {
+ autoConfigUrl = QString::fromWCharArray(ieProxyConfig.lpszAutoConfigUrl);
+ GlobalFree(ieProxyConfig.lpszAutoConfigUrl);
+ }
+ if (ieProxyConfig.lpszProxy) {
+ proxyServerList << QString::fromWCharArray(ieProxyConfig.lpszProxy);
+ GlobalFree(ieProxyConfig.lpszProxy);
+ }
+ if (ieProxyConfig.lpszProxyBypass) {
+ proxyBypass = splitSpaceSemicolon(QString::fromWCharArray(ieProxyConfig.lpszProxyBypass));
+ GlobalFree(ieProxyConfig.lpszProxyBypass);
+ }
+ }
+
+ hHttpSession = NULL;
+ if (ieProxyConfig.fAutoDetect || !autoConfigUrl.isEmpty()) {
+ // using proxy autoconfiguration
+ proxyServerList.clear();
+ proxyBypass.clear();
+
+ // open the handle and obtain the options
+ hHttpSession = ptrWinHttpOpen(L"Qt System Proxy access/1.0",
+ WINHTTP_ACCESS_TYPE_NO_PROXY,
+ WINHTTP_NO_PROXY_NAME,
+ WINHTTP_NO_PROXY_BYPASS,
+ 0);
+ if (!hHttpSession)
+ return;
+
+ isAutoConfig = true;
+ memset(&autoProxyOptions, 0, sizeof autoProxyOptions);
+ autoProxyOptions.fAutoLogonIfChallenged = true;
+ if (ieProxyConfig.fAutoDetect) {
+ autoProxyOptions.dwFlags = WINHTTP_AUTOPROXY_AUTO_DETECT;
+ autoProxyOptions.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DHCP |
+ WINHTTP_AUTO_DETECT_TYPE_DNS_A;
+ } else {
+ autoProxyOptions.dwFlags = WINHTTP_AUTOPROXY_CONFIG_URL;
+ autoProxyOptions.lpszAutoConfigUrl = (LPCWSTR)autoConfigUrl.utf16();
+ }
+ } else {
+ // not auto-detected
+ // attempt to get the static configuration instead
+ WINHTTP_PROXY_INFO proxyInfo;
+ if (ptrWinHttpGetDefaultProxyConfiguration(&proxyInfo) &&
+ proxyInfo.dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY) {
+ // we got information from the registry
+ // overwrite the IE configuration, if any
+
+ proxyBypass = splitSpaceSemicolon(QString::fromWCharArray(proxyInfo.lpszProxyBypass));
+ proxyServerList = splitSpaceSemicolon(QString::fromWCharArray(proxyInfo.lpszProxy));
+ }
+
+ if (proxyInfo.lpszProxy)
+ GlobalFree(proxyInfo.lpszProxy);
+ if (proxyInfo.lpszProxyBypass)
+ GlobalFree(proxyInfo.lpszProxyBypass);
+ }
+
+ functional = isAutoConfig || !proxyServerList.isEmpty();
+#endif
+}
+
+QList<QNetworkProxy> QNetworkProxyFactory::systemProxyForQuery(const QNetworkProxyQuery &query)
+{
+ QWindowsSystemProxy *sp = systemProxy();
+ if (!sp)
+ return QList<QNetworkProxy>() << QNetworkProxy();
+
+ QMutexLocker locker(&sp->mutex);
+ sp->init();
+ if (!sp->functional)
+ return sp->defaultResult;
+
+ if (sp->isAutoConfig) {
+ WINHTTP_PROXY_INFO proxyInfo;
+
+ // try to get the proxy config for the URL
+ QUrl url = query.url();
+ // url could be empty, e.g. from QNetworkProxy::applicationProxy(), that's fine,
+ // we'll still ask for the proxy.
+ // But for a file url, we know we don't need one.
+ if (url.scheme() == QLatin1String("file") || url.scheme() == QLatin1String("qrc"))
+ return sp->defaultResult;
+ if (query.queryType() != QNetworkProxyQuery::UrlRequest) {
+ // change the scheme to https, maybe it'll work
+ url.setScheme(QLatin1String("https"));
+ }
+ if (ptrWinHttpGetProxyForUrl(sp->hHttpSession,
+ (LPCWSTR)url.toString().utf16(),
+ &sp->autoProxyOptions,
+ &proxyInfo)) {
+ // yes, we got a config for this URL
+ QString proxyBypass = QString::fromWCharArray(proxyInfo.lpszProxyBypass);
+ QStringList proxyServerList = splitSpaceSemicolon(QString::fromWCharArray(proxyInfo.lpszProxy));
+ if (proxyInfo.lpszProxy)
+ GlobalFree(proxyInfo.lpszProxy);
+ if (proxyInfo.lpszProxyBypass)
+ GlobalFree(proxyInfo.lpszProxyBypass);
+
+ if (isBypassed(query.peerHostName(), splitSpaceSemicolon(proxyBypass)))
+ return sp->defaultResult;
+ return parseServerList(query, proxyServerList);
+ }
+
+ // GetProxyForUrl failed
+ return sp->defaultResult;
+ }
+
+ // static configuration
+ if (isBypassed(query.peerHostName(), sp->proxyBypass))
+ return sp->defaultResult;
+
+ QList<QNetworkProxy> result = parseServerList(query, sp->proxyServerList);
+ // In some cases, this was empty. See SF task 00062670
+ if (result.isEmpty())
+ return sp->defaultResult;
+
+ return result;
+}
+
+QT_END_NAMESPACE
+
+#endif