Run clang-format on source tree (excl igmp.c)

1 files changed, 109 insertions, 122 deletions

diff --git a/minecproxy/server.c b/minecproxy/server.c
index 39b4024..8c521cf 100644
--- a/minecproxy/server.c
+++ b/minecproxy/server.c
@@ -20,8 +20,8 @@
 #include "idle.h"
 #include "systemd.h"
 
-static bool
-set_property(struct server *server, char **property, const char *value)
+static bool set_property(struct server *server, char **property,
+			 const char *value)
 {
 	assert_return(server && !*property && !empty_str(value), false);
 
@@ -34,8 +34,7 @@ set_property(struct server *server, char **property, const char *value)
 	return true;
 }
 
-void
-server_refdump(struct server *server)
+void server_refdump(struct server *server)
 {
 	struct server_local *local;
 	struct server_proxy *proxy;
@@ -53,8 +52,7 @@ server_refdump(struct server *server)
 	rcon_refdump(server);
 }
 
-static void
-server_free(struct uring_task *task)
+static void server_free(struct uring_task *task)
 {
 	struct server *server = container_of(task, struct server, task);
 
@@ -72,8 +70,7 @@ server_free(struct uring_task *task)
 	xfree(server);
 }
 
-void
-server_delete(struct server *server)
+void server_delete(struct server *server)
 {
 	struct server_local *local, *ltmp;
 	struct server_proxy *proxy, *ptmp;
@@ -107,7 +104,7 @@ server_delete(struct server *server)
 
 	list_for_each_entry_safe(dns, dtmp, &server->dnslookups, list)
 		gai_cancel(&dns->gcb);
-		
+
 	uring_task_destroy(&server->idle_task);
 	uring_poll_cancel(&server->exec_task);
 	uring_task_put(&server->exec_task);
@@ -115,8 +112,7 @@ server_delete(struct server *server)
 	uring_task_put(&server->ann_task);
 }
 
-void
-server_delete_by_name(const char *name)
+void server_delete_by_name(const char *name)
 {
 	struct server *server;
 
@@ -130,8 +126,7 @@ server_delete_by_name(const char *name)
 	}
 }
 
-static void
-server_dump(struct server *server)
+static void server_dump(struct server *server)
 {
 	struct server_local *local;
 	struct saddr *remote;
@@ -151,8 +146,9 @@ server_dump(struct server *server)
 		verbose("  * Type: unknown");
 		break;
 	}
-	verbose("  * Name: %s", server->pretty_name ? server->pretty_name : "<undefined>");
-	verbose("  * Announce port: %" PRIu16, server->announce_port); 
+	verbose("  * Name: %s",
+		server->pretty_name ? server->pretty_name : "<undefined>");
+	verbose("  * Announce port: %" PRIu16, server->announce_port);
 
 	if (!list_empty(&server->locals)) {
 		verbose("  * Local:");
@@ -175,8 +171,7 @@ server_dump(struct server *server)
 	verbose("");
 }
 
-static void
-server_exec_free(struct uring_task *task)
+static void server_exec_free(struct uring_task *task)
 {
 	assert_return(task);
 
@@ -188,8 +183,7 @@ server_exec_free(struct uring_task *task)
 #endif
 
 /* FIXME: update states */
-static void
-server_exec_done(struct uring_task *task, int res)
+static void server_exec_done(struct uring_task *task, int res)
 {
 	struct server *server = container_of(task, struct server, exec_task);
 	int r;
@@ -205,10 +199,10 @@ server_exec_done(struct uring_task *task, int res)
 	}
 
 	r = waitid(P_PIDFD, server->exec_task.fd, &info, WEXITED);
-        if (r < 0) {
-                error("waitid: %m");
+	if (r < 0) {
+		error("waitid: %m");
 		goto out;
-        }
+	}
 
 	if (info.si_status == 0)
 		debug(DBG_SRV, "command successfully executed");
@@ -219,8 +213,7 @@ out:
 	uring_task_close_fd(&server->exec_task);
 }
 
