You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

494 lines
12 KiB

///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> //
// Some code by AI //
// //
// This program is free software; you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation as version 3 of the License, or //
// (at your option) any later version. //
// //
// This program is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License V3 for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
///////////////////////////////////////////////////////////////////////////////////
#include "httpclient.h"
#include <algorithm>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <string>
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <arpa/inet.h>
#include <errno.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#endif
namespace
{
std::string lowered(const std::string& text)
{
std::string result(text);
std::transform(result.begin(), result.end(), result.begin(),
[](unsigned char c) { return static_cast<char>(std::tolower(c)); });
return result;
}
std::string trimmed(const std::string& text)
{
size_t begin = text.find_first_not_of(" \t\r\n");
if (begin == std::string::npos) {
return std::string();
}
size_t end = text.find_last_not_of(" \t\r\n");
return text.substr(begin, end - begin + 1);
}
std::string socketError()
{
#ifdef _WIN32
int code = WSAGetLastError();
switch (code)
{
case WSAECONNREFUSED: return "connection refused";
case WSAETIMEDOUT: return "timed out";
case WSAECONNRESET: return "connection reset";
case WSAEHOSTUNREACH: return "host unreachable";
default: return "socket error " + std::to_string(code);
}
#else
// A receive timeout set with SO_RCVTIMEO comes back as EAGAIN, whose text says nothing
// about time
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
return "timed out";
}
return std::strerror(errno);
#endif
}
} // namespace
HttpClient::Socket HttpClient::invalidSocket()
{
#ifdef _WIN32
return INVALID_SOCKET;
#else
return -1;
#endif
}
std::string HttpClient::Head::header(const std::string& name) const
{
std::string wanted = lowered(name);
for (const auto& header : m_headers)
{
if (lowered(header.first) == wanted) {
return header.second;
}
}
return std::string();
}
bool HttpClient::startup(std::string& error)
{
#ifdef _WIN32
WSADATA data;
int result = WSAStartup(MAKEWORD(2, 2), &data);
if (result != 0)
{
error = "WSAStartup failed with " + std::to_string(result);
return false;
}
#else
(void) error;
#endif
return true;
}
void HttpClient::cleanup()
{
#ifdef _WIN32
WSACleanup();
#endif
}
HttpClient::~HttpClient()
{
close();
}
bool HttpClient::open(const std::string& host, int port, int timeoutMs, std::string& error)
{
close();
addrinfo hints;
std::memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
addrinfo *addresses = nullptr;
std::string service = std::to_string(port);
if (getaddrinfo(host.c_str(), service.c_str(), &hints, &addresses) != 0)
{
error = "cannot resolve " + host;
return false;
}
std::string reason;
for (addrinfo *address = addresses; address != nullptr; address = address->ai_next)
{
Socket handle = socket(address->ai_family, address->ai_socktype, address->ai_protocol);
if (handle == invalidSocket()) {
continue;
}
if (connect(handle, address->ai_addr, static_cast<int>(address->ai_addrlen)) == 0)
{
m_socket = handle;
break;
}
// Read before closing the socket and freeing the addresses, either of which
// replaces the last error with one of its own
reason = socketError();
#ifdef _WIN32
closesocket(handle);
#else
::close(handle);
#endif
}
freeaddrinfo(addresses);
if (m_socket == invalidSocket())
{
error = reason.empty() ? "no usable address" : reason;
return false;
}
// Nagle would hold small JSON-RPC messages back waiting for more to send
int flag = 1;
setsockopt(m_socket, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<const char *>(&flag), sizeof(flag));
#ifdef SO_NOSIGPIPE
// A send on a connection the server has closed must fail, not raise SIGPIPE and end the
// process. Linux has no such option and uses MSG_NOSIGNAL on the send instead
setsockopt(m_socket, SOL_SOCKET, SO_NOSIGPIPE, &flag, sizeof(flag));
#endif
if (timeoutMs > 0)
{
#ifdef _WIN32
DWORD timeout = static_cast<DWORD>(timeoutMs);
setsockopt(m_socket, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<const char *>(&timeout), sizeof(timeout));
setsockopt(m_socket, SOL_SOCKET, SO_SNDTIMEO, reinterpret_cast<const char *>(&timeout), sizeof(timeout));
#else
timeval timeout;
timeout.tv_sec = timeoutMs / 1000;
timeout.tv_usec = (timeoutMs % 1000) * 1000;
setsockopt(m_socket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
setsockopt(m_socket, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
#endif
}
m_buffer.clear();
m_eof = false;
return true;
}
void HttpClient::interrupt()
{
if (m_socket != invalidSocket())
{
#ifdef _WIN32
shutdown(m_socket, SD_BOTH);
#else
shutdown(m_socket, SHUT_RDWR);
#endif
}
}
void HttpClient::close()
{
if (m_socket != invalidSocket())
{
#ifdef _WIN32
closesocket(m_socket);
#else
::close(m_socket);
#endif
m_socket = invalidSocket();
}
m_buffer.clear();
m_eof = false;
}
bool HttpClient::sendAll(const std::string& data, std::string& error)
{
size_t sent = 0;
while (sent < data.size())
{
#ifdef MSG_NOSIGNAL
const int flags = MSG_NOSIGNAL;
#else
const int flags = 0;
#endif
int count = ::send(m_socket, data.data() + sent, static_cast<int>(data.size() - sent), flags);
if (count <= 0)
{
error = "send failed (" + socketError() + ")";
return false;
}
sent += static_cast<size_t>(count);
}
return true;
}
bool HttpClient::send(const std::string& method, const std::string& path, const std::vector<Header>& headers,
const std::string& body, std::string& error)
{
std::string request = method + " " + path + " HTTP/1.1\r\n";
for (const auto& header : headers) {
request += header.first + ": " + header.second + "\r\n";
}
// One request per connection keeps the response framing simple: no pipelining to unpick,
// and a body with neither Content-Length nor chunking ends at the close
request += "Connection: close\r\n";
request += "Content-Length: " + std::to_string(body.size()) + "\r\n";
request += "\r\n";
request += body;
return sendAll(request, error);
}
bool HttpClient::fill(std::string& error)
{
char block[8192];
int count = recv(m_socket, block, sizeof(block), 0);
if (count == 0)
{
m_eof = true;
return false;
}
if (count < 0)
{
error = "read failed (" + socketError() + ")";
m_eof = true;
return false;
}
m_buffer.append(block, static_cast<size_t>(count));
return true;
}
bool HttpClient::readLine(std::string& line, std::string& error)
{
for (;;)
{
size_t end = m_buffer.find("\r\n");
if (end != std::string::npos)
{
line = m_buffer.substr(0, end);
m_buffer.erase(0, end + 2);
return true;
}
if (!fill(error))
{
if (error.empty()) {
error = "connection closed while reading a line";
}
return false;
}
}
}
bool HttpClient::readExactly(size_t count, std::string& out, std::string& error)
{
while (m_buffer.size() < count)
{
if (!fill(error))
{
if (error.empty()) {
error = "connection closed with " + std::to_string(count - m_buffer.size()) + " bytes still to read";
}
return false;
}
}
out = m_buffer.substr(0, count);
m_buffer.erase(0, count);
return true;
}
bool HttpClient::readHead(Head& head, std::string& error)
{
std::string line;
if (!readLine(line, error)) {
return false;
}
// HTTP/1.1 200 OK
size_t firstSpace = line.find(' ');
if ((firstSpace == std::string::npos) || (line.compare(0, 5, "HTTP/") != 0))
{
error = "not an HTTP response: " + line;
return false;
}
size_t secondSpace = line.find(' ', firstSpace + 1);
head.m_status = std::atoi(line.substr(firstSpace + 1).c_str());
head.m_reason = (secondSpace == std::string::npos) ? std::string() : trimmed(line.substr(secondSpace + 1));
for (;;)
{
if (!readLine(line, error)) {
return false;
}
if (line.empty()) {
break;
}
size_t colon = line.find(':');
if (colon == std::string::npos) {
continue;
}
head.m_headers.emplace_back(trimmed(line.substr(0, colon)), trimmed(line.substr(colon + 1)));
}
std::string length = head.header("Content-Length");
if (!length.empty()) {
head.m_contentLength = std::atoll(length.c_str());
}
head.m_chunked = (lowered(head.header("Transfer-Encoding")).find("chunked") != std::string::npos);
return true;
}
bool HttpClient::readChunk(std::string& chunk, std::string& error)
{
std::string line;
if (!readLine(line, error)) {
return false;
}
// The size line may carry chunk extensions after a semicolon
size_t semicolon = line.find(';');
std::string sizeText = trimmed((semicolon == std::string::npos) ? line : line.substr(0, semicolon));
size_t size = static_cast<size_t>(std::strtoul(sizeText.c_str(), nullptr, 16));
if (size == 0)
{
// Trailers, then the final blank line. The body is complete, which is not an error
for (;;)
{
std::string trailer;
if (!readLine(trailer, error) || trailer.empty()) {
break;
}
}
error.clear();
return false;
}
if (!readExactly(size, chunk, error)) {
return false;
}
std::string terminator;
return readLine(terminator, error);
}
bool HttpClient::readSome(std::string& data, std::string& error)
{
if (m_buffer.empty() && !fill(error)) {
return false;
}
data.clear();
data.swap(m_buffer);
return true;
}
bool HttpClient::readBody(const Head& head, std::string& body, std::string& error)
{
body.clear();
if (head.m_chunked)
{
std::string chunk;
while (readChunk(chunk, error)) {
body += chunk;
}
return error.empty();
}
if (head.m_contentLength >= 0)
{
if (head.m_contentLength == 0) {
return true;
}
return readExactly(static_cast<size_t>(head.m_contentLength), body, error);
}
// Neither framing: the body runs to the close, which Connection: close guarantees
while (fill(error)) {
// keep reading
}
body.swap(m_buffer);
m_buffer.clear();
return error.empty();
}