kmx git

/* started 2025.03.08 - MIT - https://github.com/skullchap/fnet */

#define nil 		((void*)0)

#ifndef _WIN32
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

typedef int sockt;
#else
#define _CRT_SECURE_NO_WARNINGS
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <winsock2.h>
#include <ws2tcpip.h>
#include <afunix.h>
#include <fcntl.h>
#include <io.h>
#pragma comment(lib, "ws2_32.lib")

typedef SOCKET sockt;
#define close closesocket
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "fnet.h"

typedef unsigned char	uchar;
typedef unsigned short	ushort;
typedef unsigned int	uint;
typedef unsigned long	ulong;

typedef struct	NetAddr NetAddr;
typedef struct	ParsedV4V6 ParsedV4V6;
typedef enum	ConnType ConnType;
typedef enum	SockDomain SockDomain;
typedef enum	SockType SockType;

enum
{
	ProtoStrMaxLen=	8,
	AddrStrMaxLen=	120
};

enum ConnType
{
	Dial,
	Listen
};

enum SockDomain
{
	Local,
	Unix=	Local,
	IPv4,
	IPv6
};

enum SockType
{
	Stream,
	DgRam,
};

struct ParsedV4V6
{
	char	ip[AddrStrMaxLen];
	ushort	port;
	int	isv6;
};

struct NetAddr
{
	char proto[ProtoStrMaxLen], addr[AddrStrMaxLen];
};

struct NetConn
{
	FILE *f;
	ConnType   conntype;
	SockDomain sockdomain;
	SockType   socktype;
	ParsedV4V6 v4v6;
	NetAddr    remote, local;
	sockt fd;
};

static NetConn*	newnetconn(char *proto, char *addr, ConnType ct);
static int	setsockdomaintype(NetConn *c, char *proto, char *addr);
static sockt	sockdial(NetConn *c);
static sockt	socklisten(NetConn *c);
static sockt	sockaccept(NetConn *c);
static int	setlocaddr(NetConn *c);
static int	setremaddr(NetConn *c);
static FILE*	fdfile(sockt fd);
static int	parsev4v6(char *addr, ParsedV4V6 *result);
static int	setfneterr(char *fmt, ...);
static char*	sockerrstr();
static char*	errnostr();

static
int
setsockdomaintype(NetConn *c, char *proto, char *addr)
{
	int v4v6= 0;
	ParsedV4V6 paddr;

	if(strncmp("tcp", proto, ProtoStrMaxLen) == 0){
		v4v6 = 1;
		c->socktype = Stream;
	}else if(strncmp("udp", proto, ProtoStrMaxLen) == 0){
		v4v6 = 1;
		c->socktype = DgRam;
	}else if(strncmp("unix", proto, ProtoStrMaxLen) == 0){
		c->sockdomain = Unix;
		c->socktype = Stream;
	}else{
		setfneterr("unknown proto (%s)", proto);
		return -1;
	}
	if(v4v6){
		if(parsev4v6(addr, &paddr) < 0)
			return -1;
		if(paddr.isv6)
			c->sockdomain = IPv6;
		else
			c->sockdomain = IPv4;
		c->v4v6 = paddr;
	}
	return 0;
}

static
NetConn*
newnetconn(char *proto, char *addr, ConnType ct)
{
	NetConn *c;

	c = calloc(1, sizeof(NetConn));
	if(!c)
		return nil;

	c->conntype = ct;
	if(setsockdomaintype(c, proto, addr) < 0){
		free(c);
		return nil;
	}
	strncpy(c->local.proto, proto, ProtoStrMaxLen);
	strncpy(c->remote.proto, proto, ProtoStrMaxLen);
	if(ct == Dial)
		strncpy(c->remote.addr, addr, AddrStrMaxLen);
	else
		strncpy(c->local.addr, addr, AddrStrMaxLen);
	return c;
}

static
int
dialisten(NetConn *c)
{
	if(c->conntype == Dial){
		if((c->fd = sockdial(c)) < 0){
			return -1;
		}
	}else{
		if((c->fd = socklisten(c)) < 0){
			return -1;
		}
	}
	if(!(c->f = fdfile(c->fd))){
		close(c->fd);
		return -1;
	}
	return 0;
}

