recv() keeps returning -1 - c++

Question

I am creating a server proxy between a client and a server. Currently I have found a base of the idea in python, and I'm trying to convert it to C++. However, I'm struggling since my code doesn't seem to work correctly.
Apparently recv keeps returning SOCKET_ERROR, so I am thinking that maybe I've done something wrongly with winsock.
#include <iostream>
#include <string>
#include <WinSock2.h>
#include <ws2tcpip.h>
#include <thread>
#include <vector>
#include <sstream>
#pragma comment(lib, "Ws2_32.lib")
void parse(char* data, int len, int port, const std::string& origin) {
std::cout << "[" << origin << "(" << port << ")] " << data << std::endl;
}
struct ProxyToServer {
SOCKET m_client;
SOCKET m_server;
int m_port;
ProxyToServer() = default;
ProxyToServer(const char* host, int port) {
m_port = port;
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0) {
sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
inet_pton(AF_INET, host, &server_addr.sin_addr);
if ((m_server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {
std::cerr << "[Proxy2Server] Could not create socket!\n";
}
if (connect(m_server, reinterpret_cast<sockaddr*>(&server_addr), sizeof(server_addr)) != 0) {
std::cerr << "[Proxy2Server] Could not connect socket!\n";
}
if (WSACleanup() != 0) {
std::cerr << "Cleanup failed!\n";
}
}
else {
std::cerr << " Winsock startup failed!\n";
}
}
void execute() {
char data[4096];
while (true) {
int totalRecv = recv(m_server, data, 4096, 0);
if (totalRecv == SOCKET_ERROR) std::cout << "Socket error... (recv)" << std::endl;
if (totalRecv > 0) {
parse(data, 4096, m_port, "server");
send(m_client, data, totalRecv, 0);
}
}
}
};
struct ClientToProxy {
SOCKET m_server;
SOCKET m_client;
int m_port;
ClientToProxy() = default;
ClientToProxy(const char* host, int port) {
m_port = port;
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0) {
if (LOBYTE(wsaData.wVersion) >= 2) {
SOCKET sock;
if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {
std::cerr << "[Client2Proxy] Could not create socket!\n";
}
const int enable = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*) & enable, sizeof(enable));
sockaddr_in sock_addr;
sock_addr.sin_family = AF_INET;
sock_addr.sin_port = htons(port);
inet_pton(AF_INET, host, &sock_addr.sin_addr);
if (bind(sock, (sockaddr*)&sock_addr, sizeof(sock_addr)) != 0) {
std::cerr << "[Client2Proxy] Could not bind socket!\n";
}
if (listen(sock, 100) != 0) {
std::cerr << "[Client2Proxy] Could not listen!\n";
}
sockaddr_in clientSockAddr;
int clientSockSize = sizeof(clientSockAddr);
m_client = accept(sock,reinterpret_cast<sockaddr*>(&clientSockAddr),&clientSockSize);
if (m_client == INVALID_SOCKET) std::cerr << "Invalid Client! " << std::endl;
}
else {
std::cerr << "Requested winsock ver is not supported! \n";
}
if (WSACleanup() != 0) {
std::cerr << "Cleanup failed!\n";
}
}
else {
std::cerr << " Winsock startup failed!\n";
}
}
void execute() {
while (true) {
char data[4096];
int totalRecv = recv(m_client, data, sizeof(data), 0);
if (totalRecv == SOCKET_ERROR) std::cout << "Socket error... (recv) " << std::endl;
if (totalRecv > 0) {
parse(data, 4096, m_port, "client");
send(m_server, data, sizeof(data), 0);
}
}
}
};
struct Proxy {
const char* m_from_host;
const char* m_to_host;
int m_port;
ClientToProxy g2p;
ProxyToServer p2s;
Proxy(const char* from_host, const char* to_host, int port) : m_from_host(from_host), m_to_host(to_host), m_port(port) {}
void execute() {
while (true) {
std::cout << "[proxy(" << m_port << ")] setting up" << std::endl;
g2p = ClientToProxy(m_from_host, m_port);
p2s = ProxyToServer(m_to_host, m_port);
std::cout << "[proxy(" << m_port << ")] connection established" << std::endl;
p2s.m_client = g2p.m_client;
g2p.m_server = p2s.m_server;
std::thread t1(&ClientToProxy::execute, &g2p);
std::thread t2(&ProxyToServer::execute, &p2s);
t1.join();
t2.join();
}
}
};
int main() {
Proxy master_server("127.0.0.1", "183.211.202.94", 13011);
std::thread t3(&Proxy::execute, &master_server);
t3.join();
/*
std::vector<Proxy> game_servers;
for (int port = 13000; port < 13006; port++) {
Proxy game_server("127.0.0.1", "185.212.200.90", port);
std::thread t4(&Proxy::execute, &game_server);
game_servers.push_back(game_server);
t4.join();
}*/
}
I don't know how to reduce this code unfortunately. The issues are in all recv calls in both classes seemingly...
N.B I am very sure that all the IPs are correcty and the port as well.