473 lines
16 KiB
C
473 lines
16 KiB
C
// posix_socket.c - POSIX-ish socket wrappers over native Sys* sockets.
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <ntlite/syscall.h>
|
|
#include "posix.h"
|
|
#include "posix_fd.h"
|
|
|
|
static uint16_t bswap16(uint16_t x) {
|
|
return (uint16_t)((x << 8) | (x >> 8));
|
|
}
|
|
|
|
static uint32_t bswap32(uint32_t x) {
|
|
return ((x & 0x000000FFu) << 24) |
|
|
((x & 0x0000FF00u) << 8) |
|
|
((x & 0x00FF0000u) >> 8) |
|
|
((x & 0xFF000000u) >> 24);
|
|
}
|
|
|
|
__declspec(dllexport) uint16_t htons(uint16_t x) { return bswap16(x); }
|
|
__declspec(dllexport) uint16_t ntohs(uint16_t x) { return bswap16(x); }
|
|
__declspec(dllexport) uint32_t htonl(uint32_t x) { return bswap32(x); }
|
|
__declspec(dllexport) uint32_t ntohl(uint32_t x) { return bswap32(x); }
|
|
|
|
static int ParseByte(const char** p, uint8_t* out) {
|
|
const char* s = *p;
|
|
if (*s < '0' || *s > '9') return 0;
|
|
unsigned v = 0;
|
|
while (*s >= '0' && *s <= '9') {
|
|
v = v * 10 + (unsigned)(*s - '0');
|
|
if (v > 255) return 0;
|
|
s++;
|
|
}
|
|
*out = (uint8_t)v;
|
|
*p = s;
|
|
return 1;
|
|
}
|
|
|
|
static int ParseIpv4Bytes(const char* text, uint8_t out[4]) {
|
|
const char* p = text;
|
|
for (int i = 0; i < 4; i++) {
|
|
if (!ParseByte(&p, &out[i])) return 0;
|
|
if (i != 3) {
|
|
if (*p != '.') return 0;
|
|
p++;
|
|
}
|
|
}
|
|
return *p == '\0';
|
|
}
|
|
|
|
__declspec(dllexport) in_addr_t inet_addr(const char* text) {
|
|
uint8_t b[4];
|
|
if (!text || !ParseIpv4Bytes(text, b)) return INADDR_NONE;
|
|
in_addr_t out = 0;
|
|
uint8_t* p = (uint8_t*)&out;
|
|
p[0] = b[0]; p[1] = b[1]; p[2] = b[2]; p[3] = b[3];
|
|
return out;
|
|
}
|
|
|
|
__declspec(dllexport) char* inet_ntoa(struct in_addr in) {
|
|
static char buf[16];
|
|
const uint8_t* p = (const uint8_t*)&in.s_addr;
|
|
// Tiny decimal formatter, avoiding stdio dependency.
|
|
char* w = buf;
|
|
for (int i = 0; i < 4; i++) {
|
|
unsigned v = p[i];
|
|
if (v >= 100) { *w++ = (char)('0' + v / 100); v %= 100; *w++ = (char)('0' + v / 10); *w++ = (char)('0' + v % 10); }
|
|
else if (v >= 10) { *w++ = (char)('0' + v / 10); *w++ = (char)('0' + v % 10); }
|
|
else { *w++ = (char)('0' + v); }
|
|
if (i != 3) *w++ = '.';
|
|
}
|
|
*w = '\0';
|
|
return buf;
|
|
}
|
|
|
|
static int SockAddrToSys(const struct sockaddr* addr, socklen_t addrlen, SYS_SOCKET_ADDRESS_IPV4* out) {
|
|
if (!addr || !out || addrlen < sizeof(struct sockaddr_in)) { errno = EINVAL; return -1; }
|
|
const struct sockaddr_in* in = (const struct sockaddr_in*)addr;
|
|
if (in->sin_family != AF_INET) { errno = EINVAL; return -1; }
|
|
|
|
memset(out, 0, sizeof(*out));
|
|
out->Family = SYS_AF_INET;
|
|
out->Port = ntohs(in->sin_port);
|
|
const uint8_t* p = (const uint8_t*)&in->sin_addr.s_addr;
|
|
out->Address[0] = p[0];
|
|
out->Address[1] = p[1];
|
|
out->Address[2] = p[2];
|
|
out->Address[3] = p[3];
|
|
return 0;
|
|
}
|
|
|
|
static void SysToSockAddr(const SYS_SOCKET_ADDRESS_IPV4* in, struct sockaddr* addr, socklen_t* addrlen) {
|
|
if (!addr || !addrlen) return;
|
|
if (*addrlen < sizeof(struct sockaddr_in)) {
|
|
*addrlen = sizeof(struct sockaddr_in);
|
|
return;
|
|
}
|
|
|
|
struct sockaddr_in* out = (struct sockaddr_in*)addr;
|
|
memset(out, 0, sizeof(*out));
|
|
out->sin_family = AF_INET;
|
|
out->sin_port = htons(in->Port);
|
|
uint8_t* p = (uint8_t*)&out->sin_addr.s_addr;
|
|
p[0] = in->Address[0];
|
|
p[1] = in->Address[1];
|
|
p[2] = in->Address[2];
|
|
p[3] = in->Address[3];
|
|
*addrlen = sizeof(struct sockaddr_in);
|
|
}
|
|
|
|
static FD_ENTRY* SocketFdGet(int fd) {
|
|
FD_ENTRY* e = FdGet(SysGetCurrentPid(), fd);
|
|
if (!e) return (FD_ENTRY*)0;
|
|
if (e->Type != FD_SOCKET) { errno = ENOTSOCK; return (FD_ENTRY*)0; }
|
|
return e;
|
|
}
|
|
|
|
__declspec(dllexport) int socket(int domain, int type, int protocol) {
|
|
uint32_t kh = 0;
|
|
uint32_t s = SysCreateSocket((uint32_t)domain, (uint32_t)type, (uint32_t)protocol, &kh);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
|
|
int fd = FdAlloc(SysGetCurrentPid(), FD_SOCKET, kh);
|
|
if (fd < 0) {
|
|
SysCloseHandle(kh);
|
|
return -1;
|
|
}
|
|
return fd;
|
|
}
|
|
|
|
__declspec(dllexport) int bind(int fd, const struct sockaddr* addr, socklen_t addrlen) {
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
SYS_SOCKET_ADDRESS_IPV4 a;
|
|
if (SockAddrToSys(addr, addrlen, &a) != 0) return -1;
|
|
uint32_t s = SysBindSocket(e->KHandle, &a, sizeof(a));
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
return 0;
|
|
}
|
|
|
|
__declspec(dllexport) int listen(int fd, int backlog) {
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
uint32_t s = SysListenSocket(e->KHandle, backlog < 0 ? 0u : (uint32_t)backlog);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
return 0;
|
|
}
|
|
|
|
__declspec(dllexport) int accept(int fd, struct sockaddr* addr, socklen_t* addrlen) {
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
|
|
SYS_SOCKET_ADDRESS_IPV4 remote;
|
|
size_t remoteSize = sizeof(remote);
|
|
uint32_t kh = 0;
|
|
uint32_t s = SysAcceptSocket(e->KHandle, addr ? &remote : (SYS_SOCKET_ADDRESS_IPV4*)0,
|
|
addr ? &remoteSize : (size_t*)0, &kh);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
|
|
int outfd = FdAlloc(SysGetCurrentPid(), FD_SOCKET, kh);
|
|
if (outfd < 0) {
|
|
SysCloseHandle(kh);
|
|
return -1;
|
|
}
|
|
if (addr) SysToSockAddr(&remote, addr, addrlen);
|
|
return outfd;
|
|
}
|
|
|
|
__declspec(dllexport) int connect(int fd, const struct sockaddr* addr, socklen_t addrlen) {
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
SYS_SOCKET_ADDRESS_IPV4 a;
|
|
if (SockAddrToSys(addr, addrlen, &a) != 0) return -1;
|
|
uint32_t s = SysConnectSocket(e->KHandle, &a, sizeof(a));
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
return 0;
|
|
}
|
|
|
|
__declspec(dllexport) ssize_t send(int fd, const void* buf, size_t len, int flags) {
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
size_t sent = 0;
|
|
uint32_t s = SysSendSocket(e->KHandle, buf, len, (uint32_t)flags, &sent);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
return (ssize_t)sent;
|
|
}
|
|
|
|
__declspec(dllexport) ssize_t recv(int fd, void* buf, size_t len, int flags) {
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
size_t got = 0;
|
|
uint32_t s = SysRecvSocket(e->KHandle, buf, len, (uint32_t)flags, &got);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
return (ssize_t)got;
|
|
}
|
|
|
|
__declspec(dllexport) ssize_t sendto(int fd, const void* buf, size_t len, int flags,
|
|
const struct sockaddr* dest, socklen_t destlen) {
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
SYS_SOCKET_ADDRESS_IPV4 remote;
|
|
if (SockAddrToSys(dest, destlen, &remote) != 0) return -1;
|
|
|
|
size_t sent = 0;
|
|
SYS_SOCKET_SEND_TO_REQUEST req;
|
|
memset(&req, 0, sizeof(req));
|
|
req.Buffer = buf;
|
|
req.Length = len;
|
|
req.Flags = (uint32_t)flags;
|
|
req.RemoteAddress = &remote;
|
|
req.RemoteAddressSize = sizeof(remote);
|
|
req.SentOut = &sent;
|
|
|
|
uint32_t s = SysSendToSocket(e->KHandle, &req);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
return (ssize_t)sent;
|
|
}
|
|
|
|
__declspec(dllexport) ssize_t recvfrom(int fd, void* buf, size_t len, int flags,
|
|
struct sockaddr* src, socklen_t* srclen) {
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
|
|
SYS_SOCKET_ADDRESS_IPV4 remote;
|
|
size_t remoteSize = sizeof(remote);
|
|
size_t got = 0;
|
|
SYS_SOCKET_RECV_FROM_REQUEST req;
|
|
memset(&req, 0, sizeof(req));
|
|
req.Buffer = buf;
|
|
req.Length = len;
|
|
req.Flags = (uint32_t)flags;
|
|
req.RemoteAddressOut = src ? &remote : (SYS_SOCKET_ADDRESS_IPV4*)0;
|
|
req.RemoteAddressSizeInOut = src ? &remoteSize : (size_t*)0;
|
|
req.ReceivedOut = &got;
|
|
|
|
uint32_t s = SysRecvFromSocket(e->KHandle, &req);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
if (src) SysToSockAddr(&remote, src, srclen);
|
|
return (ssize_t)got;
|
|
}
|
|
|
|
__declspec(dllexport) int shutdown(int fd, int how) {
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
uint32_t s = SysShutdownSocket(e->KHandle, (uint32_t)how);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
return 0;
|
|
}
|
|
|
|
static uint32_t TimevalToMs(const struct timeval* tv) {
|
|
if (!tv) return 0;
|
|
uint64_t ms = (uint64_t)tv->tv_sec * 1000u + (uint64_t)(tv->tv_usec / 1000);
|
|
return ms > 0xFFFFFFFFu ? 0xFFFFFFFFu : (uint32_t)ms;
|
|
}
|
|
|
|
__declspec(dllexport) int setsockopt(int fd, int level, int optname, const void* optval, socklen_t optlen) {
|
|
if (level != SOL_SOCKET || !optval) { errno = EINVAL; return -1; }
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
|
|
uint32_t option = 0;
|
|
uint32_t value = 0;
|
|
if (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO) {
|
|
option = (optname == SO_RCVTIMEO) ? SYS_SOCKET_OPT_RECV_TIMEOUT_MS : SYS_SOCKET_OPT_SEND_TIMEOUT_MS;
|
|
if (optlen == sizeof(struct timeval)) value = TimevalToMs((const struct timeval*)optval);
|
|
else if (optlen == sizeof(uint32_t)) memcpy(&value, optval, sizeof(value));
|
|
else { errno = EINVAL; return -1; }
|
|
} else if (optname == SO_NONBLOCK) {
|
|
option = SYS_SOCKET_OPT_NONBLOCKING;
|
|
if (optlen < sizeof(int)) { errno = EINVAL; return -1; }
|
|
value = (*(const int*)optval) ? 1u : 0u;
|
|
} else {
|
|
errno = ENOSYS;
|
|
return -1;
|
|
}
|
|
|
|
SYS_SOCKET_OPTION_REQUEST req;
|
|
memset(&req, 0, sizeof(req));
|
|
req.Option = option;
|
|
req.Value = &value;
|
|
req.ValueSize = sizeof(value);
|
|
uint32_t s = SysSetSocketOption(e->KHandle, &req);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
return 0;
|
|
}
|
|
|
|
__declspec(dllexport) int getsockopt(int fd, int level, int optname, void* optval, socklen_t* optlen) {
|
|
if (level != SOL_SOCKET || !optval || !optlen) { errno = EINVAL; return -1; }
|
|
FD_ENTRY* e = SocketFdGet(fd);
|
|
if (!e) return -1;
|
|
|
|
uint32_t option = 0;
|
|
if (optname == SO_RCVTIMEO) option = SYS_SOCKET_OPT_RECV_TIMEOUT_MS;
|
|
else if (optname == SO_SNDTIMEO) option = SYS_SOCKET_OPT_SEND_TIMEOUT_MS;
|
|
else if (optname == SO_NONBLOCK) option = SYS_SOCKET_OPT_NONBLOCKING;
|
|
else { errno = ENOSYS; return -1; }
|
|
|
|
uint32_t value = 0;
|
|
size_t actual = sizeof(value);
|
|
SYS_SOCKET_OPTION_REQUEST req;
|
|
memset(&req, 0, sizeof(req));
|
|
req.Option = option;
|
|
req.Value = &value;
|
|
req.ValueSize = sizeof(value);
|
|
req.ActualSizeOut = &actual;
|
|
uint32_t s = SysGetSocketOption(e->KHandle, &req);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
|
|
if ((optname == SO_RCVTIMEO || optname == SO_SNDTIMEO) && *optlen >= sizeof(struct timeval)) {
|
|
struct timeval* tv = (struct timeval*)optval;
|
|
tv->tv_sec = (long)(value / 1000u);
|
|
tv->tv_usec = (long)((value % 1000u) * 1000u);
|
|
*optlen = sizeof(struct timeval);
|
|
} else if (*optlen >= sizeof(uint32_t)) {
|
|
memcpy(optval, &value, sizeof(value));
|
|
*optlen = sizeof(value);
|
|
} else {
|
|
errno = ERANGE;
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
__declspec(dllexport) int poll(struct pollfd* fds, nfds_t nfds, int timeout) {
|
|
if (!fds || nfds == 0 || nfds > 64) { errno = EINVAL; return -1; }
|
|
|
|
SYS_POLLFD* kfds = (SYS_POLLFD*)malloc(sizeof(SYS_POLLFD) * nfds);
|
|
if (!kfds) { errno = ENOMEM; return -1; }
|
|
|
|
for (nfds_t i = 0; i < nfds; i++) {
|
|
kfds[i].Handle = 0;
|
|
kfds[i].Events = 0;
|
|
kfds[i].ReturnedEvents = 0;
|
|
|
|
fds[i].revents = 0;
|
|
FD_ENTRY* e = FdGet(SysGetCurrentPid(), fds[i].fd);
|
|
if (!e || e->Type != FD_SOCKET) {
|
|
continue;
|
|
}
|
|
kfds[i].Handle = e->KHandle;
|
|
if (fds[i].events & POLLIN) kfds[i].Events |= SYS_POLL_READ;
|
|
if (fds[i].events & POLLOUT) kfds[i].Events |= SYS_POLL_WRITE;
|
|
if (fds[i].events & POLLERR) kfds[i].Events |= SYS_POLL_ERROR;
|
|
if (fds[i].events & POLLHUP) kfds[i].Events |= SYS_POLL_HANGUP;
|
|
}
|
|
|
|
size_t ready = 0;
|
|
uint32_t timeoutMs = timeout < 0 ? SYS_POLL_TIMEOUT_INFINITE : (uint32_t)timeout;
|
|
uint32_t s = SysPoll(kfds, nfds, timeoutMs, &ready);
|
|
if (s != 0) {
|
|
free(kfds);
|
|
errno = PosixStatusToErrno(s);
|
|
return -1;
|
|
}
|
|
|
|
int out = 0;
|
|
for (nfds_t i = 0; i < nfds; i++) {
|
|
short re = 0;
|
|
if (kfds[i].ReturnedEvents & SYS_POLL_READ) re |= POLLIN;
|
|
if (kfds[i].ReturnedEvents & SYS_POLL_WRITE) re |= POLLOUT;
|
|
if (kfds[i].ReturnedEvents & SYS_POLL_ERROR) re |= POLLERR;
|
|
if (kfds[i].ReturnedEvents & SYS_POLL_HANGUP) re |= POLLHUP;
|
|
if (kfds[i].ReturnedEvents & SYS_POLL_INVALID) re |= POLLNVAL;
|
|
fds[i].revents = re;
|
|
if (re) out++;
|
|
}
|
|
|
|
free(kfds);
|
|
return out;
|
|
}
|
|
|
|
static unsigned ParsePort(const char* s) {
|
|
unsigned v = 0;
|
|
if (!s) return 0;
|
|
while (*s >= '0' && *s <= '9') {
|
|
v = v * 10 + (unsigned)(*s - '0');
|
|
if (v > 65535u) return 0;
|
|
s++;
|
|
}
|
|
return *s == '\0' ? v : 0;
|
|
}
|
|
|
|
static int ResolveNameIpv4(const char* name, SYS_SOCKET_ADDRESS_IPV4* out) {
|
|
uint8_t b[4];
|
|
if (ParseIpv4Bytes(name, b)) {
|
|
memset(out, 0, sizeof(*out));
|
|
out->Family = SYS_AF_INET;
|
|
out->Address[0] = b[0]; out->Address[1] = b[1]; out->Address[2] = b[2]; out->Address[3] = b[3];
|
|
return 0;
|
|
}
|
|
|
|
size_t size = sizeof(*out);
|
|
SYS_RESOLVE_HOST_REQUEST req;
|
|
memset(&req, 0, sizeof(req));
|
|
req.Name = SysSvFromCstr(name);
|
|
req.Family = SYS_AF_INET;
|
|
req.AddressOut = out;
|
|
req.AddressSizeInOut = &size;
|
|
uint32_t s = SysResolveHost(&req);
|
|
if (s != 0) { errno = PosixStatusToErrno(s); return -1; }
|
|
return 0;
|
|
}
|
|
|
|
__declspec(dllexport) struct hostent* gethostbyname(const char* name) {
|
|
static struct hostent h;
|
|
static char hname[256];
|
|
static char* aliases[1];
|
|
static char* addr_list[2];
|
|
static uint8_t addr[4];
|
|
|
|
if (!name || strlen(name) >= sizeof(hname)) { errno = EINVAL; return (struct hostent*)0; }
|
|
|
|
SYS_SOCKET_ADDRESS_IPV4 a;
|
|
if (ResolveNameIpv4(name, &a) != 0) return (struct hostent*)0;
|
|
|
|
strcpy(hname, name);
|
|
memcpy(addr, a.Address, 4);
|
|
aliases[0] = (char*)0;
|
|
addr_list[0] = (char*)addr;
|
|
addr_list[1] = (char*)0;
|
|
|
|
h.h_name = hname;
|
|
h.h_aliases = aliases;
|
|
h.h_addrtype = AF_INET;
|
|
h.h_length = 4;
|
|
h.h_addr_list = addr_list;
|
|
return &h;
|
|
}
|
|
|
|
__declspec(dllexport) int getaddrinfo(const char* node, const char* service,
|
|
const struct addrinfo* hints, struct addrinfo** res) {
|
|
if (!res) return EINVAL;
|
|
*res = (struct addrinfo*)0;
|
|
|
|
int family = hints ? hints->ai_family : AF_INET;
|
|
if (family != AF_INET && family != 0) return EINVAL;
|
|
|
|
SYS_SOCKET_ADDRESS_IPV4 a;
|
|
memset(&a, 0, sizeof(a));
|
|
a.Family = SYS_AF_INET;
|
|
if (!node) {
|
|
a.Address[0] = 0; a.Address[1] = 0; a.Address[2] = 0; a.Address[3] = 0;
|
|
} else if (ResolveNameIpv4(node, &a) != 0) {
|
|
return errno;
|
|
}
|
|
a.Port = service ? ParsePort(service) : 0;
|
|
|
|
size_t total = sizeof(struct addrinfo) + sizeof(struct sockaddr_in);
|
|
struct addrinfo* ai = (struct addrinfo*)malloc(total);
|
|
if (!ai) return ENOMEM;
|
|
memset(ai, 0, total);
|
|
|
|
struct sockaddr_in* sin = (struct sockaddr_in*)((uint8_t*)ai + sizeof(struct addrinfo));
|
|
sin->sin_family = AF_INET;
|
|
sin->sin_port = htons(a.Port);
|
|
uint8_t* p = (uint8_t*)&sin->sin_addr.s_addr;
|
|
p[0] = a.Address[0]; p[1] = a.Address[1]; p[2] = a.Address[2]; p[3] = a.Address[3];
|
|
|
|
ai->ai_family = AF_INET;
|
|
ai->ai_socktype = hints ? hints->ai_socktype : 0;
|
|
ai->ai_protocol = hints ? hints->ai_protocol : 0;
|
|
ai->ai_addrlen = sizeof(struct sockaddr_in);
|
|
ai->ai_addr = (struct sockaddr*)sin;
|
|
ai->ai_next = (struct addrinfo*)0;
|
|
*res = ai;
|
|
return 0;
|
|
}
|
|
|
|
__declspec(dllexport) void freeaddrinfo(struct addrinfo* res) {
|
|
if (res) free(res);
|
|
}
|