NetConn*
fnetdial(char *proto, char *addr)
{
	NetConn *c = newnetconn(proto, addr, Dial);
	if(!c)
		return nil;
	if(dialisten(c) < 0){
		fnetclose(c);
		return nil;
	}
	return c;
}

NetConn*
fnetlisten(char *proto, char *addr)
{
	NetConn *c = newnetconn(proto, addr, Listen);
	if(!c)
		return nil;
	if(dialisten(c) < 0){
		fnetclose(c);
		return nil;
	}
	return c;
}

NetConn*
fnetaccept(NetConn *servc)
{
	NetConn *clientc;

	if(servc->socktype == DgRam){
		setremaddr(servc);
		return servc;
	}

	clientc = newnetconn(servc->local.proto, servc->local.addr, Listen);
	if(!clientc)
		return nil;

	if((clientc->fd = sockaccept(servc)) < 0){
		fnetclose(clientc);
		return nil;
	}
	if(!(clientc->f = fdfile(clientc->fd))){
		close(clientc->fd);
		fnetclose(clientc);
		return nil;
	}
	return clientc;
}

FILE* 	fnetf(NetConn *c)		{return c->f;}
void	fnetclose(NetConn *c)		{if(c->f)fclose(c->f); free(c);}

char*
fnetlocaddr(NetConn *c)
{
	if(c->conntype == Dial && c->local.addr[0] == '\0')
		setlocaddr(c);
	return c->local.addr;
}

char*
fnetremaddr(NetConn *c)
{
	if(c->conntype == Listen &&
	(c->socktype == DgRam || c->remote.addr[0] == '\0'))
		setremaddr(c);
	return c->remote.addr;
}


typedef struct sockaddr_in 	SockaddrIn;
typedef struct sockaddr_in6 	SockaddrIn6;
typedef struct sockaddr_un 	SockaddrUnix;
typedef struct sockaddr		Sockaddr;

static
sockt
sockdial(NetConn *c)
{
	sockt fd;
	SockaddrIn addrV4;
	SockaddrIn6 addrV6;
	SockaddrUnix addrUnix;
	uchar domain, type;
	void *paddr; uint addrlen;

	switch(c->sockdomain)
	{
	case Unix: domain = AF_UNIX; break;
	case IPv4: domain = AF_INET; break;
	case IPv6: domain = AF_INET6; break;
	default: setfneterr("bad socket domain (%d)", c->sockdomain); return -1;
	}
	switch(c->socktype)
	{
	case Stream: type = SOCK_STREAM; break;
	case DgRam:  type = SOCK_DGRAM; break;
	default: setfneterr("bad socket type (%d)", c->socktype); return -1;
	}

#ifndef _WIN32
	fd = socket(domain, type, 0);
	if(fd < 0){
		setfneterr("socket creation failed (%s)", sockerrstr());
		return -1;
	}
#else
	fd = WSASocketA(domain, type, 0, 0, 0, 0);
	if(fd == INVALID_SOCKET){
		setfneterr("socket creation failed (%s)", sockerrstr());
		return -1;
	}
#endif
	if(c->socktype == DgRam){
		int b=1;
		void *p= &b;
		setsockopt(fd, SOL_SOCKET, SO_BROADCAST, p, sizeof(b));
	}

	switch(c->sockdomain)
	{
	case IPv4:
		memset(&addrV4, 0, sizeof(addrV4));
		addrV4.sin_family = AF_INET;
		addrV4.sin_port = htons(c->v4v6.port);
		addrV4.sin_addr.s_addr = inet_addr(c->v4v6.ip);
		paddr = &addrV4;
		addrlen = sizeof(addrV4);
		break;
	case IPv6:
		memset(&addrV6, 0, sizeof(addrV6));
		addrV6.sin6_family = AF_INET6;
		addrV6.sin6_port = htons(c->v4v6.port);
		inet_pton(AF_INET6, c->v4v6.ip, &addrV6.sin6_addr);
		paddr = &addrV6;
		addrlen = sizeof(addrV6);
		break;
	case Unix:
		memset(&addrUnix, 0, sizeof(addrUnix));
		addrUnix.sun_family = AF_UNIX;
		strncpy(addrUnix.sun_path, c->remote.addr, sizeof(addrUnix.sun_path) - 1);
		paddr = &addrUnix;
		addrlen = sizeof(addrUnix);
		break;
	default:
		close(fd);
		setfneterr("bad domain (%d)", c->sockdomain);
		return -1;
	}

	if(connect(fd, paddr, addrlen) < 0){
		close(fd);
		setfneterr("connection failed (%s)", sockerrstr());
		return -1;
	}
	return fd;
}

