From 31afd2aaaeb76a12e232eab0fb6a550b73948737 Mon Sep 17 00:00:00 2001 From: David Härdeman Date: Mon, 22 Jun 2020 10:50:15 +0200 Subject: Make struct cfg global and make the corresponding changes throughout --- server.c | 202 +++++++++++++++++++++++++++++++-------------------------------- 1 file changed, 99 insertions(+), 103 deletions(-) (limited to 'server.c') 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); -- cgit v1.2.3