Catcrafts/Crafter.Network
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fixes

Browse source
This commit is contained in:
Jorijn van der Graaf 2025-11-03 14:25:51 +01:00
commit 9bdf133d0f
12 changed files with 301 additions and 168 deletions
Download patch file Download diff file Expand all files Collapse all files

15
implementations/Crafter.Network-ClientHTTP.cpp
View file

@ -37,7 +37,7 @@ import std;
using namespace Crafter;
ClientHTTP::ClientHTTP(const char* host, std::uint16_t port): client(host, port) {
ClientHTTP::ClientHTTP(const char* host, std::uint16_t port): host(host), port(port), client(host, port) {
}
@ -45,14 +45,21 @@ ClientHTTP::ClientHTTP(std::string host, std::uint16_t port): ClientHTTP(host.c_
}
HTTPResponse ClientHTTP::Send(const char* request, std::uint32_t length) const {
HTTPResponse ClientHTTP::Send(const char* request, std::uint32_t length) {
client.Send(request, length);
std::vector<char> buffer;
HTTPResponse response;
std::uint32_t i = 0;
std::uint32_t statusStart = 0;
while(true) {
buffer = client.RecieveSync();
try {
buffer = client.RecieveSync();
} catch(const SocketClosedException& e) {
client = ClientTCP(host.c_str(), port);
client.Send(request, length);
buffer = client.RecieveSync();
}
for(; i < buffer.size(); i++) {
if(buffer[i] == ' ') {
statusStart = i;
@ -185,6 +192,6 @@ HTTPResponse ClientHTTP::Send(const char* request, std::uint32_t length) const {
}
return response;
}
HTTPResponse ClientHTTP::Send(std::string request) const {
HTTPResponse ClientHTTP::Send(std::string request) {
return Send(request.c_str(), request.size());
}

60
implementations/Crafter.Network-ClientTCP.cpp
View file

@ -32,6 +32,7 @@ module;
#include <sys/ioctl.h>
#include <netdb.h>
#include <strings.h>
#include <cerrno>
module Crafter.Network:ClientTCP_impl;
import :ClientTCP;
@ -72,7 +73,16 @@ ClientTCP::ClientTCP(std::string hostName, std::uint16_t port): ClientTCP(hostNa
ClientTCP::~ClientTCP()
{
if(socketid != 1) {
shutdown(socketid, SHUT_RDWR);
close(socketid);
}
}
void ClientTCP::Stop() {
shutdown(socketid, SHUT_RDWR);
close(socketid);
socketid = -1;
}
void ClientTCP::Send(const void* buffer, std::uint32_t size) const {
@ -82,8 +92,10 @@ void ClientTCP::Send(const void* buffer, std::uint32_t size) const {
std::vector<char> ClientTCP::RecieveSync(std::uint32_t bufferSize) const {
std::vector<char> totalBuffer(bufferSize);
int read = recv(socketid, totalBuffer.data(), bufferSize, 0);
if(read < bufferSize){
totalBuffer.resize(read);
if(read < 0) {
throw std::runtime_error(std::strerror(errno));
} else if(read == 0) {
throw SocketClosedException();
}
return totalBuffer;
}
@ -94,22 +106,49 @@ int ClientTCP::RecieveSync(std::uint32_t bufferSize, void* buffer) const {
std::vector<char> ClientTCP::RecieveSync() const {
int count;
ioctl(socketid, FIONREAD, &count);
if(count == 0){
count = 1024;
}
std::vector<char> buffer(count);
recv(socketid, buffer.data(), count, 0);
int read = recv(socketid, buffer.data(), count, 0);
if(read < 0) {
throw std::runtime_error(std::strerror(errno));
} else if(read == 0) {
throw SocketClosedException();
} else if(count != read) {
buffer.resize(read);
}
return buffer;
}
std::vector<char> ClientTCP::RecieveUntilCloseSync() const {
int count;
ioctl(socketid, FIONREAD, &count);
if(count == 0){
count = 1024;
}
std::vector<char> buffer(count);
recv(socketid, buffer.data(), count, 0);
int read = recv(socketid, buffer.data(), count, 0);
if(read < 0) {
throw std::runtime_error(std::strerror(errno));
} else if(read == 0) {
throw SocketClosedException();
}
while(true) {
ioctl(socketid, FIONREAD, &count);
if(count == 0){
count = 1024;
}
unsigned int oldSize = buffer.size();
buffer.resize(buffer.size()+count);
if(recv(socketid, buffer.data()+oldSize, count, 0) == -1) {
break;
int read = recv(socketid, buffer.data()+oldSize, count, 0);
if(read < 0) {
throw std::runtime_error(std::strerror(errno));
} else if(read == 0) {
return buffer;
} else if(count != read) {
buffer.resize(read);
}
}
return buffer;
@ -120,11 +159,12 @@ std::vector<char> ClientTCP::RecieveUntilFullSync(std::uint32_t bufferSize) cons
int read = 0;
while(read < bufferSize) {
int newRead = recv(socketid, buffer.data()+read, bufferSize-read, 0);
if(newRead == -1) {
break;
} else{
read+=newRead;
if(read < 0) {
throw std::runtime_error(std::strerror(errno));
} else if(read == 0) {
throw SocketClosedException();
}
read+=newRead;
}
buffer.resize(read);
return buffer;

256
implementations/Crafter.Network-ListenerHTTP.cpp
View file

@ -68,150 +68,170 @@ ListenerHTTP::ListenerHTTP(std::uint16_t port, std::unordered_map<std::string, s
}
}
ListenerHTTP::~ListenerHTTP() {
if(s != -1) {
Stop();
}
}
void ListenerHTTP::Stop() {
running = false;
shutdown(s, SHUT_RDWR);
close(s);
s = -1;
for(ListenerHTTPClient* client : clients) {
client->client.Stop();
client->thread.join();
delete client;
}
}
void ListenerHTTP::ListenSyncSync() const {
void ListenerHTTP::Listen() {
while(running) {
sockaddr_in newSockAddr;
socklen_t newSockAddrSize = sizeof(newSockAddr);
int client = accept(s, (sockaddr*)&newSockAddr, &newSockAddrSize);
if(!running) {
return;
}
if (client > 0) {
CallRoute(client);
clients.push_back(new ListenerHTTPClient(this, client));
} else {
std::cerr << "Error accepting request from client!" << std::endl;
}
std::erase_if(clients, [](ListenerHTTPClient* client) {
if (client->disconnected.load()) {
client->thread.join();
delete client;
return true;
}
return false;
});
}
}
void ListenerHTTP::ListenSyncAsync() const {
while(running) {
sockaddr_in newSockAddr;
socklen_t newSockAddrSize = sizeof(newSockAddr);
int client = accept(s, (sockaddr*)&newSockAddr, &newSockAddrSize);
if (client > 0) {
ThreadPool::Enqueue([this, client]() {CallRoute(client); });
}
else {
std::cerr << "Error accepting request from client!" << std::endl;
}
}
ListenerHTTPClient::ListenerHTTPClient(ListenerHTTP* server, int s) : server(server), client(s), thread(&ListenerHTTPClient::ListenRoutes, this), disconnected(false) {
}
void ListenerHTTP::ListenAsyncSync() const {
ThreadPool::Enqueue([this]() {
while(running) {
sockaddr_in newSockAddr;
socklen_t newSockAddrSize = sizeof(newSockAddr);
int client = accept(s, (sockaddr*)&newSockAddr, &newSockAddrSize);
if (client > 0) {
CallRoute(client);
}
else if(running) {
std::cerr << "Error accepting request from client: "<< strerror(errno) << " (errno: " << errno << ")"<< std::endl;
}
}
});
}
void ListenerHTTP::ListenAsyncAsync() const {
ThreadPool::Enqueue([this]() {
while(running) {
sockaddr_in newSockAddr;
socklen_t newSockAddrSize = sizeof(newSockAddr);
int client = accept(s, (sockaddr*)&newSockAddr, &newSockAddrSize);
if (client > 0) {
ThreadPool::Enqueue([this, client]() {CallRoute(client); });
}
else {
std::cerr << "Error accepting request from client!" << std::endl;
}
}
});
}
void ListenerHTTP::CallRoute(int clientid) const {
ClientTCP client(clientid);
std::vector<char> buffer = client.RecieveSync(1024);
HTTPRequest request;
std::string route;
std::uint32_t i = 0;
std::uint32_t routeStart = 0;
for(; i < 1024; i++) {
if(buffer[i] == ' ') {
request.method.assign(buffer.data(), i);
break;
}
}
for(; i < 1024; i++) {
if(buffer[i] == '/') {
routeStart = i;
break;
}
}
for(; i < 1024; i++) {
if(buffer[i] == ' ') {
route.assign(buffer.data()+routeStart, i-routeStart);
break;
}
}
for(; i < 1024; i++) {
if(buffer[i] == '\r' && buffer[i+1] == '\n') {
break;
}
}
i+=2;
while(i < 1024) {
std::uint32_t headerStart = i;
std::string headerName;
for(; i < 1024-i; i++) {
if(buffer[i] == ':') {
headerName.assign(buffer.data()+headerStart, i-headerStart);
i++;
break;
}
}
headerStart = i;
std::string headerValue;
for(; i < 1024; i++) {
if(buffer[i] == '\r' && buffer[i+1] == '\n') {
headerValue.assign(buffer.data()+headerStart, i-headerStart);
request.headers.insert({headerName, headerValue});
if(buffer[i+2] == '\r'){
goto headersComplete;
} else{
void ListenerHTTPClient::ListenRoutes() {
try {
while(true) {
std::vector<char> buffer;
HTTPRequest request;
std::string route;
std::uint32_t i = 0;
std::uint32_t routeStart = 0;
while(true) {
while(true) {
buffer = client.RecieveSync();
std::string str(buffer.begin(), buffer.end());
for(; i < buffer.size(); i++) {
if(buffer[i] == ' ') {
request.method.assign(buffer.data(), i);
break;
}
}
for(; i < buffer.size(); i++) {
if(buffer[i] == '/') {
routeStart = i;
break;
}
}
for(; i < buffer.size(); i++) {
if(buffer[i] == ' ') {
route.assign(buffer.data()+routeStart, i-routeStart);
break;
}
}
for(; i < buffer.size(); i++) {
if(buffer[i] == '\r' && buffer[i+1] == '\n') {
break;
}
}
i+=2;
break;
while(i < buffer.size()) {
std::uint32_t headerStart = i;
std::string headerName;
for(; i < buffer.size()-i; i++) {
if(buffer[i] == ':') {
headerName.assign(buffer.data()+headerStart, i-headerStart);
i++;
break;
}
}
headerStart = i;
std::string headerValue;
for(; i < buffer.size(); i++) {
if(buffer[i] == '\r' && buffer[i+1] == '\n') {
headerValue.assign(buffer.data()+headerStart, i-headerStart);
request.headers.insert({headerName, headerValue});
if(buffer[i+2] == '\r'){
goto headersComplete;
} else{
i+=2;
break;
}
}
}
}
i = 0;
}
headersComplete:;
i+=4;
std::unordered_map<std::string, std::string>::iterator it = request.headers.find("Content-Length");
if(it != request.headers.end()) {
const int lenght = std::stoi(it->second);
request.body.resize(lenght, 0);
if(lenght > 0 ){
std::int_fast32_t remaining = lenght+i-buffer.size();
if(remaining < 0) {
std::memcpy(&request.body[0], buffer.data()+i, lenght);
std::string response = server->routes.at(route)(request);
client.Send(&response[0], response.size());
i+=lenght;
} else if(remaining == 0){
std::memcpy(&request.body[0], buffer.data()+i, lenght);
std::string response = server->routes.at(route)(request);
client.Send(&response[0], response.size());
break;
} else {
std::memcpy(&request.body[0], buffer.data()+i, lenght-remaining);
std::vector<char> bodyBuffer = client.RecieveUntilFullSync(remaining);
std::memcpy(&request.body[remaining], bodyBuffer.data(), remaining);
std::string response = server->routes.at(route)(request);
client.Send(&response[0], response.size());
break;
}
} else {
break;
}
} else {
std::string response = server->routes.at(route)(request);
client.Send(&response[0], response.size());
if(i == buffer.size()) {
break;
}
}
}
}
} catch(SocketClosedException& e) {
disconnected.store(true);
}
headersComplete:;
i+=4;
std::unordered_map<std::string, std::string>::iterator it = request.headers.find("Content-Length");
if(it != request.headers.end())
{
const int lenght = std::stoi(it->second);
const int remaining = 1024-lenght-i;
request.body.resize(lenght, 0);
if(remaining > 0){
std::memcpy(&request.body[0], buffer.data()+i, lenght);
}
if(remaining < lenght){
std::vector<char> bodyBuffer = client.RecieveSync(lenght-remaining);
std::memcpy(&request.body[remaining], bodyBuffer.data(), lenght-remaining);
}
}
std::string response = routes.at(route)(request);
client.Send(&response[0], response.size());
}
ListenerHTTP::~ListenerHTTP() {
if(s != -1) {
close(s);
ListenerAsyncHTTP::ListenerAsyncHTTP(std::uint16_t port, std::unordered_map<std::string, std::function<std::string(const HTTPRequest&)>> routes): listener(port, routes), thread(&ListenerHTTP::Listen, &listener) {
}
ListenerAsyncHTTP::~ListenerAsyncHTTP() {
if(listener.s != -1) {
Stop();
}
}
void ListenerAsyncHTTP::Stop() {
listener.Stop();
thread.join();
}