BeamMP/BeamMP-Launcher
1
0
Fork 0
mirror of https://github.com/BeamMP/BeamMP-Launcher.git synced 2025-07-01 23:46:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

implement receiving new header format

Browse Source
This commit is contained in:
Lion Kortlepel 2024-06-25 17:46:08 +02:00
parent 88a9d4a1b1
commit 7c24020124
No known key found for this signature in database
GPG Key ID: 4322FF2B4C71259B
10 changed files with 166 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/Helpers.h Normal file
View File

@ -0,0 +1,11 @@
#include <span>
#include <string>
#include <vector>
#pragma once
using ByteSpan = std::span<const char>;
std::string bytespan_to_string(ByteSpan span);
std::vector<char> strtovec(std::string_view str);

9
include/Network/network.hpp
View File

@ -7,12 +7,15 @@
/// ///
#pragma once #pragma once
#include "Helpers.h"
#include <span>
#include <string> #include <string>
#ifdef __linux__ #ifdef __linux__
#include "linuxfixes.h" #include "linuxfixes.h"
#include <bits/types/siginfo_t.h> #include <bits/types/siginfo_t.h>
#include <cstdint> #include <cstdint>
#include <vector>
#include <sys/ucontext.h> #include <sys/ucontext.h>
#endif #endif
@ -39,16 +42,16 @@ extern std::string PrivateKey;
extern std::string ListOfMods; extern std::string ListOfMods;
int KillSocket(uint64_t Dead); int KillSocket(uint64_t Dead);
void UUl(const std::string& R); void UUl(const std::string& R);
void UDPSend(std::string Data); void UDPSend(const std::vector<char>& Data);
bool CheckBytes(int32_t Bytes); bool CheckBytes(int32_t Bytes);
void GameSend(std::string_view Data); void GameSend(std::string_view Data);
void SendLarge(std::string Data); void SendLarge(const std::vector<char>& Data);
std::string TCPRcv(uint64_t Sock); std::string TCPRcv(uint64_t Sock);
void SyncResources(uint64_t TCPSock); void SyncResources(uint64_t TCPSock);
std::string GetAddr(const std::string& IP); std::string GetAddr(const std::string& IP);
void ServerParser(std::string_view Data); void ServerParser(std::string_view Data);
std::string Login(const std::string& fields); std::string Login(const std::string& fields);
void TCPSend(const std::string& Data, uint64_t Sock); void TCPSend(const std::vector<char>& Data, uint64_t Sock);
void TCPClientMain(const std::string& IP, int Port); void TCPClientMain(const std::string& IP, int Port);
void UDPClientMain(const std::string& IP, int Port); void UDPClientMain(const std::string& IP, int Port);
void TCPGameServer(const std::string& IP, int Port); void TCPGameServer(const std::string& IP, int Port);

11
include/NetworkHelpers.h Normal file
View File

@ -0,0 +1,11 @@
#pragma once
#if defined(__linux__)
#include "linuxfixes.h"
#else
#include <winsock2.h>
#include <ws2tcpip.h>
#endif
#include <vector>
void ReceiveFromGame(SOCKET socket, std::vector<char>& out_data);

9
src/Helpers.cpp Normal file
View File

@ -0,0 +1,9 @@
#include "Helpers.h"
std::string bytespan_to_string(ByteSpan span) {
return std::string(span.data(), span.size());
}
std::vector<char> strtovec(std::string_view str) {
return std::vector<char>(str.begin(), str.end());
}

122
src/Network/Core.cpp
View File