-static int
-server_exec_child(void *ptr)
+static int server_exec_child(void *ptr)
 {
 	const char *cmd = ptr;
 
@@ -234,8 +227,7 @@ server_exec_child(void *ptr)
 #define CLONE_PIDFD 0x00001000
 #endif
 
-static bool
-server_exec(struct server *server, const char *cmd)
+static bool server_exec(struct server *server, const char *cmd)
 {
 	char stack[4096]; /* Beautiful/horrible hack :) */
 	int pidfd;
@@ -243,9 +235,9 @@ server_exec(struct server *server, const char *cmd)
 
 	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,
-                  (void *)cmd, &pidfd);
+	r = clone(server_exec_child, stack + sizeof(stack),
+		  CLONE_VM | CLONE_VFORK | CLONE_PIDFD | SIGCHLD, (void *)cmd,
+		  &pidfd);
 	if (r < 0) {
 		error("clone: %m: %i", r);
 		return false;
@@ -256,14 +248,14 @@ server_exec(struct server *server, const char *cmd)
 	return true;
 }
 
-static bool
-server_check_running(struct server *server)
+static bool server_check_running(struct server *server)
 {
 	assert_return(server, false);
 
 	/* FIXME: other methods, rcon? */
 	if (server->systemd_service) {
-		verbose("%s: checking if systemd service is running", server->name);
+		verbose("%s: checking if systemd service is running",
+			server->name);
 		if (systemd_service_running(server)) {
 			server->state = SERVER_STATE_RUNNING;
 			return true;
@@ -276,21 +268,19 @@ server_check_running(struct server *server)
 	return false;
 }
 
-bool
-server_start(struct server *server)
+bool server_start(struct server *server)
 {
 	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(server, server->start_exec);
 
 	case SERVER_START_METHOD_SYSTEMD:
-		verbose("Starting server %s via systemd (%s)",
-			server->name, server->systemd_service);
+		verbose("Starting server %s via systemd (%s)", server->name,
+			server->systemd_service);
 
 		if (systemd_service_start(server)) {
 			server->state = SERVER_STATE_RUNNING;
@@ -306,21 +296,19 @@ server_start(struct server *server)
 	return false;
 }
 
-bool
-server_stop(struct server *server)
+bool server_stop(struct server *server)
 {
 	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(server, server->stop_exec);
 
 	case SERVER_STOP_METHOD_SYSTEMD:
-		verbose("Stopping server %s via systemd (%s)",
-			server->name, server->systemd_service);
+		verbose("Stopping server %s via systemd (%s)", server->name,
+			server->systemd_service);
 		if (systemd_service_stop(server)) {
 			server->state = SERVER_STATE_STOPPED;
 			return true;
@@ -340,22 +328,19 @@ server_stop(struct server *server)
 	return false;
 }
 
-static void
-server_idle_free(struct uring_task *task)
+static void server_idle_free(struct uring_task *task)
 {
 	assert_return(task);
 
 	debug(DBG_ANN, "called");
 }
 
-void
-server_set_active_players(struct server *server, int count)
+void server_set_active_players(struct server *server, int count)
 {
 	assert_return(server);
 	assert_task_alive(DBG_IDLE, &server->idle_task);
 
-	debug(DBG_IDLE, "%s: currently %i active players",
-	      server->name, count);
+	debug(DBG_IDLE, "%s: currently %i active players", server->name, count);
 
 	if (count < 0)
 		return;
@@ -368,12 +353,11 @@ server_set_active_players(struct server *server, int count)
 
 	if (server->idle_count > server->idle_timeout) {
 		verbose("stopping idle server %s", server->name);
-		server_stop(server); 
+		server_stop(server);
 	}
 }
 
-static void
-server_idle_connected_cb(struct connection *conn, bool connected)
+static void server_idle_connected_cb(struct connection *conn, bool connected)
 {
 	struct server *server = container_of(conn, struct server, idle_conn);
 
@@ -393,8 +377,7 @@ server_idle_connected_cb(struct connection *conn, bool connected)
 	idle_check_get_player_count(server, conn);
 }
 
-bool
-server_idle_check(struct server *server)
+bool server_idle_check(struct server *server)
 {
 	assert_return(server, false);
 
@@ -413,21 +396,19 @@ server_idle_check(struct server *server)
 		return true;
 	}
 
-	connect_any(&server->idle_task, &server->remotes,
-		    &server->idle_conn, server_idle_connected_cb);
+	connect_any(&server->idle_task, &server->remotes, &server->idle_conn,
+		    server_idle_connected_cb);
 	return true;
 }
 
-static void
-server_announce_free(struct uring_task *task)
+static void server_announce_free(struct uring_task *task)
 {
 	assert_return(task);
 
 	debug(DBG_ANN, "called");
 }
 
-static void
-server_announce_cb(struct uring_task *task, int res)
+static void server_announce_cb(struct uring_task *task, int res)
 {
 	struct server *server = container_of(task, struct server, ann_task);
 
@@ -443,8 +424,7 @@ server_announce_cb(struct uring_task *task, int res)
 	uring_task_set_fd(&server->ann_task, -1);
 }
 
-bool
-server_announce(struct server *server, int fd)
+bool server_announce(struct server *server, int fd)
 {
 	assert_return(server && fd >= 0, false);
 
@@ -458,8 +438,7 @@ server_announce(struct server *server, int fd)
 	return true;
 }
 
-bool
-server_commit(struct server *server)
+bool server_commit(struct server *server)
 {
 	struct server_local *local;
 	uint16_t port;
@@ -486,14 +465,14 @@ server_commit(struct server *server)
 	if (server->stop_method == SERVER_STOP_METHOD_RCON &&
 	    list_empty(&server->rcons)) {
 		error("%s: rcon stop method missing rcon address",
-		      server->name); 
+		      server->name);
 		return false;
 	}
 
 	if (server->stop_method == SERVER_STOP_METHOD_RCON &&
 	    !server->rcon_password) {
 		error("%s: rcon stop method missing rcon password",
-		      server->name); 
+		      server->name);
 		return false;
 	}
 
@@ -501,12 +480,13 @@ server_commit(struct server *server)
 	     server->stop_method == SERVER_STOP_METHOD_SYSTEMD) &&
 	    !server->systemd_service) {
 		error("%s: systemd start/stop method missing systemd service",
-		      server->name); 
+		      server->name);
 		return false;
 	}
 
 	if (server->systemd_service && !server->systemd_obj) {
-		server->systemd_obj = systemd_object_path(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);
@@ -516,29 +496,33 @@ server_commit(struct server *server)
 
 	if (server->idle_timeout > 0 &&
 	    server->stop_method == SERVER_STOP_METHOD_UNDEFINED) {
-		error("%s: idle_timeout set but missing stop method", server->name); 
+		error("%s: idle_timeout set but missing stop method",
+		      server->name);
 		return false;
 	}
 
 	switch (server->type) {
 	case SERVER_TYPE_ANNOUNCE:
 		if (server->announce_port < 1) {
-			error("%s: missing announce port", server->name); 
+			error("%s: missing announce port", server->name);
 			return false;
 		}
 
 		if (server->start_method != SERVER_START_METHOD_UNDEFINED) {
-			error("%s: can't set start_method for announce server", server->name);
+			error("%s: can't set start_method for announce server",
+			      server->name);
 			return false;
 		}
 
 		if (!list_empty(&server->locals)) {
-			error("%s: can't set local addresses for announce server", server->name);
+			error("%s: can't set local addresses for announce server",
+			      server->name);
 			return false;
 		}
 
 		if (!list_empty(&server->remotes)) {
-			error("%s: can't set remote addresses for announce server", server->name);
+			error("%s: can't set remote addresses for announce server",
+			      server->name);
 			return false;
 		}
 
@@ -546,17 +530,20 @@ server_commit(struct server *server)
 
 	case SERVER_TYPE_PROXY:
 		if (server->announce_port >= 1) {
-			error("%s: can't set announce port for proxy server", server->name); 
+			error("%s: can't set announce port for proxy server",
+			      server->name);
 			return false;
 		}
 
 		if (list_empty(&server->locals)) {
-			error("%s: missing local addresses for proxy server", server->name);
+			error("%s: missing local addresses for proxy server",
+			      server->name);
 			return false;
 		}
 
 		if (list_empty(&server->remotes)) {
-			error("%s: missing remote addresses for proxy server", server->name);
+			error("%s: missing remote addresses for proxy server",
+			      server->name);
 			return false;
 		}
 
@@ -578,7 +565,8 @@ server_commit(struct server *server)
 		}
 
 		if (server->announce_port < 1) {
-			error("%s: can't determine which port to announce", server->name);
+			error("%s: can't determine which port to announce",
+			      server->name);
 			return false;
 		}
 
@@ -591,30 +579,34 @@ server_commit(struct server *server)
 
 	if (!server->pretty_name) {
 		char *suffix;
-		
+
 		suffix = strrchr(server->name, '.');
 		if (!suffix || suffix == server->name) {
 			error("invalid server name: %s", server->name);
 			return false;
 		}
 
-		server->pretty_name = xstrndup(server->name, suffix - server->name);
+		server->pretty_name =
+			xstrndup(server->name, suffix - server->name);
 		if (!server->pretty_name) {
-			error("failed to create display name: %s", server->name);
+			error("failed to create display name: %s",
+			      server->name);
 			return false;
 		}
 	}
 
 	r = snprintf(server->ann_buf.buf, sizeof(server->ann_buf.buf),
-		     "[MOTD]%s[/MOTD][AD]%" PRIu16 "[/AD]",
-		     server->pretty_name, server->announce_port);
+		     "[MOTD]%s[/MOTD][AD]%" PRIu16 "[/AD]", server->pretty_name,
+		     server->announce_port);
 	if (r < 1 || r >= sizeof(server->ann_buf.buf)) {
-		error("%s: unable to create announce msg: %i\n", server->name, r);
+		error("%s: unable to create announce msg: %i\n", server->name,
+		      r);
 		return false;
 	}
 	server->ann_buf.len = r;
 
