antizona

server.c (6378B)

---

 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 
 #include <err.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "net.h"
 
 struct server_slot {
 	struct sockaddr_in	addr;
 	socklen_t		addr_len;
 	time_t			last_seen;
 	char			name[24];
 	uint16_t		skin;
 	float			x, y, z;
 	float			yaw;
 	int			active;
 };
 
 static struct server_slot	clients[MAX_PLAYERS];
 static int			server_fd;
 static int			max_clients = MAX_PLAYERS;
 
 static int
 find_slot_by_addr(const struct sockaddr_in *addr)
 {
 	int i;
 
 	for (i = 0; i < max_clients; i++) {
 		if (clients[i].active &&
 		    clients[i].addr.sin_addr.s_addr == addr->sin_addr.s_addr &&
 		    clients[i].addr.sin_port == addr->sin_port) {
 			return (i);
 		}
 	}
 	return (-1);
 }
 
 static int
 find_free_slot(void)
 {
 	int i;
 
 	for (i = 0; i < max_clients; i++) {
 		if (!clients[i].active) {
 			return (i);
 		}
 	}
 	return (-1);
 }
 
 static void
 broadcast_world_state(void)
 {
 	struct pkt_world_state pkt;
 	int i, count;
 
 	memset(&pkt, 0, sizeof(pkt));
 	pkt.hdr.magic = NET_MAGIC;
 	pkt.hdr.type = PKT_WORLD_STATE;
 
 	count = 0;
 	for (i = 0; i < max_clients; i++) {
 		if (clients[i].active) {
 			pkt.players[count].id = (uint8_t)i;
 			pkt.players[count].skin = clients[i].skin;
 			pkt.players[count].x = clients[i].x;
 			pkt.players[count].y = clients[i].y;
 			pkt.players[count].z = clients[i].z;
 			pkt.players[count].yaw = clients[i].yaw;
 			count++;
 		}
 	}
 	pkt.player_count = (uint8_t)count;
 
 	for (i = 0; i < max_clients; i++) {
 		if (clients[i].active) {
 			sendto(server_fd, &pkt,
 			    sizeof(struct pkt_header) + 1 + count * sizeof(struct player_state),
 			    0, (struct sockaddr *)&clients[i].addr, clients[i].addr_len);
 		}
 	}
 }
 
 static void
 handle_packet(const uint8_t *buf, ssize_t len, const struct sockaddr_in *src_addr, socklen_t addr_len)
 {
 	const struct pkt_header *hdr;
 	struct pkt_join_ack ack;
 	int slot, i;
 	time_t now;
 
 	if (len < (ssize_t)sizeof(struct pkt_header)) {
 		return;
 	}
 	hdr = (const struct pkt_header *)buf;
 	if (hdr->magic != NET_MAGIC) {
 		return;
 	}
 
 	time(&now);
 	slot = find_slot_by_addr(src_addr);
 
 	if (hdr->type == PKT_JOIN) {
 		const struct pkt_join *pj;
 
 		if (len < (ssize_t)sizeof(struct pkt_join)) {
 			return;
 		}
 		pj = (const struct pkt_join *)buf;
 
 		if (slot < 0) {
 			slot = find_free_slot();
 			if (slot < 0) {
 				return;
 			}
 		}
 
 		clients[slot].addr = *src_addr;
 		clients[slot].addr_len = addr_len;
 		clients[slot].last_seen = now;
 		clients[slot].skin = pj->skin;
 		strncpy(clients[slot].name, pj->name, sizeof(clients[slot].name) - 1);
 		clients[slot].name[sizeof(clients[slot].name) - 1] = '\0';
 		clients[slot].active = 1;
 
 		memset(&ack, 0, sizeof(ack));
 		ack.hdr.magic = NET_MAGIC;
 		ack.hdr.type = PKT_JOIN_ACK;
 		ack.hdr.player_id = (uint8_t)slot;
 		ack.your_id = (uint8_t)slot;
 		ack.game_time = 12.0f;
 		ack.game_weather = 0;
 
 		sendto(server_fd, &ack, sizeof(ack), 0,
 		    (struct sockaddr *)src_addr, addr_len);
 		printf("server: player joined [id=%d, nick=%s]\n", slot, clients[slot].name);
 		return;
 	}
 
 	if (slot < 0) {
 		return;
 	}
 	clients[slot].last_seen = now;
 
 	if (hdr->type == PKT_SYNC) {
 		const struct pkt_sync *ps;
 
 		if (len < (ssize_t)sizeof(struct pkt_sync)) {
 			return;
 		}
 		ps = (const struct pkt_sync *)buf;
 		clients[slot].x = ps->x;
 		clients[slot].y = ps->y;
 		clients[slot].z = ps->z;
 		clients[slot].yaw = ps->yaw;
 		clients[slot].skin = ps->skin;
 	} else if (hdr->type == PKT_CHAT) {
 		const struct pkt_chat *pc;
 		struct pkt_chat out_chat;
 
 		if (len < (ssize_t)sizeof(struct pkt_chat)) {
 			return;
 		}
 		pc = (const struct pkt_chat *)buf;
 		printf("[%s]: %s\n", clients[slot].name, pc->msg);
 
 		memset(&out_chat, 0, sizeof(out_chat));
 		out_chat.hdr.magic = NET_MAGIC;
 		out_chat.hdr.type = PKT_CHAT;
 		out_chat.hdr.player_id = (uint8_t)slot;
 		strncpy(out_chat.name, clients[slot].name, sizeof(out_chat.name) - 1);
 		strncpy(out_chat.msg, pc->msg, sizeof(out_chat.msg) - 1);
 
 		for (i = 0; i < max_clients; i++) {
 			if (clients[i].active) {
 				sendto(server_fd, &out_chat, sizeof(out_chat), 0,
 				    (struct sockaddr *)&clients[i].addr, clients[i].addr_len);
 			}
 		}
 	} else if (hdr->type == PKT_LEAVE) {
 		clients[slot].active = 0;
 		printf("server: player left [id=%d, nick=%s]\n", slot, clients[slot].name);
 	}
 }
 
 int
 main(int argc, char *argv[])
 {
 	struct sockaddr_in srv_addr, cli_addr;
 	struct pollfd pfd;
 	uint8_t buf[2048];
 	ssize_t n;
 	socklen_t addr_len;
 	struct timespec t_last, t_now;
 	double elapsed;
 	int port, i;
 	time_t now;
 
 	if (argc < 3) {
 		fprintf(stderr, "usage: %s <port> <max_players>\n", argv[0]);
 		return (1);
 	}
 
 	port = atoi(argv[1]);
 	max_clients = atoi(argv[2]);
 
 	if (port <= 0 || port > 65535) {
 		errx(1, "invalid port: %s", argv[1]);
 	}
 	if (max_clients <= 0 || max_clients > MAX_PLAYERS) {
 		errx(1, "invalid max_players (1-%d): %s", MAX_PLAYERS, argv[2]);
 	}
 
 	memset(clients, 0, sizeof(clients));
 
 	server_fd = socket(AF_INET, SOCK_DGRAM, 0);
 	if (server_fd < 0) {
 		err(1, "socket");
 	}
 
 	fcntl(server_fd, F_SETFL, O_NONBLOCK);
 
 	memset(&srv_addr, 0, sizeof(srv_addr));
 	srv_addr.sin_family = AF_INET;
 	srv_addr.sin_addr.s_addr = INADDR_ANY;
 	srv_addr.sin_port = htons(port);
 
 	if (bind(server_fd, (struct sockaddr *)&srv_addr, sizeof(srv_addr)) < 0) {
 		err(1, "bind");
 	}
 
 	printf("antizona server listening on port %d (max players: %d)...\n", port, max_clients);
 
 	pfd.fd = server_fd;
 	pfd.events = POLLIN;
 
 	clock_gettime(CLOCK_MONOTONIC, &t_last);
 
 	while (1) {
 		if (poll(&pfd, 1, 5) > 0) {
 			if (pfd.revents & POLLIN) {
 				while (1) {
 					addr_len = sizeof(cli_addr);
 					n = recvfrom(server_fd, buf, sizeof(buf), 0,
 					    (struct sockaddr *)&cli_addr, &addr_len);
 					if (n < 0) {
 						break;
 					}
 					handle_packet(buf, n, &cli_addr, addr_len);
 				}
 			}
 		}
 
 		clock_gettime(CLOCK_MONOTONIC, &t_now);
 		elapsed = (t_now.tv_sec - t_last.tv_sec) +
 		    (t_now.tv_nsec - t_last.tv_nsec) * 1e-9;
 
 		if (elapsed >= 0.033) {
 			time(&now);
 			for (i = 0; i < max_clients; i++) {
 				if (clients[i].active && (now - clients[i].last_seen) > 5) {
 					clients[i].active = 0;
 					printf("server: timeout player [id=%d, nick=%s]\n", i, clients[i].name);
 				}
 			}
 			broadcast_world_state();
 			t_last = t_now;
 		}
 	}
 
 	close(server_fd);
 	return (0);
 }