static
sockt
socklisten(NetConn *c)
{
	sockt fd;
	SockaddrIn addrV4;
	SockaddrIn6 addrV6;
	SockaddrUnix addrUnix;
	uchar domain, type;
	void *paddr; uint addrlen;

	switch(c->sockdomain)
	{
	case Unix: domain = AF_UNIX; break;
	case IPv4: domain = AF_INET; break;
	case IPv6: domain = AF_INET6; break;
	default: setfneterr("bad socket domain (%d)", c->sockdomain); return -1;
	}
	switch(c->socktype)
	{
	case Stream: type = SOCK_STREAM; break;
	case DgRam:  type = SOCK_DGRAM; break;
	default: setfneterr("bad socket type (%d)", c->socktype); return -1;
	}

#ifndef _WIN32
	fd = socket(domain, type, 0);
	if(fd < 0){
		setfneterr("socket creation failed (%s)", sockerrstr());
		return -1;
	}
#else
	fd = WSASocketA(domain, type, 0, 0, 0, 0);
	if(fd == INVALID_SOCKET){
		setfneterr("socket creation failed (%s)", sockerrstr());
		return -1;
	}
#endif

	switch(c->sockdomain)
	{
	case IPv4:
		memset(&addrV4, 0, sizeof(addrV4));
		addrV4.sin_family = AF_INET;
		addrV4.sin_port = htons(c->v4v6.port);
		addrV4.sin_addr.s_addr = inet_addr(c->v4v6.ip);
		paddr = &addrV4;
		addrlen = sizeof(addrV4);
		break;
	case IPv6:
		memset(&addrV6, 0, sizeof(addrV6));
		addrV6.sin6_family = AF_INET6;
		addrV6.sin6_port = htons(c->v4v6.port);
		inet_pton(AF_INET6, c->v4v6.ip, &addrV6.sin6_addr);
		paddr = &addrV6;
		addrlen = sizeof(addrV6);
		break;
	case Unix:
		memset(&addrUnix, 0, sizeof(addrUnix));
		addrUnix.sun_family = AF_UNIX;
		strncpy(addrUnix.sun_path, c->local.addr, sizeof(addrUnix.sun_path) - 1);
		paddr = &addrUnix;
		addrlen = sizeof(addrUnix);
		break;
	default:
		close(fd);
		setfneterr("bad domain (%d)", c->sockdomain);
		return -1;
	}

	if(bind(fd, paddr, addrlen) < 0){
		close(fd);
		setfneterr("bind failed (%s)", sockerrstr());
		return -1;
	}

	if(c->socktype == Stream){
		if(listen(fd, 128) < 0){
			close(fd);
			setfneterr("listen failed (%s)", sockerrstr());
			return -1;
		}
	}
	return fd;
}

sockt
sockaccept(NetConn *c)
{
	sockt cfd = accept(c->fd, nil, nil);
#ifndef _WIN32
	if(cfd < 0){
		setfneterr("accept failed (%s)", sockerrstr());
		return -1;
	}
#else
	if(cfd == INVALID_SOCKET){
		setfneterr("accept failed (%s)", sockerrstr());
		return -1;
	}
#endif
	return cfd;
}