-	/* FIXME: config, dont reread config if server running, make sure fd is available before this is called */
+	/* FIXME: config, dont reread config if server running, make sure fd is
+	 * available before this is called */
 	server_dump(server);
 
 	list_for_each_entry(local, &server->locals, list)
@@ -628,8 +620,7 @@ server_commit(struct server *server)
 	return true;
 }
 
-bool
-server_add_remote(struct server *server, struct saddr *remote)
+bool server_add_remote(struct server *server, struct saddr *remote)
 {
 	assert_return(server && remote, false);
 	assert_task_alive_or(DBG_SRV, &server->task, return false);
@@ -639,8 +630,7 @@ server_add_remote(struct server *server, struct saddr *remote)
 	return true;
 }
 
-bool
-server_add_local(struct server *server, struct saddr *saddr)
+bool server_add_local(struct server *server, struct saddr *saddr)
 {
 	struct server_local *local;
 
@@ -655,8 +645,7 @@ server_add_local(struct server *server, struct saddr *saddr)
 	return true;
 }
 
-bool
-server_add_rcon(struct server *server, struct saddr *rcon)
+bool server_add_rcon(struct server *server, struct saddr *rcon)
 {
 	assert_return(server && rcon, false);
 	assert_task_alive_or(DBG_SRV, &server->task, return false);
@@ -666,21 +655,20 @@ server_add_rcon(struct server *server, struct saddr *rcon)
 	return true;
 }
 
