Make struct cfg global and make the corresponding changes throughout

1 files changed, 99 insertions, 103 deletions

diff --git a/server.c b/server.c
index 1151cc4..ddd4ad4 100644
--- a/server.c
+++ b/server.c
@@ -32,9 +32,9 @@ struct server_local {
 };
 
 static bool
-set_property(struct cfg *cfg, struct server *server, char **property, const char *value)
+set_property(struct server *server, char **property, const char *value)
 {
-	assert_return(cfg && server && !*property && !empty_str(value), false);
+	assert_return(server && !*property && !empty_str(value), false);
 
 	*property = xstrdup(value);
 	if (!*property) {
@@ -84,7 +84,7 @@ server_free(struct uring_task *task)
 }
 
 void
-server_delete(struct cfg *cfg, struct server *server)
+server_delete(struct server *server)
 {
 	struct server_local *local, *ltmp;
 	struct server_proxy *proxy, *ptmp;
@@ -93,18 +93,18 @@ server_delete(struct cfg *cfg, struct server *server)
 	struct saddr *tmp;
 	struct dns_async *dns, *dtmp;
 
-	assert_return(cfg && server);
+	assert_return(server);
 
 	verbose("Removing server %s", server->name);
 	server->state = SERVER_STATE_DEAD;
 
-	rcon_delete(cfg, server);
+	rcon_delete(server);
 
 	list_for_each_entry_safe(local, ltmp, &server->locals, list)
-		uring_task_destroy(cfg, &local->task);
+		uring_task_destroy(&local->task);
 
 	list_for_each_entry_safe(proxy, ptmp, &server->proxys, list)
-		proxy_delete(cfg, proxy);
+		proxy_delete(proxy);
 
 	list_for_each_entry_safe(rcon, tmp, &server->rcons, list) {
 		list_del(&rcon->list);
@@ -119,23 +119,23 @@ server_delete(struct cfg *cfg, struct server *server)
 	list_for_each_entry_safe(dns, dtmp, &server->dnslookups, list)
 		gai_cancel(&dns->gcb);
 		
-	uring_task_destroy(cfg, &server->idle_task);
-	uring_poll_cancel(cfg, &server->exec_task);
-	uring_task_put(cfg, &server->exec_task);
-	uring_task_destroy(cfg, &server->task);
-	uring_task_put(cfg, &server->ann_task);
+	uring_task_destroy(&server->idle_task);
+	uring_poll_cancel(&server->exec_task);
+	uring_task_put(&server->exec_task);
+	uring_task_destroy(&server->task);
+	uring_task_put(&server->ann_task);
 }
 
 void
-server_delete_by_name(struct cfg *cfg, const char *name)
+server_delete_by_name(const char *name)
 {
 	struct server *server;
 
-	assert_return(cfg && !empty_str(name));
+	assert_return(!empty_str(name));
 
 	list_for_each_entry(server, &cfg->servers, list) {
 		if (streq(server->name, name)) {
-			server_delete(cfg, server);
+			server_delete(server);
 			return;
 		}
 	}
@@ -199,13 +199,13 @@ server_local_free(struct uring_task *task)
 }
 
 static void
-server_local_accept(struct cfg *cfg, struct uring_task *task, int res)
+server_local_accept(struct uring_task *task, int res)
 {
 	struct server_local *local = container_of(task, struct server_local, task);
 	struct server *server = container_of(task->parent, struct server, task);
 	struct server_proxy *proxy;
 
-	assert_return(cfg && task);
+	assert_return(task);
 	assert_task_alive(DBG_SRV, task);
 
 	debug(DBG_SRV, "task %p, res %i, server %s", task, res, server->name);
@@ -223,26 +223,26 @@ server_local_accept(struct cfg *cfg, struct uring_task *task, int res)
 	if (list_empty(&server->remotes)) {
 		/* This shouldn't be possible, checked before opening local */
 		error("server->remotes empty!");
-		uring_close(cfg, &local->task, res);
+		uring_close(&local->task, res);
 		goto out;
 	}
 
-	proxy = proxy_new(cfg, server, &local->client, res);
+	proxy = proxy_new(server, &local->client, res);
 	if (!proxy)
-		uring_close(cfg, &local->task, res);
+		uring_close(&local->task, res);
 
 out:
-	uring_accept(cfg, &local->task, &local->client, server_local_accept);
+	uring_accept(&local->task, &local->client, server_local_accept);
 }
 
 static bool
-server_local_open(struct cfg *cfg, struct server *server, struct server_local *local)
+server_local_open(struct server *server, struct server_local *local)
 {
 	int sfd;
 	int option;
 	int r;
 
-	assert_return(cfg && server && local, false);
+	assert_return(server && local, false);
 
 	sfd = socket(local->local.storage.ss_family, SOCK_STREAM | SOCK_CLOEXEC, 0);
 	if (sfd < 0) {
@@ -267,7 +267,7 @@ server_local_open(struct cfg *cfg, struct server *server, struct server_local *l
 	if (setsockopt(sfd, IPPROTO_IP, IP_FREEBIND, &option, sizeof(option)) < 0)
 		error("setsockopt: %m");
 
-	socket_set_low_latency(cfg, sfd);
+	socket_set_low_latency(sfd);
 
 	r = bind(sfd, (struct sockaddr *)&local->local.storage, local->local.addrlen);
 	if (r < 0) {
@@ -282,7 +282,7 @@ server_local_open(struct cfg *cfg, struct server *server, struct server_local *l
 	}
 
 	uring_task_set_fd(&local->task, sfd);
-	uring_accept(cfg, &local->task, &local->client, server_local_accept);
+	uring_accept(&local->task, &local->client, server_local_accept);
 	return true;
 
 error:
@@ -305,13 +305,13 @@ server_exec_free(struct uring_task *task)
 
 /* FIXME: update states */
 static void
-server_exec_done(struct cfg *cfg, struct uring_task *task, int res)
+server_exec_done(struct uring_task *task, int res)
 {
 	struct server *server = container_of(task, struct server, exec_task);
 	int r;
 	siginfo_t info;
 
-	assert_return(cfg && task);
+	assert_return(task);
 	assert_task_alive_or(DBG_SRV, task, goto out);
 	/* Should we leave child processes running? */
 
@@ -332,7 +332,7 @@ server_exec_done(struct cfg *cfg, struct uring_task *task, int res)
 		error("command failed: %i", info.si_status);
 
 out:
-	uring_task_close_fd(cfg, &server->exec_task);
+	uring_task_close_fd(&server->exec_task);
 }
 
 static int
@@ -351,13 +351,13 @@ server_exec_child(void *ptr)
 #endif
 
 static bool
-server_exec(struct cfg *cfg, struct server *server, const char *cmd)
+server_exec(struct server *server, const char *cmd)
 {
 	char stack[4096]; /* Beautiful/horrible hack :) */
 	int pidfd;
 	int r;
 
-	assert_return(cfg && server && cmd && server->exec_task.fd < 1, false);
+	assert_return(server && cmd && server->exec_task.fd < 1, false);
 
         r = clone(server_exec_child, stack + sizeof(stack),
                   CLONE_VM | CLONE_VFORK | CLONE_PIDFD | SIGCHLD,
@@ -368,19 +368,19 @@ server_exec(struct cfg *cfg, struct server *server, const char *cmd)
 	}
 
 	uring_task_set_fd(&server->exec_task, pidfd);
-	uring_poll(cfg, &server->exec_task, POLLIN, server_exec_done);
+	uring_poll(&server->exec_task, POLLIN, server_exec_done);
 	return true;
 }
 
 static bool
-server_check_running(struct cfg *cfg, struct server *server)
+server_check_running(struct server *server)
 {
-	assert_return(cfg && server, false);
+	assert_return(server, false);
 
 	/* FIXME: other methods, rcon? */
 	if (server->systemd_service) {
 		verbose("%s: checking if systemd service is running", server->name);
-		if (systemd_service_running(cfg, server)) {
+		if (systemd_service_running(server)) {
 			server->state = SERVER_STATE_RUNNING;
 			return true;
 		} else {
@@ -393,26 +393,26 @@ server_check_running(struct cfg *cfg, struct server *server)
 }
 
 bool
-server_start(struct cfg *cfg, struct server *server)
+server_start(struct server *server)
 {
-	assert_return(cfg && server, false);
+	assert_return(server, false);
 	assert_task_alive_or(DBG_SRV, &server->task, return false);
 
 	switch (server->start_method) {
 
 	case SERVER_START_METHOD_EXEC:
 		verbose("Starting server %s via external cmd", server->name);
-		return server_exec(cfg, server, server->start_exec);
+		return server_exec(server, server->start_exec);
 
 	case SERVER_START_METHOD_SYSTEMD:
 		verbose("Starting server %s via systemd (%s)",
 			server->name, server->systemd_service);
 
-		if (systemd_service_start(cfg, server)) {
+		if (systemd_service_start(server)) {
 			server->state = SERVER_STATE_RUNNING;
 			return true;
 		} else
-			return server_check_running(cfg, server);
+			return server_check_running(server);
 
 	case SERVER_START_METHOD_UNDEFINED:
 	default:
@@ -423,29 +423,29 @@ server_start(struct cfg *cfg, struct server *server)
 }
 
 bool
-server_stop(struct cfg *cfg, struct server *server)
+server_stop(struct server *server)
 {
-	assert_return(cfg && server, false);
+	assert_return(server, false);
 	assert_task_alive_or(DBG_SRV, &server->task, return false);
 
 	switch (server->stop_method) {
 
 	case SERVER_STOP_METHOD_EXEC:
 		verbose("Stopping server %s via external cmd", server->name);
-		return server_exec(cfg, server, server->stop_exec);
+		return server_exec(server, server->stop_exec);
 
 	case SERVER_STOP_METHOD_SYSTEMD:
 		verbose("Stopping server %s via systemd (%s)",
 			server->name, server->systemd_service);
-		if (systemd_service_stop(cfg, server)) {
+		if (systemd_service_stop(server)) {
 			server->state = SERVER_STATE_STOPPED;
 			return true;
 		} else
-			return server_check_running(cfg, server);
+			return server_check_running(server);
 
 	case SERVER_STOP_METHOD_RCON:
 		verbose("Stopping server %s via rcon", server->name);
-		rcon_init(cfg, server);
+		rcon_init(server);
 		return true;
 
 	case SERVER_STOP_METHOD_UNDEFINED:
@@ -465,9 +465,9 @@ server_idle_free(struct uring_task *task)
 }
 
 void
-server_set_active_players(struct cfg *cfg, struct server *server, int count)
+server_set_active_players(struct server *server, int count)
 {
-	assert_return(cfg && server);
+	assert_return(server);
 	assert_task_alive(DBG_IDLE, &server->idle_task);
 
 	debug(DBG_IDLE, "%s: currently %i active players",
@@ -484,16 +484,16 @@ server_set_active_players(struct cfg *cfg, struct server *server, int count)
 
 	if (server->idle_count > server->idle_timeout) {
 		verbose("stopping idle server %s", server->name);
-		server_stop(cfg, server); 
+		server_stop(server); 
 	}
 }
 
 static void
-server_idle_connected_cb(struct cfg *cfg, struct connection *conn, bool connected)
+server_idle_connected_cb(struct connection *conn, bool connected)
 {
 	struct server *server = container_of(conn, struct server, idle_conn);
 
-	assert_return(cfg && conn);
+	assert_return(conn);
 	assert_task_alive(DBG_IDLE, &server->idle_task);
 
 	if (!connected) {
@@ -506,13 +506,13 @@ server_idle_connected_cb(struct cfg *cfg, struct connection *conn, bool connecte
 	}
 
 	debug(DBG_IDLE, "connected to remote %s\n", conn->remote.addrstr);
-	idle_check_get_player_count(cfg, server, conn);
+	idle_check_get_player_count(server, conn);
 }
 
 bool
-server_idle_check(struct cfg *cfg, struct server *server)
+server_idle_check(struct server *server)
 {
-	assert_return(cfg && server, false);
+	assert_return(server, false);
 
 	if (server->state == SERVER_STATE_INIT ||
 	    server->state == SERVER_STATE_DEAD)
@@ -529,7 +529,7 @@ server_idle_check(struct cfg *cfg, struct server *server)
 		return true;
 	}
 
-	connect_any(cfg, &server->idle_task, &server->remotes,
+	connect_any(&server->idle_task, &server->remotes,
 		    &server->idle_conn, server_idle_connected_cb);
 	return true;
 }
@@ -543,11 +543,11 @@ server_announce_free(struct uring_task *task)
 }
 
 static void
-server_announce_cb(struct cfg *cfg, struct uring_task *task, int res)
+server_announce_cb(struct uring_task *task, int res)
 {
 	struct server *server = container_of(task, struct server, ann_task);
 
-	assert_return(cfg && task);
+	assert_return(task);
 
 	if (res < 0)
 		error("failure %i", res);
@@ -558,9 +558,9 @@ server_announce_cb(struct cfg *cfg, struct uring_task *task, int res)
 }
 
 bool
-server_announce(struct cfg *cfg, struct server *server, int fd)
+server_announce(struct server *server, int fd)
 {
-	assert_return(cfg && server && fd >= 0, false);
+	assert_return(server && fd >= 0, false);
 
 	if (server->state == SERVER_STATE_INIT ||
 	    server->state == SERVER_STATE_DEAD)
@@ -568,18 +568,18 @@ server_announce(struct cfg *cfg, struct server *server, int fd)
 
 	debug(DBG_ANN, "announcing server: %s", server->name);
 	uring_task_set_fd(&server->ann_task, fd);
-	uring_tbuf_sendmsg(cfg, &server->ann_task, server_announce_cb);
+	uring_tbuf_sendmsg(&server->ann_task, server_announce_cb);
 	return true;
 }
 
 bool
-server_commit(struct cfg *cfg, struct server *server)
+server_commit(struct server *server)
 {
 	struct server_local *local;
 	uint16_t port;
 	int r;
 
-	assert_return(cfg && server && server->name, false);
+	assert_return(server && server->name, false);
 	assert_task_alive_or(DBG_SRV, &server->task, return false);
 
 	if (server->state != SERVER_STATE_INIT) {
@@ -620,8 +620,7 @@ server_commit(struct cfg *cfg, struct server *server)
 	}
 
 	if (server->systemd_service && !server->systemd_obj) {
-		server->systemd_obj = systemd_service_object_path(cfg,
-								server->systemd_service);
+		server->systemd_obj = systemd_object_path(server->systemd_service);
 		if (!server->systemd_obj) {
 			error("%s: failed to create systemd object path (%s)",
 			      server->name, server->systemd_service);
@@ -733,21 +732,21 @@ server_commit(struct cfg *cfg, struct server *server)
 	server_dump(server);
 
 	list_for_each_entry(local, &server->locals, list) {
-		server_local_open(cfg, server, local);
+		server_local_open(server, local);
 	}
 
 	server->state = SERVER_STATE_CFG_OK;
 
-	server_check_running(cfg, server);
+	server_check_running(server);
 
 	debug(DBG_SRV, "success");
 	return true;
 }
 
 bool
-server_add_remote(struct cfg *cfg, struct server *server, struct saddr *remote)
+server_add_remote(struct server *server, struct saddr *remote)
 {
-	assert_return(cfg && server && remote, false);
+	assert_return(server && remote, false);
 	assert_task_alive_or(DBG_SRV, &server->task, return false);
 
 	debug(DBG_SRV, "adding remote: %s", remote->addrstr);
@@ -756,11 +755,11 @@ server_add_remote(struct cfg *cfg, struct server *server, struct saddr *remote)
 }
 
 bool
-server_add_local(struct cfg *cfg, struct server *server, struct saddr *saddr)
+server_add_local(struct server *server, struct saddr *saddr)
 {
 	struct server_local *local;
 
-	assert_return(cfg && server && saddr, false);
+	assert_return(server && saddr, false);
 	assert_task_alive_or(DBG_SRV, &server->task, return false);
 
 	local = zmalloc(sizeof(*local));
@@ -771,16 +770,16 @@ server_add_local(struct cfg *cfg, struct server *server, struct saddr *saddr)
 
 	debug(DBG_SRV, "adding local: %s", saddr->addrstr);
 	local->local = *saddr;
-	uring_task_init(cfg, &local->task, "local", &server->task, server_local_free);
+	uring_task_init(&local->task, "local", &server->task, server_local_free);
 	list_add(&local->list, &server->locals);
 	xfree(saddr);
 	return true;
 }
 
 bool
-server_add_rcon(struct cfg *cfg, struct server *server, struct saddr *rcon)
+server_add_rcon(struct server *server, struct saddr *rcon)
 {
-	assert_return(cfg && server && rcon, false);
+	assert_return(server && rcon, false);
 	assert_task_alive_or(DBG_SRV, &server->task, return false);
 
 	debug(DBG_SRV, "adding rcon: %s", rcon->addrstr);
@@ -789,22 +788,20 @@ server_add_rcon(struct cfg *cfg, struct server *server, struct saddr *rcon)
 }
 
 bool
-server_set_rcon_password(struct cfg *cfg, struct server *server,
-			 const char *password)
+server_set_rcon_password(struct server *server, const char *password)
 {
-	assert_return(cfg && server && !empty_str(password), false);
+	assert_return(server && !empty_str(password), false);
 
-	return set_property(cfg, server, &server->rcon_password, password);
+	return set_property(server, &server->rcon_password, password);
 }
 
 bool
-server_set_systemd_service(struct cfg *cfg, struct server *server,
-			   const char *service)
+server_set_systemd_service(struct server *server, const char *service)
 {
 	const char *suffix;
 	char *tmp;
 
-	assert_return(cfg && server && !empty_str(service) && !server->systemd_service, false);
+	assert_return(server && !empty_str(service) && !server->systemd_service, false);
 
 	suffix = strrchr(service, '.');
 	if (!suffix || !streq(suffix, ".service")) {
@@ -824,7 +821,7 @@ server_set_systemd_service(struct cfg *cfg, struct server *server,
 }
 
 bool
-server_set_stop_method(struct cfg *cfg, struct server *server,
+server_set_stop_method(struct server *server,
 		       enum server_stop_method stop_method)
 {
 	assert_return(server->stop_method == SERVER_STOP_METHOD_UNDEFINED &&
@@ -835,7 +832,7 @@ server_set_stop_method(struct cfg *cfg, struct server *server,
 }
 
 bool
-server_set_start_method(struct cfg *cfg, struct server *server,
+server_set_start_method(struct server *server,
 			enum server_start_method start_method)
 {
 	assert_return(server->start_method == SERVER_START_METHOD_UNDEFINED &&
@@ -846,43 +843,43 @@ server_set_start_method(struct cfg *cfg, struct server *server,
 }
 
 bool
-server_set_stop_exec(struct cfg *cfg, struct server *server, const char *cmd)
+server_set_stop_exec(struct server *server, const char *cmd)
 {
-	assert_return(cfg && server && !empty_str(cmd), false);
+	assert_return(server && !empty_str(cmd), false);
 
-	return set_property(cfg, server, &server->stop_exec, cmd);
+	return set_property(server, &server->stop_exec, cmd);
 }
 
 bool
-server_set_start_exec(struct cfg *cfg, struct server *server, const char *cmd)
+server_set_start_exec(struct server *server, const char *cmd)
 {
-	assert_return(cfg && server && !empty_str(cmd), false);
+	assert_return(server && !empty_str(cmd), false);
 
-	return set_property(cfg, server, &server->start_exec, cmd);
+	return set_property(server, &server->start_exec, cmd);
 }
 
 bool
-server_set_idle_timeout(struct cfg *cfg, struct server *server, uint16_t timeout)
+server_set_idle_timeout(struct server *server, uint16_t timeout)
 {
-	assert_return(cfg && server && timeout > 0 && server->idle_timeout == 0, false);
+	assert_return(server && timeout > 0 && server->idle_timeout == 0, false);
 
 	server->idle_timeout = timeout;
 	return true;
 }
 
 bool
-server_set_port(struct cfg *cfg, struct server *server, uint16_t port)
+server_set_port(struct server *server, uint16_t port)
 {
-	assert_return(cfg && server && port > 0 && server->announce_port == 0, false);
+	assert_return(server && port > 0 && server->announce_port == 0, false);
 
 	server->announce_port = htons(port);
 	return true;
 }
 
 bool
-server_set_type(struct cfg *cfg, struct server *server, enum server_type type)
+server_set_type(struct server *server, enum server_type type)
 {
-	assert_return(cfg && server && type != SERVER_TYPE_UNDEFINED, false);
+	assert_return(server && type != SERVER_TYPE_UNDEFINED, false);
 
 	switch (type) {
 	case SERVER_TYPE_ANNOUNCE:
@@ -899,19 +896,19 @@ server_set_type(struct cfg *cfg, struct server *server, enum server_type type)
 }
 
 bool
-server_set_pretty_name(struct cfg *cfg, struct server *server, const char *pretty_name)
+server_set_pretty_name(struct server *server, const char *pretty_name)
 {
-	assert_return(cfg && server && !empty_str(pretty_name), false);
+	assert_return(server && !empty_str(pretty_name), false);
 
-	return set_property(cfg, server, &server->pretty_name, pretty_name);
+	return set_property(server, &server->pretty_name, pretty_name);
 }
 
 struct server *
-server_new(struct cfg *cfg, const char *name)
+server_new(const char *name)
 {
 	struct server *server;
 
-	assert_return(cfg && !empty_str(name), NULL);
+	assert_return(!empty_str(name), NULL);
 
 	list_for_each_entry(server, &cfg->servers, list) {
 		if (!streq(name, server->name))
@@ -928,23 +925,22 @@ server_new(struct cfg *cfg, const char *name)
 	}
 
 	server->state = SERVER_STATE_INIT;
-	server->cfg = cfg;
 	server->type = SERVER_TYPE_UNDEFINED;
 	server->name = xstrdup(name);
 	server->stop_method = SERVER_STOP_METHOD_UNDEFINED;
 	server->start_method = SERVER_START_METHOD_UNDEFINED;
 	server->idle_timeout = 0;
 
-	uring_task_init(cfg, &server->task, server->name, uring_parent(cfg), server_free);
+	uring_task_init(&server->task, server->name, uring_parent(), server_free);
 	uring_task_set_buf(&server->task, &server->tbuf);
 
-	uring_task_init(cfg, &server->ann_task, "announce", &server->task, server_announce_free);
+	uring_task_init(&server->ann_task, "announce", &server->task, server_announce_free);
 	uring_task_set_buf(&server->ann_task, &server->ann_buf);
 	saddr_set_ipv4(&server->ann_task.saddr, cinet_addr(224,0,2,60), htons(4445));
 
-	uring_task_init(cfg, &server->exec_task, "exec", &server->task, server_exec_free);
+	uring_task_init(&server->exec_task, "exec", &server->task, server_exec_free);
 
-	uring_task_init(cfg, &server->idle_task, "idle", &server->task, server_idle_free);
+	uring_task_init(&server->idle_task, "idle", &server->task, server_idle_free);
 	uring_task_set_buf(&server->idle_task, &server->idle_buf);
 
 	list_init(&server->remotes);