mirror of
https://github.com/open-goal/jak-project.git
synced 2024-10-20 11:26:18 -04:00
60db0e5ef9
This updates `fmt` to the latest version and moves to just being a copy of their repo to make updating easier (no editing their cmake / figuring out which files to minimally include). The motivation for this is now that we switched to C++ 20, there were a ton of deprecated function usages that is going away in future compiler versions. This gets rid of all those warnings.
192 lines
5 KiB
C++
192 lines
5 KiB
C++
/*!
|
|
* @file xsocket.cpp
|
|
* Cross platform socket library used for the listener.
|
|
*/
|
|
|
|
// clang-format off
|
|
#include "common/common_types.h"
|
|
#ifdef OS_POSIX
|
|
#include <arpa/inet.h>
|
|
#include <netinet/tcp.h>
|
|
#include <sys/socket.h>
|
|
#include <unistd.h>
|
|
#elif _WIN32
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <WinSock2.h>
|
|
#include <WS2tcpip.h>
|
|
#endif
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "fmt/core.h"
|
|
#include "common/log/log.h"
|
|
// clang-format on
|
|
|
|
int open_socket(int af, int type, int protocol) {
|
|
#ifdef OS_POSIX
|
|
return socket(af, type, protocol);
|
|
#elif _WIN32
|
|
WSADATA wsaData = {0};
|
|
int iResult = 0;
|
|
// Initialize Winsock
|
|
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
|
|
if (iResult != 0) {
|
|
lg::error("WSAStartup failed: {}", iResult);
|
|
return 1;
|
|
}
|
|
return socket(af, type, protocol);
|
|
#endif
|
|
}
|
|
|
|
int connect_socket(int socket, sockaddr* addr, int nameLen) {
|
|
int result = connect(socket, addr, nameLen);
|
|
if (result == -1) {
|
|
return -1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#ifdef OS_POSIX
|
|
int accept_socket(int socket, sockaddr* addr, socklen_t* addrLen) {
|
|
return accept(socket, addr, addrLen);
|
|
}
|
|
int select_and_accept_socket(int socket, sockaddr* addr, socklen_t* addrLen, int microSeconds) {
|
|
struct timeval timeout;
|
|
timeout.tv_sec = 0;
|
|
timeout.tv_usec = microSeconds;
|
|
// Use select so it can timeout, accept on the returned socket if it is correct
|
|
fd_set read_sockets;
|
|
FD_ZERO(&read_sockets);
|
|
FD_SET(socket, &read_sockets);
|
|
auto activity = select(socket + 1, &read_sockets, NULL, NULL, &timeout);
|
|
if (activity > 0) {
|
|
return accept(socket, addr, addrLen);
|
|
}
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
int accept_socket(int socket, sockaddr* addr, int* addrLen) {
|
|
WSADATA wsaData = {0};
|
|
int iResult = 0;
|
|
// Initialize Winsock
|
|
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
|
|
if (iResult != 0) {
|
|
lg::error("WSAStartup failed: {}", iResult);
|
|
return 1;
|
|
}
|
|
return accept(socket, addr, addrLen);
|
|
}
|
|
|
|
int select_and_accept_socket(int socket, sockaddr* addr, int* addrLen, int microSeconds) {
|
|
WSADATA wsaData = {0};
|
|
int iResult = 0;
|
|
// Initialize Winsock
|
|
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
|
|
if (iResult != 0) {
|
|
printf("WSAStartup failed: %d\n", iResult);
|
|
return 1;
|
|
}
|
|
struct timeval timeout;
|
|
timeout.tv_sec = 0;
|
|
timeout.tv_usec = microSeconds;
|
|
// Use select so it can timeout, accept on the returned socket if it is correct
|
|
fd_set read_sockets;
|
|
FD_ZERO(&read_sockets);
|
|
FD_SET(socket, &read_sockets);
|
|
auto activity = select(socket + 1, &read_sockets, NULL, NULL, &timeout);
|
|
if (activity > 0) {
|
|
return accept(socket, addr, addrLen);
|
|
}
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
void close_socket(int sock) {
|
|
if (sock < 0) {
|
|
return;
|
|
}
|
|
#ifdef OS_POSIX
|
|
close(sock);
|
|
#elif _WIN32
|
|
closesocket(sock);
|
|
WSACleanup();
|
|
#endif
|
|
}
|
|
|
|
int set_socket_option(int socket, int level, int optname, const void* optval, int optlen) {
|
|
int ret = setsockopt(socket, level, optname, (const char*)optval, optlen);
|
|
if (ret < 0) {
|
|
lg::error("Failed to setsockopt({},{}, {}, _, _) - Error: {}", socket, level, optname,
|
|
strerror(errno));
|
|
}
|
|
#ifdef _WIN32
|
|
if (ret < 0) {
|
|
int err = WSAGetLastError();
|
|
lg::error("WSAGetLastError: {}", err);
|
|
}
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
int set_socket_timeout(int socket, long microSeconds) {
|
|
#ifdef OS_POSIX
|
|
struct timeval timeout = {};
|
|
timeout.tv_sec = 0;
|
|
timeout.tv_usec = microSeconds;
|
|
int ret = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (struct timeval*)&timeout, sizeof(timeout));
|
|
if (ret < 0) {
|
|
printf("Failed to setsockopt(%d, %d, %d, _, _) - Error: %s\n", socket, SOL_SOCKET, SO_RCVTIMEO,
|
|
strerror(errno));
|
|
}
|
|
return ret;
|
|
#elif _WIN32
|
|
DWORD timeout = microSeconds / 1000; // milliseconds
|
|
// TODO - NOTE this might be bad / unreliable if the socket ends up being in a bad state
|
|
// select() instead should be used, will do so if ends up being an issue in practice
|
|
return set_socket_option(socket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
|
|
#endif
|
|
}
|
|
|
|
int write_to_socket(int socket, const char* buf, int len) {
|
|
int bytes_wrote = 0;
|
|
#ifdef OS_POSIX
|
|
bytes_wrote = send(socket, buf, len, MSG_NOSIGNAL);
|
|
#elif _WIN32
|
|
bytes_wrote = send(socket, buf, len, 0);
|
|
#endif
|
|
if (bytes_wrote < 0) {
|
|
lg::error("[XSocket:{}] Error writing to socket", socket);
|
|
}
|
|
return bytes_wrote;
|
|
}
|
|
|
|
int read_from_socket(int socket, char* buf, int len) {
|
|
#ifdef OS_POSIX
|
|
return read(socket, buf, len);
|
|
#elif _WIN32
|
|
return recv(socket, buf, len, 0);
|
|
#endif
|
|
}
|
|
|
|
bool socket_timed_out() {
|
|
#ifdef OS_POSIX
|
|
return errno == EAGAIN;
|
|
#elif _WIN32
|
|
auto err = WSAGetLastError();
|
|
return err == WSAETIMEDOUT;
|
|
#endif
|
|
}
|
|
|
|
std::string address_to_string(const sockaddr_in& addr) {
|
|
char ip_str[INET_ADDRSTRLEN]; // Buffer to hold the IP address string
|
|
// Convert binary IP address to human-readable string using inet_ntop
|
|
if (inet_ntop(AF_INET, &(addr.sin_addr), ip_str, INET_ADDRSTRLEN) == nullptr) {
|
|
// Handle the error (e.g., log, throw an exception, etc.)
|
|
return "Error: Unable to convert IP address";
|
|
}
|
|
return ip_str;
|
|
}
|