static
int
setlocaddr(NetConn *c)
{
	SockaddrIn addrV4;
	SockaddrIn6 addrV6;
	void *paddr; uint addrlen;
	char buf[AddrStrMaxLen];

	switch(c->sockdomain)
	{
	case IPv4:
		paddr = &addrV4;
		addrlen = sizeof(addrV4);
		break;
	case IPv6:
		paddr = &addrV6;
		addrlen = sizeof(addrV6);
		break;
	case Unix:
		strncpy(c->local.addr, c->remote.addr, AddrStrMaxLen);
		return 0;
	default:
		setfneterr("bad domain (%d)", c->sockdomain);
		return -1;
	}

	if(getsockname(c->fd, paddr, &addrlen) < 0){
		setfneterr("getsockname failed (%s)", sockerrstr());
		return -1;
	}
	if(c->sockdomain == IPv4){
		if(inet_ntop(AF_INET, &addrV4.sin_addr, buf, sizeof(buf)) == nil){
			setfneterr("inet_ntop failed (%s)", sockerrstr());
			return -1;
		}
		snprintf(c->local.addr, AddrStrMaxLen, "%s:%d", buf, ntohs(addrV4.sin_port));
	}
	if(c->sockdomain == IPv6){
		if(inet_ntop(AF_INET6, &addrV6.sin6_addr, buf, sizeof(buf)) == nil){
			setfneterr("inet_ntop failed (%s)", sockerrstr());
			return -1;
		}
		snprintf(c->local.addr, AddrStrMaxLen, "%s:%d", buf, ntohs(addrV6.sin6_port));
	}
	return 0;
}

static
int
setremaddr(NetConn *c)
{
	SockaddrIn addrV4;
	SockaddrIn6 addrV6;
	void *paddr; uint addrlen;
	char buf[AddrStrMaxLen];

	switch(c->sockdomain)
	{
	case IPv4:
		paddr = &addrV4;
		addrlen = sizeof(addrV4);
		break;
	case IPv6:
		paddr = &addrV6;
		addrlen = sizeof(addrV6);
		break;
	case Unix:
		strncpy(c->remote.addr, c->local.addr, AddrStrMaxLen);
		return 0;
	default:
		setfneterr("bad domain (%d)", c->sockdomain);
		return -1;
	}

	if(c->socktype == Stream){
		if(getpeername(c->fd, paddr, &addrlen) < 0){
			setfneterr("getpeername failed (%s)", sockerrstr());
			return -1;
		}
	}else{
		char b[1];
		SockaddrIn addr;
		addr.sin_family = AF_UNSPEC;
		memset(&addr, 0, sizeof(addr));
		connect(c->fd, (Sockaddr*)&addr, sizeof(addr));

		if(recvfrom(c->fd, b, 1, MSG_PEEK, paddr, &addrlen) < 0){
			setfneterr("recvfrom failed (%s)", sockerrstr());
			return -1;
		}
		if(connect(c->fd, paddr, addrlen) < 0){
			setfneterr("connection failed (%s)", errnostr());
			return -1;
		}
	}

	if(c->sockdomain == IPv4){
		if(inet_ntop(AF_INET, &addrV4.sin_addr, buf, sizeof(buf)) == nil){
			setfneterr("inet_ntop failed (%s)", sockerrstr());
			return -1;
		}
		snprintf(c->remote.addr, AddrStrMaxLen, "%s:%d", buf, ntohs(addrV4.sin_port));
	}
	if(c->sockdomain == IPv6){
		if(inet_ntop(AF_INET6, &addrV6.sin6_addr, buf, sizeof(buf)) == nil){
			setfneterr("inet_ntop failed (%s)", sockerrstr());
			return -1;
		}
		snprintf(c->remote.addr, AddrStrMaxLen, "%s:%d", buf, ntohs(addrV6.sin6_port));
	}
	return 0;
}

#ifndef _WIN32
static
FILE*
fdfile(sockt fd)
{
	FILE *f = fdopen(fd, "r+");
	if(f == nil){
		setfneterr("fdopen failed (%s)", errnostr());
		return nil;
	}
	return f;
}
#else
static
FILE*
fdfile(sockt sock)
{
	int fd;
	FILE *f;

	fd = _open_osfhandle((intptr_t)sock, _O_RDWR);
	if(fd == -1){
		setfneterr("open_osfhandle failed (%s)", errnostr());
		return nil;
	}

	f = _fdopen(fd, "r+");
	if(f == nil){
		setfneterr("fdopen failed (%s)", errnostr());
		_close(fd);
		return nil;
	}

	return f;
}
#endif

