261 lines
8.8 KiB
C++
261 lines
8.8 KiB
C++
#if defined(_MSC_VER)
|
|
|
|
#include "WinHttpClient.h"
|
|
#include <sstream>
|
|
#include <iostream>
|
|
#include <cpp-utils/assert/assert.h>
|
|
#include <cpp-utils/data/Data.h>
|
|
#include <codecvt>
|
|
#include <Windows.h>
|
|
#include <Winhttp.h>
|
|
#include <VersionHelpers.h>
|
|
|
|
using boost::none;
|
|
using boost::optional;
|
|
using std::string;
|
|
using std::wstring;
|
|
using std::wstring_convert;
|
|
using std::ostringstream;
|
|
|
|
namespace cpputils {
|
|
|
|
namespace {
|
|
struct HttpHandleRAII final {
|
|
HINTERNET handle;
|
|
|
|
HttpHandleRAII(HINTERNET handle_) : handle(handle_) {}
|
|
|
|
HttpHandleRAII(HttpHandleRAII&& rhs) : handle(rhs.handle) {
|
|
rhs.handle = nullptr;
|
|
}
|
|
|
|
~HttpHandleRAII() {
|
|
if (nullptr != handle) {
|
|
BOOL success = WinHttpCloseHandle(handle);
|
|
if (!success) {
|
|
throw std::runtime_error("Error calling WinHttpCloseHandle. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
}
|
|
}
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(HttpHandleRAII);
|
|
};
|
|
|
|
URL_COMPONENTS parse_url(const wstring &url) {
|
|
URL_COMPONENTS result;
|
|
result.dwStructSize = sizeof(result);
|
|
// Declare fields we want. Setting a field to nullptr and the length to non-zero means the field will be returned.
|
|
result.lpszScheme = nullptr;
|
|
result.dwSchemeLength = 1;
|
|
result.lpszHostName = nullptr;
|
|
result.dwHostNameLength = 1;
|
|
result.lpszUserName = nullptr;
|
|
result.dwUserNameLength = 1;
|
|
result.lpszPassword = nullptr;
|
|
result.dwPasswordLength = 1;
|
|
result.lpszUrlPath = nullptr;
|
|
result.dwUrlPathLength = 1;
|
|
result.lpszExtraInfo = nullptr;
|
|
result.dwExtraInfoLength = 1;
|
|
|
|
BOOL success = WinHttpCrackUrl(url.c_str(), url.size(), ICU_REJECT_USERPWD, &result);
|
|
if (!success) {
|
|
throw std::runtime_error("Error parsing url '" + wstring_convert<std::codecvt_utf8_utf16<wchar_t>>().to_bytes(url) + "'. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
INTERNET_PORT get_port_from_url(const URL_COMPONENTS& parsedUrl) {
|
|
wstring scheme_str(parsedUrl.lpszScheme, parsedUrl.dwSchemeLength);
|
|
string s_(wstring_convert < std::codecvt_utf8_utf16<wchar_t>>().to_bytes(scheme_str));
|
|
if (parsedUrl.nScheme == INTERNET_SCHEME_HTTP) {
|
|
ASSERT(scheme_str == L"http", "Scheme mismatch");
|
|
if (parsedUrl.nPort != 80) {
|
|
throw std::runtime_error("We don't support non-default ports");
|
|
}
|
|
return INTERNET_DEFAULT_HTTP_PORT;
|
|
}
|
|
else if (parsedUrl.nScheme == INTERNET_SCHEME_HTTPS) {
|
|
ASSERT(scheme_str == L"https", "Scheme mismatch");
|
|
if (parsedUrl.nPort != 443) {
|
|
throw std::runtime_error("We don't support non-default ports");
|
|
}
|
|
return INTERNET_DEFAULT_HTTPS_PORT;
|
|
}
|
|
else {
|
|
throw std::runtime_error("Unsupported scheme: " + wstring_convert<std::codecvt_utf8_utf16<wchar_t>>().to_bytes(scheme_str));
|
|
}
|
|
}
|
|
|
|
class Request final {
|
|
public:
|
|
Request(HttpHandleRAII request) : request_(std::move(request)) {}
|
|
|
|
void set_redirect_policy(DWORD redirectPolicy) {
|
|
BOOL success = WinHttpSetOption(request_.handle, WINHTTP_OPTION_REDIRECT_POLICY, &redirectPolicy, sizeof(redirectPolicy));
|
|
if (!success) {
|
|
throw std::runtime_error("Error calling WinHttpSetOption. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
}
|
|
|
|
void set_timeouts(long timeoutMsec) {
|
|
// TODO Timeout should be a total timeout, not per step as we're doing it here.
|
|
BOOL success = WinHttpSetTimeouts(request_.handle, timeoutMsec, timeoutMsec, timeoutMsec, timeoutMsec);
|
|
if (!success) {
|
|
throw std::runtime_error("Error calling WinHttpSetTimeouts. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
}
|
|
|
|
void send() {
|
|
BOOL success = WinHttpSendRequest(request_.handle, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
|
|
if (!success) {
|
|
throw std::runtime_error("Error calling WinHttpSendRequest. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
}
|
|
|
|
void wait_for_response() {
|
|
BOOL success = WinHttpReceiveResponse(request_.handle, nullptr);
|
|
if (!success) {
|
|
throw std::runtime_error("Error calling WinHttpReceiveResponse. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
}
|
|
|
|
DWORD get_status_code() {
|
|
DWORD statusCode;
|
|
DWORD statusCodeSize = sizeof(statusCode);
|
|
BOOL success = WinHttpQueryHeaders(request_.handle, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, WINHTTP_HEADER_NAME_BY_INDEX, &statusCode, &statusCodeSize, WINHTTP_NO_HEADER_INDEX);
|
|
if (!success) {
|
|
throw std::runtime_error("Eror calling WinHttpQueryHeaders. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
return statusCode;
|
|
}
|
|
|
|
string read_response() {
|
|
ostringstream result;
|
|
|
|
while (true) {
|
|
DWORD size = num_bytes_readable();
|
|
if (size == 0) {
|
|
break;
|
|
}
|
|
|
|
cpputils::Data buffer(size + 1);
|
|
buffer.FillWithZeroes();
|
|
|
|
DWORD num_read;
|
|
BOOL success = WinHttpReadData(request_.handle, buffer.data(), buffer.size(), &num_read);
|
|
if (!success) {
|
|
throw std::runtime_error("Error calling WinHttpReadData. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
ASSERT(0 != num_read, "Weird behavior of WinHttpReadData.It should never read zero bytes since WinHttpQueryDataAvailable said there are bytes readable.");
|
|
|
|
result.write(reinterpret_cast<char*>(buffer.data()), num_read);
|
|
ASSERT(result.good(), "Error writing to ostringstream");
|
|
}
|
|
|
|
return result.str();
|
|
}
|
|
|
|
private:
|
|
DWORD num_bytes_readable() {
|
|
DWORD result;
|
|
BOOL success = WinHttpQueryDataAvailable(request_.handle, &result);
|
|
if (!success) {
|
|
throw std::runtime_error("Error calling WinHttpQueryDataAvailable. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
HttpHandleRAII request_;
|
|
};
|
|
|
|
struct Connection final {
|
|
public:
|
|
Connection(HttpHandleRAII connection) : connection_(std::move(connection)) {}
|
|
|
|
Request create_request(const URL_COMPONENTS& parsedUrl) {
|
|
const INTERNET_PORT port = get_port_from_url(parsedUrl);
|
|
const wstring path = wstring(parsedUrl.lpszUrlPath, parsedUrl.dwUrlPathLength) + wstring(parsedUrl.lpszExtraInfo, parsedUrl.dwExtraInfoLength);
|
|
const DWORD flags = (port == INTERNET_DEFAULT_HTTPS_PORT) ? WINHTTP_FLAG_SECURE : 0;
|
|
|
|
HttpHandleRAII request_handle(WinHttpOpenRequest(connection_.handle, L"GET", path.c_str(), nullptr, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, flags));
|
|
if (nullptr == request_handle.handle) {
|
|
throw std::runtime_error("Error calling WinHttpOpenRequest. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
return Request(std::move(request_handle));
|
|
}
|
|
|
|
private:
|
|
HttpHandleRAII connection_;
|
|
};
|
|
}
|
|
|
|
struct WinHttpSession final {
|
|
public:
|
|
WinHttpSession(HttpHandleRAII session) : session_(std::move(session)) {}
|
|
|
|
Connection create_connection(const URL_COMPONENTS& parsedUrl) {
|
|
const INTERNET_PORT port = get_port_from_url(parsedUrl);
|
|
const wstring host(parsedUrl.lpszHostName, parsedUrl.dwHostNameLength);
|
|
|
|
HttpHandleRAII connection_handle = WinHttpConnect(session_.handle, host.c_str(), port, 0);
|
|
if (nullptr == connection_handle.handle) {
|
|
throw std::runtime_error("Error calling WinHttpConnect. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
|
|
return Connection(std::move(connection_handle));
|
|
}
|
|
|
|
private:
|
|
HttpHandleRAII session_;
|
|
};
|
|
|
|
namespace {
|
|
cpputils::unique_ref<WinHttpSession> create_session() {
|
|
const DWORD dwAccessType = IsWindows8Point1OrGreater() ? WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY : WINHTTP_ACCESS_TYPE_DEFAULT_PROXY;
|
|
HttpHandleRAII session_handle = WinHttpOpen(L"cpputils::HttpClient", dwAccessType, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
|
|
if(nullptr == session_handle.handle) {
|
|
throw std::runtime_error("Error calling WinHttpOpen. Error code: " + std::to_string(GetLastError()));
|
|
}
|
|
|
|
return cpputils::make_unique_ref<WinHttpSession>(std::move(session_handle));
|
|
}
|
|
}
|
|
|
|
WinHttpClient::WinHttpClient() : session_(create_session()) {}
|
|
|
|
WinHttpClient::~WinHttpClient() {}
|
|
|
|
string WinHttpClient::get(const string &url, optional<long> timeoutMsec) {
|
|
wstring wurl = wstring_convert<std::codecvt_utf8_utf16<wchar_t>>().from_bytes(url);
|
|
const URL_COMPONENTS parsedUrl = parse_url(wurl);
|
|
|
|
ASSERT(parsedUrl.dwUserNameLength == 0, "Authentication not supported");
|
|
ASSERT(parsedUrl.dwPasswordLength == 0, "Authentication not supported");
|
|
|
|
Connection connection = session_->create_connection(parsedUrl);
|
|
Request request = connection.create_request(parsedUrl);
|
|
|
|
// allow redirects but not from https to http
|
|
request.set_redirect_policy(WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP);
|
|
|
|
if (timeoutMsec != none) {
|
|
request.set_timeouts(*timeoutMsec);
|
|
}
|
|
|
|
request.send();
|
|
request.wait_for_response();
|
|
|
|
DWORD statusCode = request.get_status_code();
|
|
if (statusCode != HTTP_STATUS_OK) {
|
|
throw std::runtime_error("HTTP Server returned unsupported status code: " + std::to_string(statusCode));
|
|
}
|
|
|
|
return request.read_response();
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|