@ -7,6 +7,7 @@
/// ///
#include "Http.h" #include "Http.h"
#include "Network/network.hpp" #include "Network/network.hpp"
#include "NetworkHelpers.h"
#include "Security/Init.h" #include "Security/Init.h"
#include <cstdlib> #include <cstdlib>
#include <regex> #include <regex>
@ -72,37 +73,38 @@ bool IsAllowedLink(const std::string& Link) {
return std::regex_search(Link, link_match, link_pattern) && link_match.position() == 0; return std::regex_search(Link, link_match, link_pattern) && link_match.position() == 0;
} }
void Parse(std::string Data, SOCKET CSocket) { void Parse(std::span<char> InData, SOCKET CSocket) {
char Code = Data.at(0), SubCode = 0; std::string OutData;
if (Data.length() > 1) char Code = InData[0], SubCode = 0;
SubCode = Data.at(1); if (InData.size() > 1)
SubCode = InData[1];
switch (Code) { switch (Code) {
case 'A': case 'A':
Data = Data.substr(0, 1); OutData = "A";
break; break;
case 'B': case 'B':
NetReset(); NetReset();
Terminate = true; Terminate = true;
TCPTerminate = true; TCPTerminate = true;
Data = Code + HTTP::Get("https://backend.beammp.com/servers-info"); OutData = Code + HTTP::Get("https://backend.beammp.com/servers-info");
break; break;
case 'C': case 'C':
ListOfMods.clear(); ListOfMods.clear();
StartSync(Data); StartSync(std::string(InData.data(), InData.size()));
while (ListOfMods.empty() && !Terminate) { while (ListOfMods.empty() && !Terminate) {
std::this_thread::sleep_for(std::chrono::seconds(1)); std::this_thread::sleep_for(std::chrono::seconds(1));
} }
if (ListOfMods == "-") if (ListOfMods == "-")
Data = "L"; OutData = "L";
else else
Data = "L" + ListOfMods; OutData = "L" + ListOfMods;
break; break;
case 'O': // open default browser with URL case 'O': // open default browser with URL
if (IsAllowedLink(Data.substr(1))) { if (IsAllowedLink(bytespan_to_string(InData.subspan(1)))) {
#if defined(__linux) #if defined(__linux)
if (char* browser = getenv("BROWSER"); browser != nullptr && !std::string_view(browser).empty()) { if (char* browser = getenv("BROWSER"); browser != nullptr && !std::string_view(browser).empty()) {
pid_t pid; pid_t pid;
auto arg = Data.substr(1); auto arg = bytespan_to_string(InData.subspan(1));
char* argv[] = { browser, arg.data() }; char* argv[] = { browser, arg.data() };
auto status = posix_spawn(&pid, browser, nullptr, nullptr, argv, environ); auto status = posix_spawn(&pid, browser, nullptr, nullptr, argv, environ);
if (status == 0) { if (status == 0) {
@ -114,27 +116,27 @@ void Parse(std::string Data, SOCKET CSocket) {
error(std::string("posix_spawn: ") + strerror(status)); error(std::string("posix_spawn: ") + strerror(status));
} }
} else { } else {
error("Failed to open the following link in the browser because the $BROWSER environment variable is not set: " + Data.substr(1)); error("Failed to open the following link in the browser because the $BROWSER environment variable is not set: " + bytespan_to_string(InData.subspan(1)));
} }
#elif defined(WIN32) #elif defined(WIN32)
ShellExecuteA(nullptr, "open", Data.substr(1).c_str(), nullptr, nullptr, SW_SHOW); /// TODO: Look at when working on linux port ShellExecuteA(nullptr, "open", InData.subspan(1).data(), nullptr, nullptr, SW_SHOW); /// TODO: Look at when working on linux port
#endif #endif
info("Opening Link \"" + Data.substr(1) + "\""); info("Opening Link \"" + bytespan_to_string(InData.subspan(1)) + "\"");
} }
Data.clear(); OutData.clear();
break; break;
case 'P': case 'P':
Data = Code + std::to_string(ProxyPort); OutData = Code + std::to_string(ProxyPort);
break; break;
case 'U': case 'U':
if (SubCode == 'l') if (SubCode == 'l')
Data = UlStatus; OutData = UlStatus;
if (SubCode == 'p') { if (SubCode == 'p') {
if (ping > 800) { if (ping > 800) {
Data = "Up-2"; OutData = "Up-2";
} else } else
Data = "Up" + std::to_string(ping); OutData = "Up" + std::to_string(ping);
} }
if (!SubCode) { if (!SubCode) {
std::string Ping; std::string Ping;
@ -142,11 +144,11 @@ void Parse(std::string Data, SOCKET CSocket) {
Ping = "-2"; Ping = "-2";
else else
Ping = std::to_string(ping); Ping = std::to_string(ping);
Data = std::string(UlStatus) + "\n" + "Up" + Ping; OutData = std::string(UlStatus) + "\n" + "Up" + Ping;
} }
break; break;
case 'M': case 'M':
Data = MStatus; OutData = MStatus;
break; break;
case 'Q': case 'Q':
if (SubCode == 'S') { if (SubCode == 'S') {
@ -157,17 +159,19 @@ void Parse(std::string Data, SOCKET CSocket) {
} }
if (SubCode == 'G') if (SubCode == 'G')
exit(2); exit(2);
Data.clear(); OutData.clear();
break; break;
case 'R': // will send mod name case 'R': // will send mod name
if (ConfList->find(Data) == ConfList->end()) { {
ConfList->insert(Data); auto str = bytespan_to_string(InData);
if (ConfList->find(str) == ConfList->end()) {
ConfList->insert(str);
ModLoaded = true; ModLoaded = true;
} }
Data.clear(); OutData.clear();
break; } break;
case 'Z': case 'Z':
Data = "Z" + GetVer(); OutData = "Z" + GetVer();
break; break;
case 'N': case 'N':
if (SubCode == 'c') { if (SubCode == 'c') {
@ -180,20 +184,21 @@ void Parse(std::string Data, SOCKET CSocket) {
if (!UserRole.empty()) { if (!UserRole.empty()) {
Auth["role"] = UserRole; Auth["role"] = UserRole;
} }
Data = "N" + Auth.dump(); OutData = "N" + Auth.dump();
} else { } else {
Data = "N" + Login(Data.substr(Data.find(':') + 1)); auto indata_str = bytespan_to_string(InData);
OutData = "N" + Login(indata_str.substr(indata_str.find(':') + 1));
} }
break; break;
default: default:
Data.clear(); OutData.clear();
break; break;
} }
if (!Data.empty() && CSocket != -1) { if (!OutData.empty() && CSocket != -1) {
uint32_t DataSize = Data.size(); uint32_t DataSize = OutData.size();
std::vector<char> ToSend(sizeof(DataSize) + Data.size()); std::vector<char> ToSend(sizeof(DataSize) + OutData.size());
std::copy_n(reinterpret_cast<char*>(&DataSize), sizeof(DataSize), ToSend.begin()); std::copy_n(reinterpret_cast<char*>(&DataSize), sizeof(DataSize), ToSend.begin());
std::copy_n(Data.data(), Data.size(), ToSend.begin() + sizeof(DataSize)); std::copy_n(OutData.data(), OutData.size(), ToSend.begin() + sizeof(DataSize));
int res = send(CSocket, ToSend.data(), int(ToSend.size()), 0); int res = send(CSocket, ToSend.data(), int(ToSend.size()), 0);
if (res < 0) { if (res < 0) {
debug("(Core) send failed with error: " + std::to_string(WSAGetLastError())); debug("(Core) send failed with error: " + std::to_string(WSAGetLastError()));
@ -201,46 +206,16 @@ void Parse(std::string Data, SOCKET CSocket) {
} }
} }
void GameHandler(SOCKET Client) { void GameHandler(SOCKET Client) {
std::vector<char> data {};
int32_t Size, Temp, Rcv;
char Header[10] = { 0 };
do { do {
Rcv = 0; try {
do { ReceiveFromGame(Client, data);
Temp = recv(Client, &Header[Rcv], 1, 0); Parse(data, Client);
if (Temp < 1) } catch (const std::exception& e) {
break; error(std::string("Error while receiving from game: ") + e.what());
if (!isdigit(Header[Rcv]) && Header[Rcv] != '>') {
error("(Core) Invalid lua communication");
KillSocket(Client);
return;
}
} while (Header[Rcv++] != '>');
if (Temp < 1)
break;
if (std::from_chars(Header, &Header[Rcv], Size).ptr[0] != '>') {
debug("(Core) Invalid lua Header -> " + std::string(Header, Rcv));
break; break;
} }
std::string Ret(Size, 0); } while (true);
Rcv = 0;
do {
Temp = recv(Client, &Ret[Rcv], Size - Rcv, 0);
if (Temp < 1)
break;
Rcv += Temp;
} while (Rcv < Size);
if (Temp < 1)
break;
Parse(Ret, Client);
} while (Temp > 0);
if (Temp == 0) {
debug("(Core) Connection closing");
} else {
debug("(Core) recv failed with error: " + std::to_string(WSAGetLastError()));
}
NetReset(); NetReset();
KillSocket(Client); KillSocket(Client);
} }
@ -286,6 +261,11 @@ void CoreMain() {
WSACleanup(); WSACleanup();
return; return;
} }
#if defined (__linux__)
int opt = 1;
if (setsockopt(LSocket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
error("setsockopt(SO_REUSEADDR) failed");
#endif
iRes = bind(LSocket, res->ai_addr, int(res->ai_addrlen)); iRes = bind(LSocket, res->ai_addr, int(res->ai_addrlen));
if (iRes == SOCKET_ERROR) { if (iRes == SOCKET_ERROR) {
error("(Core) bind failed with error: " + std::to_string(WSAGetLastError())); error("(Core) bind failed with error: " + std::to_string(WSAGetLastError()));

64
src/Network/GlobalHandler.cpp
View File

@ -5,8 +5,11 @@
/// ///
/// Created by Anonymous275 on 7/25/2020 /// Created by Anonymous275 on 7/25/2020
/// ///
#include "Helpers.h"
#include "Network/network.hpp" #include "Network/network.hpp"
#include "NetworkHelpers.h"
#include <algorithm> #include <algorithm>
#include <span>
#include <vector> #include <vector>
#include <zlib.h> #include <zlib.h>
#if defined(_WIN32) #if defined(_WIN32)
@ -89,15 +92,13 @@ void GameSend(std::string_view RawData) {
return; return;
}*/ }*/
} }
void ServerSend(std::string Data, bool Rel) {
void ServerSend(const std::vector<char>& Data, bool Rel) {
if (Terminate || Data.empty()) if (Terminate || Data.empty())
return; return;
if (Data.find("Zp") != std::string::npos && Data.size() > 500) {
abort();
}
char C = 0; char C = 0;
bool Ack = false; bool Ack = false;
int DLen = int(Data.length()); int DLen = int(Data.size());
if (DLen > 3) if (DLen > 3)
C = Data.at(0); C = Data.at(0);
if (C == 'O' || C == 'T') if (C == 'O' || C == 'T')
@ -113,14 +114,6 @@ void ServerSend(std::string Data, bool Rel) {
TCPSend(Data, TCPSock); TCPSend(Data, TCPSock);
} else } else
UDPSend(Data); UDPSend(Data);
if (DLen > 1000) {
debug("(Launcher->Server) Bytes sent: " + std::to_string(Data.length()) + " : "
+ Data.substr(0, 10)
+ Data.substr(Data.length() - 10));
} else if (C == 'Z') {
// debug("(Game->Launcher) : " + Data);
}
} }
void NetReset() { void NetReset() {
@ -178,6 +171,11 @@ SOCKET SetupListener() {
WSACleanup(); WSACleanup();
return -1; return -1;
} }
#if defined (__linux__)
int opt = 1;
if (setsockopt(GSocket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
error("setsockopt(SO_REUSEADDR) failed");
#endif
iRes = bind(GSocket, result->ai_addr, (int)result->ai_addrlen); iRes = bind(GSocket, result->ai_addr, (int)result->ai_addrlen);
if (iRes == SOCKET_ERROR) { if (iRes == SOCKET_ERROR) {
error("(Proxy) bind failed with error: " + std::to_string(WSAGetLastError())); error("(Proxy) bind failed with error: " + std::to_string(WSAGetLastError()));
@ -198,7 +196,7 @@ SOCKET SetupListener() {
} }
void AutoPing() { void AutoPing() {
while (!Terminate) { while (!Terminate) {
ServerSend("p", false); ServerSend(strtovec("p"), false);
PingStart = std::chrono::high_resolution_clock::now(); PingStart = std::chrono::high_resolution_clock::now();
std::this_thread::sleep_for(std::chrono::seconds(1)); std::this_thread::sleep_for(std::chrono::seconds(1));
} }
@ -266,42 +264,18 @@ void TCPGameServer(const std::string& IP, int Port) {
t1.detach(); t1.detach();
CServer = false; CServer = false;
} }
int32_t Size, Temp, Rcv; std::vector<char> data {};
char Header[10] = { 0 };
// Read byte by byte until '>' is rcved then get the size and read based on it // Read byte by byte until '>' is rcved then get the size and read based on it
do { do {
Rcv = 0; try {
ReceiveFromGame(CSocket, data);
do { ServerSend(data, false);
Temp = recv(CSocket, &Header[Rcv], 1, 0); } catch (const std::exception& e) {
if (Temp < 1 || TCPTerminate) error(std::string("Error while receiving from game: ") + e.what());
break;
} while (Header[Rcv++] != '>');
if (Temp < 1 || TCPTerminate)
break;
if (std::from_chars(Header, &Header[Rcv], Size).ptr[0] != '>') {
debug("(Game) Invalid lua Header -> " + std::string(Header, Rcv));
break; break;
} }
std::string Ret(Size, 0); } while (!TCPTerminate);
Rcv = 0;
do {
Temp = recv(CSocket, &Ret[Rcv], Size - Rcv, 0);
if (Temp < 1)
break;
Rcv += Temp;
} while (Rcv < Size && !TCPTerminate);
if (Temp < 1 || TCPTerminate)
break;
ServerSend(Ret, false);
} while (Temp > 0 && !TCPTerminate);
if (Temp == 0)
debug("(Proxy) Connection closing");
else
debug("(Proxy) recv failed error : " + std::to_string(WSAGetLastError()));
} }
TCPTerminate = true; TCPTerminate = true;
GConnected = false; GConnected = false;

12
src/Network/Resources.cpp
View File

@ -73,7 +73,7 @@ void Abord() {
} }
std::string Auth(SOCKET Sock) { std::string Auth(SOCKET Sock) {
TCPSend("VC" + GetVer(), Sock); TCPSend(strtovec("VC" + GetVer()), Sock);
auto Res = TCPRcv(Sock); auto Res = TCPRcv(Sock);
@ -82,7 +82,7 @@ std::string Auth(SOCKET Sock) {
return ""; return "";
} }
TCPSend(PublicKey, Sock); TCPSend(strtovec(PublicKey), Sock);
if (Terminate) if (Terminate)
return ""; return "";
@ -100,7 +100,7 @@ std::string Auth(SOCKET Sock) {
UUl("Authentication failed!"); UUl("Authentication failed!");
return ""; return "";
} }
TCPSend("SR", Sock); TCPSend(strtovec("SR"), Sock);
if (Terminate) if (Terminate)
return ""; return "";
@ -114,7 +114,7 @@ std::string Auth(SOCKET Sock) {
if (Res.empty() || Res == "-") { if (Res.empty() || Res == "-") {
info("Didn't Receive any mods..."); info("Didn't Receive any mods...");
ListOfMods = "-"; ListOfMods = "-";
TCPSend("Done", Sock); TCPSend(strtovec("Done"), Sock);
info("Done!"); info("Done!");
return ""; return "";
} }
@ -320,7 +320,7 @@ void SyncResources(SOCKET Sock) {
CheckForDir(); CheckForDir();
std::string FName = a.substr(a.find_last_of('/')); std::string FName = a.substr(a.find_last_of('/'));
do { do {
TCPSend("f" + *FN, Sock); TCPSend(strtovec("f" + *FN), Sock);
std::string Data = TCPRcv(Sock); std::string Data = TCPRcv(Sock);
if (Data == "CO" || Terminate) { if (Data == "CO" || Terminate) {
@ -362,7 +362,7 @@ void SyncResources(SOCKET Sock) {
} }
KillSocket(DSock); KillSocket(DSock);
if (!Terminate) { if (!Terminate) {
TCPSend("Done", Sock); TCPSend(strtovec("Done"), Sock);
info("Done!"); info("Done!");
} else { } else {
UlStatus = "Ulstart"; UlStatus = "Ulstart";

25
src/Network/VehicleData.cpp
View File

@ -26,12 +26,15 @@
SOCKET UDPSock = -1; SOCKET UDPSock = -1;
sockaddr_in* ToServer = nullptr; sockaddr_in* ToServer = nullptr;
void UDPSend(std::string Data) { void UDPSend(const std::vector<char>& RawData) {
if (ClientID == -1 || UDPSock == -1) if (ClientID == -1 || UDPSock == -1)
return; return;
if (Data.length() > 400) { std::string Data;
auto res = Comp(std::span<char>(Data.data(), Data.size())); if (Data.size() > 400) {
auto res = Comp(RawData);
Data = "ABG:" + std::string(res.data(), res.size()); Data = "ABG:" + std::string(res.data(), res.size());
} else {
Data = std::string(RawData.data(), RawData.size());
} }
std::string Packet = char(ClientID + 1) + std::string(":") + Data; std::string Packet = char(ClientID + 1) + std::string(":") + Data;
int sendOk = sendto(UDPSock, Packet.c_str(), int(Packet.size()), 0, (sockaddr*)ToServer, sizeof(*ToServer)); int sendOk = sendto(UDPSock, Packet.c_str(), int(Packet.size()), 0, (sockaddr*)ToServer, sizeof(*ToServer));
@ -39,12 +42,14 @@ void UDPSend(std::string Data) {
error("Error Code : " + std::to_string(WSAGetLastError())); error("Error Code : " + std::to_string(WSAGetLastError()));
} }
void SendLarge(std::string Data) { void SendLarge(const std::vector<char>& Data) {
if (Data.length() > 400) { if (Data.size() > 400) {
auto res = Comp(std::span<char>(Data.data(), Data.size())); auto res = Comp(Data);
Data = "ABG:" + std::string(res.data(), res.size()); res.insert(res.begin(), {'A', 'B', 'G', ':'});
TCPSend(res, TCPSock);
} else {
TCPSend(Data, TCPSock);
} }
TCPSend(Data, TCPSock);
} }
void UDPParser(std::string_view Packet) { void UDPParser(std::string_view Packet) {
@ -90,8 +95,8 @@ void UDPClientMain(const std::string& IP, int Port) {
inet_pton(AF_INET, IP.c_str(), &ToServer->sin_addr); inet_pton(AF_INET, IP.c_str(), &ToServer->sin_addr);
UDPSock = socket(AF_INET, SOCK_DGRAM, 0); UDPSock = socket(AF_INET, SOCK_DGRAM, 0);
GameSend("P" + std::to_string(ClientID)); GameSend("P" + std::to_string(ClientID));
TCPSend("H", TCPSock); TCPSend(strtovec("H"), TCPSock);
UDPSend("p"); UDPSend(strtovec("p"));
while (!Terminate) while (!Terminate)
UDPRcv(); UDPRcv();
KillSocket(UDPSock); KillSocket(UDPSock);

6
src/Network/VehicleEvent.cpp
View File

@ -46,7 +46,7 @@ void UUl(const std::string& R) {
UlStatus = "UlDisconnected: " + R; UlStatus = "UlDisconnected: " + R;
} }
void TCPSend(const std::string& Data, uint64_t Sock) { void TCPSend(const std::vector<char>& Data, uint64_t Sock) {
if (Sock == -1) { if (Sock == -1) {
Terminate = true; Terminate = true;
UUl("Invalid Socket"); UUl("Invalid Socket");
@ -57,7 +57,7 @@ void TCPSend(const std::string& Data, uint64_t Sock) {
std::string Send(4, 0); std::string Send(4, 0);
Size = int32_t(Data.size()); Size = int32_t(Data.size());
memcpy(&Send[0], &Size, sizeof(Size)); memcpy(&Send[0], &Size, sizeof(Size));
Send += Data; Send += std::string(Data.data(), Data.size());
// Do not use Size before this point for anything but the header // Do not use Size before this point for anything but the header
Sent = 0; Sent = 0;
Size += 4; Size += 4;
@ -113,7 +113,7 @@ std::string TCPRcv(SOCKET Sock) {
if (Ret.substr(0, 4) == "ABG:") { if (Ret.substr(0, 4) == "ABG:") {
auto substr = Ret.substr(4); auto substr = Ret.substr(4);
auto res = DeComp(std::span<char>(substr.data(), substr.size())); auto res = DeComp(strtovec(substr));
Ret = std::string(res.data(), res.size()); Ret = std::string(res.data(), res.size());
} }

35
src/NetworkHelpers.cpp Normal file
View File

@ -0,0 +1,35 @@
#include "NetworkHelpers.h"
#include <array>
#include <cerrno>
#include <cstring>
#include <stdexcept>
#if defined(__linux__)
#include <sys/socket.h>
#else
#include <winsock2.h>
#include <ws2tcpip.h>
#endif
static uint32_t RecvHeader(SOCKET socket) {
std::array<uint8_t, sizeof(uint32_t)> header_buffer {};
auto n = recv(socket, reinterpret_cast<char*>(header_buffer.data()), header_buffer.size(), MSG_WAITALL);
if (n < 0) {
throw std::runtime_error(std::string("recv() of header failed: ") + std::strerror(errno));
} else if (n == 0) {
throw std::runtime_error("Game disconnected");
}
return *reinterpret_cast<uint32_t*>(header_buffer.data());
}
/// Throws!!!
void ReceiveFromGame(SOCKET socket, std::vector<char>& out_data) {
auto header = RecvHeader(socket);
out_data.resize(header);
auto n = recv(socket, reinterpret_cast<char*>(out_data.data()), out_data.size(), MSG_WAITALL);
if (n < 0) {
throw std::runtime_error(std::string("recv() of data failed: ") + std::strerror(errno));
} else if (n == 0) {
throw std::runtime_error("Game disconnected");
}
}