/* 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 #include #include #include #include #ifdef _WIN32 #include #include #pragma comment(lib, "Ws2_32.lib") #else #include #include #include #include #include #include #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 }