Add WinINet backend.

src/common/HTTPS.cpp

@@ -19,6 +19,9 @@
 #ifdef HTTPS_BACKEND_ANDROID
 #	include "../android/AndroidClient.h"
 #endif
+#ifdef HTTPS_BACKEND_WININET
+#	include "../windows/WinINetClient.h"
+#endif
 
 #ifdef HTTPS_BACKEND_CURL
 	static CurlClient curlclient;
@@ -35,6 +38,9 @@
 #ifdef HTTPS_BACKEND_ANDROID
 	static AndroidClient androidclient;
 #endif
+#ifdef HTTPS_BACKEND_WININET
+	static WinINetClient wininetclient;
+#endif
 
 static HTTPSClient *clients[] = {
 #ifdef HTTPS_BACKEND_CURL
@@ -42,6 +48,10 @@ static HTTPSClient *clients[] = {
 #endif
 #ifdef HTTPS_BACKEND_OPENSSL
 	&opensslclient,
+#endif
+	// WinINet must be above SChannel
+#ifdef HTTPS_BACKEND_WININET
+	&wininetclient,
 #endif
 #ifdef HTTPS_BACKEND_SCHANNEL
 	&schannelclient,

src/windows/WinINetClient.cpp

@@ -0,0 +1,222 @@
+#include "WinINetClient.h"
+
+#ifdef HTTPS_BACKEND_WININET
+
+#include <algorithm>
+#include <stdexcept>
+#include <sstream>
+#include <vector>
+
+#include <Windows.h>
+#include <wininet.h>
+
+#include "../common/HTTPRequest.h"
+
+class LazyHInternetLoader final
+{
+public:
+	LazyHInternetLoader(): hInternet(nullptr) { }
+	~LazyHInternetLoader()
+	{
+		if (hInternet)
+			InternetCloseHandle(hInternet);
+	}
+
+	HINTERNET getInstance()
+	{
+		if (!init)
+		{
+			hInternet = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, nullptr, nullptr, 0);
+			if (hInternet)
+			{
+				// Try to enable HTTP2
+				DWORD httpProtocol = HTTP_PROTOCOL_FLAG_HTTP2;
+				InternetSetOptionA(hInternet, INTERNET_OPTION_ENABLE_HTTP_PROTOCOL, &httpProtocol, sizeof(DWORD));
+				SetLastError(0); // If it errors, ignore.
+			}
+		}
+
+		return hInternet;
+	}
+
+private:
+	bool init;
+	HINTERNET hInternet;
+};
+
+static thread_local LazyHInternetLoader hInternetCache;
+
+bool WinINetClient::valid() const
+{
+	// Allow disablement of WinINet backend.
+	const char *disabler = getenv("LUAHTTPS_DISABLE_WININET");
+	if (disabler && strcmp(disabler, "1") == 0)
+		return false;
+
+	return hInternetCache.getInstance() != nullptr;
+}
+
+HTTPSClient::Reply WinINetClient::request(const HTTPSClient::Request &req)
+{
+	Reply reply;
+	reply.responseCode = 0;
+
+	// Parse URL
+	auto parsedUrl = HTTPRequest::parseUrl(req.url);
+
+	// Default flags
+	DWORD inetFlags =
+		INTERNET_FLAG_NO_AUTH |
+		INTERNET_FLAG_NO_CACHE_WRITE |
+		INTERNET_FLAG_NO_COOKIES |
+		INTERNET_FLAG_NO_UI;
+
+	if (parsedUrl.schema == "https")
+		inetFlags |= INTERNET_FLAG_SECURE;
+	else if (parsedUrl.schema != "http")
+		return reply;
+
+	// Keep-Alive
+	auto connectHeader = req.headers.find("Connection");
+	auto headerEnd = req.headers.end();
+	if ((connectHeader != headerEnd && connectHeader->second != "close") || connectHeader == headerEnd)
+		inetFlags |= INTERNET_FLAG_KEEP_CONNECTION;
+
+	// Open internet
+	HINTERNET hInternet = hInternetCache.getInstance();
+	if (hInternet == nullptr)
+		return reply;
+
+	// Connect
+	HINTERNET hConnect = InternetConnectA(
+		hInternet,
+		parsedUrl.hostname.c_str(),
+		parsedUrl.port,
+		nullptr, nullptr,
+		INTERNET_SERVICE_HTTP,
+		INTERNET_FLAG_EXISTING_CONNECT,
+		(DWORD_PTR) this
+	);
+	if (!hConnect)
+		return reply;
+
+	std::string httpMethod = req.method;
+	std::transform(
+		httpMethod.begin(),
+		httpMethod.end(),
+		httpMethod.begin(),
+		[](char c) {return (char)toupper((unsigned char) c); }
+	);
+
+	// Open HTTP request
+	HINTERNET hHTTP = HttpOpenRequestA(
+		hConnect,
+		httpMethod.c_str(),
+		parsedUrl.query.c_str(),
+		nullptr,
+		nullptr,
+		nullptr,
+		inetFlags,
+		(DWORD_PTR) this
+	);
+	if (!hHTTP)
+	{
+		InternetCloseHandle(hConnect);
+		return reply;
+	}
+
+	// Send additional headers
+	HttpAddRequestHeadersA(hHTTP, "User-Agent:", 0, HTTP_ADDREQ_FLAG_REPLACE);
+	for (const auto &header: req.headers)
+	{
+		std::string headerString = header.first + ": " + header.second + "\r\n";
+		HttpAddRequestHeadersA(hHTTP, headerString.c_str(), headerString.length(), HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE);
+	}
+
+	// POST data
+	const char *postData = nullptr;
+	if (req.postdata.length() > 0 && (httpMethod != "GET" && httpMethod != "HEAD"))
+	{
+		char temp[48];
+		int len = sprintf(temp, "Content-Length: %u\r\n", (unsigned int) req.postdata.length());
+		postData = req.postdata.c_str();
+
+		HttpAddRequestHeadersA(hHTTP, temp, len, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE);
+	}
+
+	// Send away!
+	BOOL result = HttpSendRequestA(hHTTP, nullptr, 0, (void *) postData, (DWORD) req.postdata.length());
+	if (!result)
+	{
+		InternetCloseHandle(hHTTP);
+		InternetCloseHandle(hConnect);
+		return reply;
+	}
+
+	DWORD bufferLength = sizeof(DWORD);
+	DWORD headerCounter = 0;
+
+	// Status code
+	DWORD statusCode = 0;
+	if (!HttpQueryInfoA(hHTTP, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &statusCode, &bufferLength, &headerCounter))
+	{
+		InternetCloseHandle(hHTTP);
+		InternetCloseHandle(hConnect);
+		return reply;
+	}
+
+	// Query headers
+	std::vector<char> responseHeaders;
+	bufferLength = 0;
+	HttpQueryInfoA(hHTTP, HTTP_QUERY_RAW_HEADERS, responseHeaders.data(), &bufferLength, &headerCounter);
+	if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+	{
+		InternetCloseHandle(hHTTP);
+		InternetCloseHandle(hConnect);
+		return reply;
+	}
+
+	responseHeaders.resize(bufferLength);
+	if (!HttpQueryInfoA(hHTTP, HTTP_QUERY_RAW_HEADERS, responseHeaders.data(), &bufferLength, &headerCounter))
+	{
+		InternetCloseHandle(hHTTP);
+		InternetCloseHandle(hConnect);
+		return reply;
+	}
+
+	for (const char *headerData = responseHeaders.data(); *headerData; headerData += strlen(headerData) + 1)
+	{
+		const char *value = strchr(headerData, ':');
+		if (value)
+		{
+			ptrdiff_t keyLen = (ptrdiff_t) (value - headerData);
+			reply.headers[std::string(headerData, keyLen)] = value + 2; // +2, colon and 1 space character.
+		}
+	}
+	responseHeaders.resize(1);
+
+	// Read response
+	std::stringstream responseData;
+	for (;;)
+	{
+		constexpr DWORD BUFFER_SIZE = 4096;
+		char buffer[BUFFER_SIZE];
+		DWORD readed = 0;
+
+		if (!InternetReadFile(hHTTP, buffer, BUFFER_SIZE, &readed))
+			break;
+
+		responseData.write(buffer, readed);
+		if (readed < BUFFER_SIZE)
+			break;
+	}
+
+	reply.body = responseData.str();
+	reply.responseCode = statusCode;
+
+	InternetCloseHandle(hHTTP);
+	InternetCloseHandle(hConnect);
+	return reply;
+}
+
+#endif // HTTPS_BACKEND_WININET

src/windows/WinINetClient.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "../common/config.h"
+
+#ifdef HTTPS_BACKEND_WININET
+
+#include "../common/HTTPSClient.h"
+
+class WinINetClient: public HTTPSClient
+{
+public:
+	bool valid() const override;
+	HTTPSClient::Reply request(const HTTPSClient::Request &req) override;
+};
+
+#endif // HTTPS_BACKEND_WININET