-bool
-server_set_rcon_password(struct server *server, const char *password)
+bool server_set_rcon_password(struct server *server, const char *password)
 {
 	assert_return(server && !empty_str(password), false);
 
 	return set_property(server, &server->rcon_password, password);
 }
 
-bool
-server_set_systemd_service(struct server *server, const char *service)
+bool server_set_systemd_service(struct server *server, const char *service)
 {
 	const char *suffix;
 	char *tmp;
 
-	assert_return(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")) {
@@ -699,55 +687,52 @@ server_set_systemd_service(struct server *server, const char *service)
 	return true;
 }
 
-bool
-server_set_stop_method(struct server *server,
-		       enum server_stop_method stop_method)
+bool server_set_stop_method(struct server *server,
+			    enum server_stop_method stop_method)
 {
 	assert_return(server->stop_method == SERVER_STOP_METHOD_UNDEFINED &&
-		      stop_method != SERVER_STOP_METHOD_UNDEFINED, false);
+			      stop_method != SERVER_STOP_METHOD_UNDEFINED,
+		      false);
 
 	server->stop_method = stop_method;
 	return true;
 }
 
-bool
-server_set_start_method(struct server *server,
-			enum server_start_method start_method)
+bool server_set_start_method(struct server *server,
+			     enum server_start_method start_method)
 {
 	assert_return(server->start_method == SERVER_START_METHOD_UNDEFINED &&
-		      start_method != SERVER_START_METHOD_UNDEFINED, false);
+			      start_method != SERVER_START_METHOD_UNDEFINED,
+		      false);
 
 	server->start_method = start_method;
 	return true;
 }
 
