mirror of
https://gitea.sffempire.ru/Kolyah35/minecraft-pe-0.6.1.git
synced 2026-03-19 22:43:32 +00:00
339 lines
10 KiB
C++
339 lines
10 KiB
C++
#include "HttpClient.h"
|
|
#include "log.h"
|
|
|
|
#include <algorithm>
|
|
#include <cctype>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <vector>
|
|
|
|
#if defined(_WIN32)
|
|
#ifndef NOMINMAX
|
|
#define NOMINMAX
|
|
#endif
|
|
#include <winsock2.h>
|
|
#include <ws2tcpip.h>
|
|
#include <winhttp.h>
|
|
#pragma comment(lib, "ws2_32.lib")
|
|
#pragma comment(lib, "winhttp.lib")
|
|
#else
|
|
#include <arpa/inet.h>
|
|
#include <netdb.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
namespace {
|
|
|
|
bool startsWith(const std::string& s, const std::string& prefix) {
|
|
return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
|
|
}
|
|
|
|
bool parseUrl(const std::string& url, std::string& scheme, std::string& host, int& port, std::string& path);
|
|
|
|
#if defined(_WIN32)
|
|
|
|
bool downloadHttpsWinHttp(const std::string& url, std::vector<unsigned char>& outBody) {
|
|
outBody.clear();
|
|
|
|
std::string scheme, host, path;
|
|
int port = 0;
|
|
if (!parseUrl(url, scheme, host, port, path))
|
|
return false;
|
|
|
|
// WinHTTP expects the path to include the leading '/'.
|
|
HINTERNET hSession = WinHttpOpen(L"MinecraftPE/1.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
|
|
if (!hSession)
|
|
return false;
|
|
|
|
HINTERNET hConnect = WinHttpConnect(hSession, std::wstring(host.begin(), host.end()).c_str(), port, 0);
|
|
if (!hConnect) {
|
|
WinHttpCloseHandle(hSession);
|
|
return false;
|
|
}
|
|
|
|
HINTERNET hRequest = WinHttpOpenRequest(
|
|
hConnect,
|
|
L"GET",
|
|
std::wstring(path.begin(), path.end()).c_str(),
|
|
NULL,
|
|
WINHTTP_NO_REFERER,
|
|
WINHTTP_DEFAULT_ACCEPT_TYPES,
|
|
WINHTTP_FLAG_SECURE
|
|
);
|
|
|
|
if (!hRequest) {
|
|
WinHttpCloseHandle(hConnect);
|
|
WinHttpCloseHandle(hSession);
|
|
return false;
|
|
}
|
|
|
|
DWORD redirectPolicy = WINHTTP_OPTION_REDIRECT_POLICY_ALWAYS;
|
|
WinHttpSetOption(hRequest, WINHTTP_OPTION_REDIRECT_POLICY, &redirectPolicy, sizeof(redirectPolicy));
|
|
|
|
BOOL result = WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
|
|
if (!result) {
|
|
WinHttpCloseHandle(hRequest);
|
|
WinHttpCloseHandle(hConnect);
|
|
WinHttpCloseHandle(hSession);
|
|
return false;
|
|
}
|
|
|
|
result = WinHttpReceiveResponse(hRequest, NULL);
|
|
if (!result) {
|
|
WinHttpCloseHandle(hRequest);
|
|
WinHttpCloseHandle(hConnect);
|
|
WinHttpCloseHandle(hSession);
|
|
return false;
|
|
}
|
|
|
|
DWORD bytesAvailable = 0;
|
|
while (WinHttpQueryDataAvailable(hRequest, &bytesAvailable) && bytesAvailable > 0) {
|
|
std::vector<unsigned char> buffer(bytesAvailable);
|
|
DWORD bytesRead = 0;
|
|
if (!WinHttpReadData(hRequest, buffer.data(), bytesAvailable, &bytesRead) || bytesRead == 0)
|
|
break;
|
|
outBody.insert(outBody.end(), buffer.begin(), buffer.begin() + bytesRead);
|
|
}
|
|
|
|
WinHttpCloseHandle(hRequest);
|
|
WinHttpCloseHandle(hConnect);
|
|
WinHttpCloseHandle(hSession);
|
|
|
|
return !outBody.empty();
|
|
}
|
|
|
|
#endif
|
|
|
|
std::string toLower(const std::string& s) {
|
|
std::string out = s;
|
|
std::transform(out.begin(), out.end(), out.begin(), ::tolower);
|
|
return out;
|
|
}
|
|
|
|
bool parseUrl(const std::string& url, std::string& scheme, std::string& host, int& port, std::string& path) {
|
|
scheme.clear();
|
|
host.clear();
|
|
path.clear();
|
|
port = 0;
|
|
|
|
// Very simple URL parser.
|
|
// url format: scheme://host[:port]/path
|
|
auto pos = url.find("://");
|
|
if (pos == std::string::npos) return false;
|
|
scheme = toLower(url.substr(0, pos));
|
|
size_t start = pos + 3;
|
|
|
|
size_t slash = url.find('/', start);
|
|
std::string hostPort = (slash == std::string::npos) ? url.substr(start) : url.substr(start, slash - start);
|
|
path = (slash == std::string::npos) ? "/" : url.substr(slash);
|
|
|
|
size_t colon = hostPort.find(':');
|
|
if (colon != std::string::npos) {
|
|
host = hostPort.substr(0, colon);
|
|
port = atoi(hostPort.c_str() + colon + 1);
|
|
} else {
|
|
host = hostPort;
|
|
}
|
|
|
|
if (scheme == "http") {
|
|
if (port == 0) port = 80;
|
|
} else if (scheme == "https") {
|
|
if (port == 0) port = 443;
|
|
}
|
|
|
|
return !host.empty() && !scheme.empty();
|
|
}
|
|
|
|
bool readAll(int sockfd, std::vector<unsigned char>& out) {
|
|
const int BUF_SIZE = 4096;
|
|
unsigned char buffer[BUF_SIZE];
|
|
|
|
while (true) {
|
|
int received = recv(sockfd, (char*)buffer, BUF_SIZE, 0);
|
|
if (received <= 0)
|
|
break;
|
|
out.insert(out.end(), buffer, buffer + received);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool resolveAndConnect(const std::string& host, int port, int& outSock) {
|
|
#if defined(_WIN32)
|
|
static bool initialized = false;
|
|
if (!initialized) {
|
|
WSADATA wsaData;
|
|
WSAStartup(MAKEWORD(2, 2), &wsaData);
|
|
initialized = true;
|
|
}
|
|
#endif
|
|
|
|
struct addrinfo hints;
|
|
struct addrinfo* result = NULL;
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
hints.ai_family = AF_UNSPEC;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
std::ostringstream portStream;
|
|
portStream << port;
|
|
const std::string portStr = portStream.str();
|
|
if (getaddrinfo(host.c_str(), portStr.c_str(), &hints, &result) != 0)
|
|
return false;
|
|
|
|
int sock = -1;
|
|
for (struct addrinfo* rp = result; rp != NULL; rp = rp->ai_next) {
|
|
sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
|
|
if (sock < 0) continue;
|
|
if (connect(sock, rp->ai_addr, (int)rp->ai_addrlen) == 0)
|
|
break; // success
|
|
|
|
#if defined(_WIN32)
|
|
closesocket(sock);
|
|
#else
|
|
close(sock);
|
|
#endif
|
|
sock = -1;
|
|
}
|
|
|
|
freeaddrinfo(result);
|
|
|
|
if (sock < 0)
|
|
return false;
|
|
|
|
outSock = sock;
|
|
return true;
|
|
}
|
|
|
|
std::string getHeaderValue(const std::string& headers, const std::string& key) {
|
|
std::string lower = toLower(headers);
|
|
std::string lowerKey = toLower(key);
|
|
size_t pos = lower.find(lowerKey);
|
|
if (pos == std::string::npos) return "";
|
|
size_t colon = lower.find(':', pos + lowerKey.size());
|
|
if (colon == std::string::npos) return "";
|
|
size_t start = colon + 1;
|
|
while (start < lower.size() && (lower[start] == ' ' || lower[start] == '\t')) start++;
|
|
size_t end = lower.find('\r', start);
|
|
if (end == std::string::npos) end = lower.find('\n', start);
|
|
if (end == std::string::npos) end = lower.size();
|
|
return headers.substr(start, end - start);
|
|
}
|
|
|
|
bool extractStatusCode(const std::string& headers, int& outStatus) {
|
|
size_t pos = headers.find(" ");
|
|
if (pos == std::string::npos) return false;
|
|
size_t pos2 = headers.find(" ", pos + 1);
|
|
if (pos2 == std::string::npos) return false;
|
|
std::string code = headers.substr(pos + 1, pos2 - pos - 1);
|
|
outStatus = atoi(code.c_str());
|
|
return true;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
namespace HttpClient {
|
|
|
|
bool download(const std::string& url, std::vector<unsigned char>& outBody) {
|
|
outBody.clear();
|
|
|
|
std::string currentUrl = url;
|
|
for (int redirect = 0; redirect < 3; ++redirect) {
|
|
std::string scheme, host, path;
|
|
int port = 0;
|
|
if (!parseUrl(currentUrl, scheme, host, port, path)) {
|
|
LOGW("[HttpClient] parseUrl failed for '%s'\n", currentUrl.c_str());
|
|
return false;
|
|
}
|
|
|
|
if (scheme == "https") {
|
|
#if defined(_WIN32)
|
|
LOGI("[HttpClient] using WinHTTP for HTTPS URL %s\n", currentUrl.c_str());
|
|
return downloadHttpsWinHttp(currentUrl, outBody);
|
|
#else
|
|
LOGW("[HttpClient] HTTPS not supported on this platform: %s\n", currentUrl.c_str());
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
if (scheme != "http") {
|
|
LOGW("[HttpClient] unsupported scheme '%s' for URL '%s'\n", scheme.c_str(), currentUrl.c_str());
|
|
return false;
|
|
}
|
|
|
|
int sock = -1;
|
|
if (!resolveAndConnect(host, port, sock)) {
|
|
LOGW("[HttpClient] resolve/connect failed for %s:%d\n", host.c_str(), port);
|
|
return false;
|
|
}
|
|
|
|
std::string request = "GET " + path + " HTTP/1.1\r\n";
|
|
request += "Host: " + host + "\r\n";
|
|
request += "User-Agent: MinecraftPE\r\n";
|
|
request += "Connection: close\r\n";
|
|
request += "\r\n";
|
|
|
|
send(sock, request.c_str(), (int)request.size(), 0);
|
|
|
|
std::vector<unsigned char> raw;
|
|
readAll(sock, raw);
|
|
|
|
#if defined(_WIN32)
|
|
closesocket(sock);
|
|
#else
|
|
close(sock);
|
|
#endif
|
|
|
|
if (raw.empty()) {
|
|
LOGW("[HttpClient] no response data from %s\n", currentUrl.c_str());
|
|
return false;
|
|
}
|
|
|
|
// split headers and body
|
|
const std::string delim = "\r\n\r\n";
|
|
auto it = std::search(raw.begin(), raw.end(), delim.begin(), delim.end());
|
|
if (it == raw.end())
|
|
return false;
|
|
|
|
size_t headerLen = it - raw.begin();
|
|
std::string headers(reinterpret_cast<const char*>(raw.data()), headerLen);
|
|
size_t bodyStart = headerLen + delim.size();
|
|
|
|
int status = 0;
|
|
if (!extractStatusCode(headers, status))
|
|
return false;
|
|
|
|
if (status == 301 || status == 302 || status == 307 || status == 308) {
|
|
std::string location = getHeaderValue(headers, "Location");
|
|
if (location.empty()) {
|
|
LOGW("[HttpClient] redirect without Location header for %s\n", currentUrl.c_str());
|
|
return false;
|
|
}
|
|
LOGI("[HttpClient] redirect %s -> %s\n", currentUrl.c_str(), location.c_str());
|
|
currentUrl = location;
|
|
continue;
|
|
}
|
|
|
|
if (status != 200) {
|
|
std::string bodySnippet;
|
|
if (!outBody.empty()) {
|
|
size_t len = outBody.size() < 1024 ? outBody.size() : 1024;
|
|
bodySnippet.assign(outBody.begin(), outBody.begin() + len);
|
|
}
|
|
LOGW("[HttpClient] HTTP status %d for %s\n", status, currentUrl.c_str());
|
|
LOGW("[HttpClient] Headers:\n%s\n", headers.c_str());
|
|
LOGW("[HttpClient] Body (up to 1024 bytes):\n%s\n", bodySnippet.c_str());
|
|
return false;
|
|
}
|
|
|
|
outBody.assign(raw.begin() + bodyStart, raw.end());
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
} // namespace HttpClient
|