static
int
validate_ipv4(char *ip_str)
{
	SockaddrIn sa;
	return inet_pton(AF_INET, ip_str, &(sa.sin_addr)) == 1;
}

static
int
validate_ipv6(char *ip_str)
{
	SockaddrIn6 sa6;
	return inet_pton(AF_INET6, ip_str, &(sa6.sin6_addr)) == 1;
}

static
int
parsev4v6(char *addr, ParsedV4V6 *result)
{
	char ip[AddrStrMaxLen];
	int port = 0;
	char *colon_pos;
	char *port_part;

	if(addr[0] == '['){
		char *rbrak = strchr(addr, ']');
		if(!rbrak){
			setfneterr("invalid IPv6 format or missing port");
			return -1;
		}
		colon_pos = strchr(rbrak, ':');
		if(!colon_pos){
			setfneterr("missing port for IPv6");
			return -1;
		}
		strncpy(ip, addr + 1, rbrak - addr - 1);
		ip[rbrak - addr - 1] = '\0';
		port_part = colon_pos + 1;
	}else{
		colon_pos = strrchr(addr, ':');
		if(!colon_pos){
			setfneterr("missing port for IP address");
			return -1;
		}
		strncpy(ip, addr, colon_pos - addr);
		ip[colon_pos - addr] = '\0';
		port_part = colon_pos + 1;
	}

	if(validate_ipv4(ip)){
		result->isv6 = 0;
	}else if(validate_ipv6(ip)){
		result->isv6 = 1;
	}else{
		setfneterr("invalid IP address");
		return -1;
	}

	if(sscanf(port_part, "%d", &port) != 1 || port < 1 || port > 65535){
		setfneterr("invalid port");
		return -1;
	}

	strncpy(result->ip, ip, AddrStrMaxLen);
	result->port = port;
	return 0;
}


/* error.c */

#include <errno.h>
#include <stdarg.h>

# if __STDC_VERSION__ <= 202311L  /* in C23 thread_local is a builtin keyword */
/* https://stackoverflow.com/a/18298965 */
# ifndef thread_local
# if __STDC_VERSION__ >= 201112L && !defined __STDC_NO_THREADS__
#  define thread_local _Thread_local
# elif defined _WIN32 && ( \
	   defined _MSC_VER || \
	   defined __ICL || \
	   defined __DMC__ || \
	   defined __BORLANDC__ )
#  define thread_local __declspec(thread) 
/* note that ICC (linux) and Clang are covered by __GNUC__ */
# elif defined __GNUC__ || \
	   defined __SUNPRO_C || \
	   defined __xlC__
#  define thread_local __thread
# else
# warning "Cannot define thread_local"
# define thread_local
# define no_thread_local
# endif
# endif
# endif

static	thread_local char estr[256];

char*	fneterr(void)	{return estr;}
char*	errnostr(void)	{return strerror(errno);}

char*
sockerrstr(void)
{
#ifndef _WIN32
	return strerror(errno);
#else
	int err;
	static thread_local char msgbuf[256];

	msgbuf[0] = '\0';
	err = WSAGetLastError();
	FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
		nil, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		msgbuf, sizeof(msgbuf), nil);

	size_t len = strlen(msgbuf);
	while(len > 0 && (msgbuf[len - 1] == '\r' || msgbuf[len - 1] == '\n')){
		msgbuf[--len] = '\0';
	}

	return msgbuf;
#endif
}


int
setfneterr(char *fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	if(vsnprintf(estr, sizeof(estr), fmt, args) < 0){
		static char emsg[] = "setfneterr(): vsnprintf error";
		memcpy(estr, emsg, sizeof(emsg));
	}
	va_end(args);
	return 0;
}

int
fnetinit(void)
{
#ifdef _WIN32
	WSADATA wsaData;
	if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0){
		setfneterr("WSAStartup failed (%s)", sockerrstr());
		return -1;
	}
#endif
	return 0;
}

int
fnetcleanup(void)
{
#ifdef _WIN32
	return WSACleanup();
#endif
	return 0;
}
kc3-lang/fnet/fnet.c

Commit

fnet.c