-bool
-server_set_stop_exec(struct server *server, const char *cmd)
+bool server_set_stop_exec(struct server *server, const char *cmd)
 {
 	assert_return(server && !empty_str(cmd), false);
 
 	return set_property(server, &server->stop_exec, cmd);
 }
 
-bool
-server_set_start_exec(struct server *server, const char *cmd)
+bool server_set_start_exec(struct server *server, const char *cmd)
 {
 	assert_return(server && !empty_str(cmd), false);
 
 	return set_property(server, &server->start_exec, cmd);
 }
 
-bool
-server_set_idle_timeout(struct server *server, uint16_t timeout)
+bool server_set_idle_timeout(struct server *server, uint16_t timeout)
 {
-	assert_return(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 server *server, uint16_t port)
+bool server_set_port(struct server *server, uint16_t port)
 {
 	assert_return(server && port > 0 && server->announce_port == 0, false);
 
@@ -755,8 +740,7 @@ server_set_port(struct server *server, uint16_t port)
 	return true;
 }
 
-bool
-server_set_type(struct server *server, enum server_type type)
+bool server_set_type(struct server *server, enum server_type type)
 {
 	assert_return(server && type != SERVER_TYPE_UNDEFINED, false);
 
@@ -774,16 +758,14 @@ server_set_type(struct server *server, enum server_type type)
 	return true;
 }
 
-bool
-server_set_pretty_name(struct server *server, const char *pretty_name)
+bool server_set_pretty_name(struct server *server, const char *pretty_name)
 {
 	assert_return(server && !empty_str(pretty_name), false);
 
 	return set_property(server, &server->pretty_name, pretty_name);
 }
 
-struct server *
-server_new(const char *name)
+struct server *server_new(const char *name)
 {
 	struct server *server;
 
@@ -810,16 +792,21 @@ server_new(const char *name)
 	server->start_method = SERVER_START_METHOD_UNDEFINED;
 	server->idle_timeout = 0;
 
-	uring_task_init(&server->task, server->name, uring_parent(), server_free);
+	uring_task_init(&server->task, server->name, uring_parent(),
+			server_free);
 	uring_task_set_buf(&server->task, &server->tbuf);
 
-	uring_task_init(&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));
+	saddr_set_ipv4(&server->ann_task.saddr, cinet_addr(224,0,2,60),
+		       htons(4445));
 
-	uring_task_init(&server->exec_task, "exec", &server->task, server_exec_free);
+	uring_task_init(&server->exec_task, "exec", &server->task,
+			server_exec_free);
 
-	uring_task_init(&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);
 
 	rcon_init(server);