Make struct cfg global and make the corresponding changes throughout

1 files changed, 30 insertions, 32 deletions

diff --git a/idle.c b/idle.c
index 0ced98d..15abd72 100644
--- a/idle.c
+++ b/idle.c
@@ -116,14 +116,14 @@ write_cmd(char **pos, const char *begin, const char *end)
 }
 
 static int
-idle_check_handshake_complete(struct cfg *cfg, struct uring_task *task, int res)
+idle_check_handshake_complete(struct uring_task *task, int res)
 {
 	size_t remain;
 	char *pos;
 	int32_t mclen;
 	int r;
 
-	assert_return(cfg && task, -EINVAL);
+	assert_return(task, -EINVAL);
 	assert_task_alive_or(DBG_IDLE, task, return -EINTR);
 
 	remain = task->tbuf->len;
@@ -152,7 +152,7 @@ idle_check_handshake_complete(struct cfg *cfg, struct uring_task *task, int res)
 
 #define ONLINE_NEEDLE "\"online\""
 static int
-get_player_count(struct cfg *cfg, const char *pos, size_t remain)
+get_player_count(const char *pos, size_t remain)
 {
 	/*
 	 * Example JSON (line breaks added):
@@ -166,7 +166,7 @@ get_player_count(struct cfg *cfg, const char *pos, size_t remain)
 	char *end;
 	unsigned count;
 
-	assert_return(cfg && pos && remain > 0, -1);
+	assert_return(pos && remain > 0, -1);
 
 	online = memmem(pos, remain, ONLINE_NEEDLE, strlen(ONLINE_NEEDLE));
 	if (!online) {
@@ -192,7 +192,7 @@ get_player_count(struct cfg *cfg, const char *pos, size_t remain)
 }
 
 static void
-idle_check_handshake_reply(struct cfg *cfg, struct uring_task *task, int res)
+idle_check_handshake_reply(struct uring_task *task, int res)
 {
 	struct server *server = container_of(task, struct server, idle_task);
 	int32_t mclen;
@@ -202,7 +202,7 @@ idle_check_handshake_reply(struct cfg *cfg, struct uring_task *task, int res)
 	int player_count = -1;
 	int r;
 
-	assert_return(cfg && task);
+	assert_return(task);
 	assert_task_alive(DBG_IDLE, task);
 
 	debug(DBG_IDLE, "res: %i", res);
@@ -257,34 +257,33 @@ idle_check_handshake_reply(struct cfg *cfg, struct uring_task *task, int res)
 		fprintf(stderr, "%c", pos[i]);
 	*/
 
-	player_count = get_player_count(cfg, pos, remain);
+	player_count = get_player_count(pos, remain);
 
 out:
-	uring_task_close_fd(cfg, task);
-	server_set_active_players(cfg, server, player_count);
+	uring_task_close_fd(task);
+	server_set_active_players(server, player_count);
 	return;
 }
 
 static void
-idle_check_handshake_sent(struct cfg *cfg, struct uring_task *task, int res)
+idle_check_handshake_sent(struct uring_task *task, int res)
 {
-	assert_return(cfg && task);
+	assert_return(task);
 	assert_task_alive(DBG_IDLE, task);
 
 	debug(DBG_IDLE, "sent %i bytes", res);
 	if (res < 0) {
-		uring_task_close_fd(cfg, task);
+		uring_task_close_fd(task);
 		return;
 	}
 
-	uring_tbuf_read_until(cfg, task,
+	uring_tbuf_read_until(task,
 			      idle_check_handshake_complete,
 			      idle_check_handshake_reply);
 }
 
 void
-idle_check_get_player_count(struct cfg *cfg, struct server *server,
-			    struct connection *conn)
+idle_check_get_player_count(struct server *server, struct connection *conn)
 {
 	char buf[1024];
 	char *pos;
@@ -292,7 +291,7 @@ idle_check_get_player_count(struct cfg *cfg, struct server *server,
 	uint16_t port;
 	char hostname[INET6_ADDRSTRLEN];
 
-	assert_return(cfg && server && conn && server->idle_task.priv);
+	assert_return(server && conn && server->idle_task.priv);
 
 	port = saddr_port(&conn->remote);
 	saddr_addr(&conn->remote, hostname, sizeof(hostname));
@@ -313,16 +312,16 @@ idle_check_get_player_count(struct cfg *cfg, struct server *server,
 	server->idle_buf.len = (cmdbuf - server->idle_buf.buf);
 	debug(DBG_IDLE, "sending MC message (%zu bytes)", server->idle_buf.len);
 
-	uring_tbuf_write(cfg, &server->idle_task, idle_check_handshake_sent);
+	uring_tbuf_write(&server->idle_task, idle_check_handshake_sent);
 }
 
 static void
-idle_cb(struct cfg *cfg, struct uring_task *task, int res)
+idle_cb(struct uring_task *task, int res)
 {
 	struct idle *idle = container_of(task, struct idle, task);
 	struct server *server;
 
-	assert_return(cfg && task);
+	assert_return(task);
 	assert_task_alive(DBG_IDLE, task);
 
 	if (res != sizeof(idle->value)) {
@@ -333,9 +332,9 @@ idle_cb(struct cfg *cfg, struct uring_task *task, int res)
 	debug(DBG_IDLE, "timer fired (value: %" PRIu64 ")", idle->value);
 
 	list_for_each_entry(server, &cfg->servers, list)
-		server_idle_check(cfg, server);
+		server_idle_check(server);
 
-	uring_read(cfg, &idle->task, &idle->value, sizeof(idle->value), idle_cb);
+	uring_read(&idle->task, &idle->value, sizeof(idle->value), idle_cb);
 }
 
 static void
@@ -349,26 +348,25 @@ idle_free(struct uring_task *task)
 }
 
 void
-idle_refdump(struct idle *idle)
+idle_refdump()
 {
-	assert_return_silent(idle);
+	assert_return_silent(cfg->idle);
 
-	uring_task_refdump(&idle->task);
+	uring_task_refdump(&cfg->idle->task);
 }
 
 void
-idle_delete(struct cfg *cfg)
+idle_delete()
 {
-	assert_return(cfg);
-	assert_return_silent(cfg->idle);
+	assert_return(cfg->idle);
 
 	debug(DBG_IDLE, "closing fd %i", cfg->idle->task.fd);
-	uring_task_destroy(cfg, &cfg->idle->task);
+	uring_task_destroy(&cfg->idle->task);
 	cfg->idle = NULL;
 }
 
 void
-idle_init(struct cfg *cfg)
+idle_init()
 {
 	struct idle *idle;
 	int ifd;
@@ -384,7 +382,7 @@ idle_init(struct cfg *cfg)
 		}
 	};
 
-	assert_return(cfg);
+	assert_return(!cfg->idle);
 
 	idle = zmalloc(sizeof(*idle));
 	if (!idle)
@@ -397,10 +395,10 @@ idle_init(struct cfg *cfg)
 	if (timerfd_settime(ifd, 0, &tspec, NULL) != 0)
 		die("timerfd_settime: %m");
 
-	uring_task_init(cfg, &idle->task, "idle", uring_parent(cfg), idle_free);
+	uring_task_init(&idle->task, "idle", uring_parent(), idle_free);
 	uring_task_set_fd(&idle->task, ifd);
 	cfg->idle = idle;
 
-	uring_read(cfg, &idle->task, &idle->value, sizeof(idle->value), idle_cb);
+	uring_read(&idle->task, &idle->value, sizeof(idle->value), idle_cb);
 }