server.c

// SPDX-License-Identifier: BSD-2-Clause
// SPDX-FileCopyrightText: Copyright (c) 2025 Runxi Yu <https://runxiyu.org>
//
//go:build ignore

#include <sys/socket.h>
#include <sys/un.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define BUF_SIZE 4096

void *handle_client(void *arg)
{
	int client_fd = *(int *)arg;
	free(arg);

	char *data = NULL;
	size_t total_len = 0, cap = 0;

	ssize_t n;
	for (char buf[BUF_SIZE]; (n = read(client_fd, buf, sizeof(buf))) > 0;) {
		if (total_len + n > cap) {
			cap = cap ? cap * 2 : 8192;
			data = realloc(data, cap);
			if (!data) {
				perror("realloc");
				close(client_fd);
				return NULL;
			}
		}
		memcpy(data + total_len, buf, n);
		total_len += n;
	}
	if (n < 0) {
		perror("read");
		close(client_fd);
		free(data);
		return NULL;
	}

	int memfd = memfd_create("shared_data", MFD_CLOEXEC);
	if (memfd < 0) {
		perror("memfd_create");
		close(client_fd);
		free(data);
		return NULL;
	}

	size_t new_size = total_len;
	if (ftruncate(memfd, new_size) < 0) {
		perror("ftruncate");
		close(memfd);
		close(client_fd);
		free(data);
		return NULL;
	}

	void *new_data = mmap(NULL, new_size, PROT_WRITE, MAP_SHARED, memfd, 0);
	if (new_data == MAP_FAILED) {
		perror("mmap");
		close(memfd);
		close(client_fd);
		free(data);
		return NULL;
	}

	memcpy(new_data, data, new_size);

	free(data);

	struct msghdr msg = { 0 };
	struct iovec iov;
	char ctrl_buf[CMSG_SPACE(sizeof(int))];
	char dummy = 'X';

	iov.iov_base = &dummy;
	iov.iov_len = 1;
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = ctrl_buf;
	msg.msg_controllen = sizeof(ctrl_buf);

	struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
	cmsg->cmsg_level = SOL_SOCKET;
	cmsg->cmsg_type = SCM_RIGHTS;
	cmsg->cmsg_len = CMSG_LEN(sizeof(int));
	*((int *)CMSG_DATA(cmsg)) = memfd;

	msg.msg_controllen = cmsg->cmsg_len;

	if (sendmsg(client_fd, &msg, 0) < 0) {
		perror("sendmsg");
	}

	close(memfd);
	close(client_fd);
	return NULL;
}

int main(int argc, char **argv)
{
	if (argc != 2) {
		fprintf(stderr, "Usage: %s <socket_path>\n", argv[0]);
		exit(1);
	}

	if (unlink(argv[1]) == -1 && errno != ENOENT) {
		perror("unlink");
		exit(1);
	}

	int sock_fd = socket(AF_UNIX, SOCK_STREAM, 0);
	if (sock_fd < 0) {
		perror("socket");
		exit(1);
	}

	struct sockaddr_un addr = { 0 };
	addr.sun_family = AF_UNIX;
	strncpy(addr.sun_path, argv[1], sizeof(addr.sun_path) - 1);

	if (bind(sock_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
		perror("bind");
		exit(1);
	}

	if (listen(sock_fd, 5) < 0) {
		perror("listen");
		exit(1);
	}

	while (1) {
		int client_fd = accept(sock_fd, NULL, NULL);
		if (client_fd < 0) {
			perror("accept");
			continue;
		}

		int *pclient = malloc(sizeof(int));
		*pclient = client_fd;

		pthread_t tid;
		pthread_create(&tid, NULL, handle_client, pclient);
		pthread_detach(tid);
	}
}