sleela_net.c
impl/core/sleela_net.c · 255 line(s) · c
/* POSIX feature-test macro: strict -std=c11 hides getaddrinfo/struct addrinfo
* and related POSIX.1-2008 networking symbols on glibc unless requested
* explicitly. Must be defined before any system header is included. */
#if !defined(_WIN32) && !defined(_WIN64) && !defined(_POSIX_C_SOURCE)
#define _POSIX_C_SOURCE 200809L
#endif
#include "sleela_net.h"
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "Ws2_32.lib")
#else
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>
#endif
static SLNetPlatform requested_platform(void) {
const char* value = getenv("SLEELA_NET_PLATFORM");
if (!value || !*value || strcmp(value, "auto") == 0) return SL_NET_AUTO;
/* "posix" means "the native POSIX backend, whichever it is" so it is
* accepted on both Linux and macOS. */
if (strcmp(value, "posix") == 0) return SL_NET_AUTO;
if (strcmp(value, "linux") == 0) return SL_NET_LINUX;
if (strcmp(value, "macos") == 0 || strcmp(value, "darwin") == 0) return SL_NET_MACOS;
if (strcmp(value, "windows") == 0 || strcmp(value, "win32") == 0) return SL_NET_WINDOWS;
return SL_NET_AUTO;
}
SLNetPlatform slnet_platform(void) {
#if defined(_WIN32)
return SL_NET_WINDOWS;
#elif defined(__APPLE__)
return SL_NET_MACOS;
#else
return SL_NET_LINUX;
#endif
}
const char* slnet_platform_name(void) {
switch (slnet_platform()) {
case SL_NET_WINDOWS: return "windows";
case SL_NET_MACOS: return "macos";
default: return "linux";
}
}
int slnet_platform_is_available(SLNetPlatform platform) {
if (platform == SL_NET_AUTO) return 1;
return platform == slnet_platform();
}
int slnet_startup(void) {
SLNetPlatform requested = requested_platform();
if (requested != SL_NET_AUTO && requested != slnet_platform()) return -1;
#ifdef _WIN32
WSADATA data;
return WSAStartup(MAKEWORD(2, 2), &data) == 0 ? 0 : -1;
#else
return 0;
#endif
}
void slnet_shutdown(void) {
#ifdef _WIN32
WSACleanup();
#endif
}
static int valid_port(uint16_t port) {
(void)port;
return 1;
}
SLNetHandle slnet_listen(uint16_t port, int backlog) {
if (!valid_port(port) || backlog < 1) return SL_NET_INVALID;
#ifdef _WIN32
SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (s == INVALID_SOCKET) return SL_NET_INVALID;
#else
int s = socket(AF_INET, SOCK_STREAM, 0);
if (s < 0) return SL_NET_INVALID;
#endif
int yes = 1;
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(yes)) < 0) {
slnet_close((SLNetHandle)s);
return SL_NET_INVALID;
}
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(port);
if (bind(s, (struct sockaddr*)&addr, sizeof(addr)) < 0 || listen(s, backlog) < 0) {
slnet_close((SLNetHandle)s);
return SL_NET_INVALID;
}
return (SLNetHandle)s;
}
SLNetHandle slnet_listen_on(const char* host, uint16_t port, int backlog) {
if (port == 0 || backlog < 1) return SL_NET_INVALID;
char service[16];
snprintf(service, sizeof(service), "%u", (unsigned)port);
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = host && *host ? 0 : AI_PASSIVE;
struct addrinfo* list = NULL;
if (getaddrinfo(host && *host ? host : NULL, service, &hints, &list) != 0) return SL_NET_INVALID;
SLNetHandle result = SL_NET_INVALID;
for (struct addrinfo* p = list; p; p = p->ai_next) {
#ifdef _WIN32
SOCKET s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
if (s == INVALID_SOCKET) continue;
int yes = 1;
(void)setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(yes));
if (bind(s, p->ai_addr, (int)p->ai_addrlen) == 0 && listen(s, backlog) == 0) {
result = (SLNetHandle)s; break;
}
closesocket(s);
#else
int s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
if (s < 0) continue;
int yes = 1;
(void)setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
if (bind(s, p->ai_addr, p->ai_addrlen) == 0 && listen(s, backlog) == 0) {
result = (SLNetHandle)s; break;
}
close(s);
#endif
}
freeaddrinfo(list);
return result;
}
int slnet_set_timeouts(SLNetHandle handle, uint32_t receive_ms, uint32_t send_ms) {
if (!slnet_valid(handle) || receive_ms == 0 || send_ms == 0) return -1;
#ifdef _WIN32
DWORD rcv = (DWORD)receive_ms, snd = (DWORD)send_ms;
if (setsockopt((SOCKET)handle, SOL_SOCKET, SO_RCVTIMEO, (const char*)&rcv, sizeof(rcv)) != 0) return -1;
if (setsockopt((SOCKET)handle, SOL_SOCKET, SO_SNDTIMEO, (const char*)&snd, sizeof(snd)) != 0) return -1;
#else
struct timeval rcv, snd;
rcv.tv_sec = (time_t)(receive_ms / 1000U); rcv.tv_usec = (suseconds_t)((receive_ms % 1000U) * 1000U);
snd.tv_sec = (time_t)(send_ms / 1000U); snd.tv_usec = (suseconds_t)((send_ms % 1000U) * 1000U);
if (setsockopt((int)handle, SOL_SOCKET, SO_RCVTIMEO, &rcv, sizeof(rcv)) != 0) return -1;
if (setsockopt((int)handle, SOL_SOCKET, SO_SNDTIMEO, &snd, sizeof(snd)) != 0) return -1;
#endif
return 0;
}
SLNetHandle slnet_accept(SLNetHandle listener) {
#ifdef _WIN32
SOCKET s = accept((SOCKET)listener, NULL, NULL);
return s == INVALID_SOCKET ? SL_NET_INVALID : (SLNetHandle)s;
#else
int s = accept((int)listener, NULL, NULL);
return s < 0 ? SL_NET_INVALID : (SLNetHandle)s;
#endif
}
SLNetHandle slnet_connect(const char* host, uint16_t port) {
if (!host || !*host || !valid_port(port)) return SL_NET_INVALID;
char service[16];
snprintf(service, sizeof(service), "%u", (unsigned)port);
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
struct addrinfo* list = NULL;
if (getaddrinfo(host, service, &hints, &list) != 0) return SL_NET_INVALID;
SLNetHandle result = SL_NET_INVALID;
for (struct addrinfo* p = list; p; p = p->ai_next) {
#ifdef _WIN32
SOCKET s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
if (s == INVALID_SOCKET) continue;
if (connect(s, p->ai_addr, (int)p->ai_addrlen) == 0) {
result = (SLNetHandle)s;
break;
}
closesocket(s);
#else
int s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
if (s < 0) continue;
if (connect(s, p->ai_addr, p->ai_addrlen) == 0) {
result = (SLNetHandle)s;
break;
}
close(s);
#endif
}
freeaddrinfo(list);
return result;
}
SLNetCount slnet_read(SLNetHandle handle, char* buffer, size_t capacity) {
if (!buffer || capacity == 0 || !slnet_valid(handle)) return -1;
#ifdef _WIN32
int n = recv((SOCKET)handle, buffer, (int)(capacity > INT_MAX ? INT_MAX : capacity), 0);
#else
ssize_t n = recv((int)handle, buffer, capacity, 0);
#endif
return n < 0 ? -1 : (SLNetCount)n;
}
SLNetCount slnet_write(SLNetHandle handle, const char* data, size_t length) {
if (!slnet_valid(handle)) return -1;
if (length == 0) return 0;
if (!data) return -1;
#ifdef _WIN32
int n = send((SOCKET)handle, data, (int)(length > INT_MAX ? INT_MAX : length), 0);
#else
ssize_t n = send((int)handle, data, length, 0);
#endif
return n < 0 ? -1 : (SLNetCount)n;
}
int slnet_close(SLNetHandle handle) {
if (!slnet_valid(handle)) return -1;
#ifdef _WIN32
return closesocket((SOCKET)handle) == 0 ? 0 : -1;
#else
return close((int)handle) == 0 ? 0 : -1;
#endif
}
int slnet_valid(SLNetHandle handle) {
#ifdef _WIN32
return handle != SL_NET_INVALID && (SOCKET)handle != INVALID_SOCKET;
#else
return handle >= 0;
#endif
}
int slnet_last_error(void) {
#ifdef _WIN32
return WSAGetLastError();
#else
return errno;
#endif
}