summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--announce.c40
-rw-r--r--announce.h10
-rw-r--r--cfgdir.c124
-rw-r--r--cfgdir.h6
-rw-r--r--config.c9
-rw-r--r--config.h4
-rw-r--r--idle.c62
-rw-r--r--idle.h8
-rw-r--r--igmp.c45
-rw-r--r--igmp.h6
-rw-r--r--main.c95
-rw-r--r--main.h6
-rw-r--r--proxy.c80
-rw-r--r--proxy.h5
-rw-r--r--rcon.c125
-rw-r--r--rcon.h4
-rw-r--r--server.c202
-rw-r--r--server.h53
-rw-r--r--systemd.c35
-rw-r--r--systemd.h18
-rw-r--r--uring.c188
-rw-r--r--uring.h59
-rw-r--r--utils.c48
-rw-r--r--utils.h17
24 files changed, 594 insertions, 655 deletions
diff --git a/announce.c b/announce.c
index 9944851..1225868 100644
--- a/announce.c
+++ b/announce.c
@@ -18,12 +18,12 @@ struct announce {
};
static void
-announce_cb(struct cfg *cfg, struct uring_task *task, int res)
+announce_cb(struct uring_task *task, int res)
{
struct announce *aev = container_of(task, struct announce, task);
struct server *server;
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_ANN, task);
if (res != sizeof(aev->value)) {
@@ -33,8 +33,8 @@ announce_cb(struct cfg *cfg, struct uring_task *task, int res)
debug(DBG_ANN, "timerfd value %" PRIu64, aev->value);
list_for_each_entry(server, &cfg->servers, list)
- server_announce(cfg, server, aev->mcast_fd);
- uring_read(cfg, &aev->task, &aev->value, sizeof(aev->value), announce_cb);
+ server_announce(server, aev->mcast_fd);
+ uring_read(&aev->task, &aev->value, sizeof(aev->value), announce_cb);
}
static void
@@ -50,25 +50,25 @@ announce_free(struct uring_task *task)
}
void
-announce_refdump(struct announce *aev)
+announce_refdump()
{
- assert_return_silent(aev);
+ assert_return_silent(cfg->aev);
- uring_task_refdump(&aev->task);
+ uring_task_refdump(&cfg->aev->task);
}
void
-announce_delete(struct cfg *cfg)
+announce_delete()
{
- assert_return(cfg && cfg->aev);
+ assert_return(cfg->aev);
debug(DBG_ANN, "closing fd %i", cfg->aev->task.fd);
- uring_task_destroy(cfg, &cfg->aev->task);
+ uring_task_destroy(&cfg->aev->task);
cfg->aev = NULL;
}
void
-announce_stop(struct announce *aev)
+announce_stop()
{
struct itimerspec tspec = {
.it_interval = {
@@ -81,14 +81,14 @@ announce_stop(struct announce *aev)
}
};
- assert_return(aev);
+ assert_return(cfg->aev);
- if (timerfd_settime(aev->task.fd, 0, &tspec, NULL) != 0)
+ if (timerfd_settime(cfg->aev->task.fd, 0, &tspec, NULL) != 0)
error("timerfd_settime: %m");
}
void
-announce_start(struct announce *aev)
+announce_start()
{
struct itimerspec tspec = {
.it_interval = {
@@ -101,20 +101,20 @@ announce_start(struct announce *aev)
}
};
- assert_return(aev);
+ assert_return(cfg->aev);
- if (timerfd_settime(aev->task.fd, 0, &tspec, NULL) != 0)
+ if (timerfd_settime(cfg->aev->task.fd, 0, &tspec, NULL) != 0)
error("timerfd_settime: %m");
}
void
-announce_init(struct cfg *cfg)
+announce_init()
{
struct announce *aev;
int afd;
int sfd;
- assert_return(cfg);
+ assert_return(!cfg->aev);
aev = zmalloc(sizeof(*aev));
if (!aev)
@@ -128,10 +128,10 @@ announce_init(struct cfg *cfg)
if (sfd < 0)
die("socket: %m");
- uring_task_init(cfg, &aev->task, "announce", uring_parent(cfg), announce_free);
+ uring_task_init(&aev->task, "announce", uring_parent(), announce_free);
uring_task_set_fd(&aev->task, afd);
aev->mcast_fd = sfd;
cfg->aev = aev;
- uring_read(cfg, &aev->task, &aev->value, sizeof(aev->value), announce_cb);
+ uring_read(&aev->task, &aev->value, sizeof(aev->value), announce_cb);
}
diff --git a/announce.h b/announce.h
index 6f805f1..c4bd8e3 100644
--- a/announce.h
+++ b/announce.h
@@ -1,14 +1,14 @@
#ifndef fooannouncehfoo
#define fooannouncehfoo
-void announce_refdump(struct announce *aev);
+void announce_refdump();
-void announce_delete(struct cfg *cfg);
+void announce_delete();
-void announce_stop(struct announce *aev);
+void announce_stop();
-void announce_start(struct announce *aev);
+void announce_start();
-void announce_init(struct cfg *cfg);
+void announce_init();
#endif
diff --git a/cfgdir.c b/cfgdir.c
index 3e8cef3..ec8a0bf 100644
--- a/cfgdir.c
+++ b/cfgdir.c
@@ -17,10 +17,9 @@
#include "server.h"
static void
-scfg_dns_cb(struct dns_async *dns, bool (*server_cb)(struct cfg *, struct server *, struct saddr *))
+scfg_dns_cb(struct dns_async *dns, bool (*server_cb)(struct server *, struct saddr *))
{
struct server *server;
- struct cfg *cfg;
struct sockaddr_in *in4;
struct sockaddr_in6 *in6;
struct saddr *saddr;
@@ -30,8 +29,6 @@ scfg_dns_cb(struct dns_async *dns, bool (*server_cb)(struct cfg *, struct server
assert_return(dns && dns->priv && server_cb);
server = dns->priv;
- cfg = server->cfg;
-
debug(DBG_DNS, "called, dns: %p, name: %s, server: %p, server->name: %s",
dns, dns->name, server, server->name);
@@ -62,13 +59,13 @@ scfg_dns_cb(struct dns_async *dns, bool (*server_cb)(struct cfg *, struct server
case AF_INET:
in4 = (struct sockaddr_in *)ai->ai_addr;
saddr_set_ipv4(saddr, in4->sin_addr.s_addr, in4->sin_port);
- server_cb(cfg, server, saddr);
+ server_cb(server, saddr);
break;
case AF_INET6:
in6 = (struct sockaddr_in6 *)ai->ai_addr;
saddr_set_ipv6(saddr, &in6->sin6_addr, in6->sin6_port);
- server_cb(cfg, server, saddr);
+ server_cb(server, saddr);
break;
default:
@@ -83,8 +80,8 @@ out:
freeaddrinfo(results);
list_del(&dns->list);
xfree(dns);
- uring_task_put(cfg, &server->task);
- server_commit(cfg, server);
+ uring_task_put(&server->task);
+ server_commit(server);
}
static void
@@ -189,14 +186,14 @@ struct cfg_key_value_map scfg_key_map[] = {
};
static bool
-handle_dns(struct cfg *cfg, struct server *server, const char *type,
+handle_dns(struct server *server, const char *type,
struct cfg_value *value, dns_cb_t *async_cb,
- bool (*sync_cb)(struct cfg *, struct server *, struct saddr *))
+ bool (*sync_cb)(struct server *, struct saddr *))
{
struct saddr *saddr, *tmp;
struct dns_async *dns;
- assert_return(cfg && server && type && value && async_cb && sync_cb, false);
+ assert_return(server && type && value && async_cb && sync_cb, false);
switch (value->type) {
case CFG_VAL_TYPE_ADDRS:
@@ -204,7 +201,7 @@ handle_dns(struct cfg *cfg, struct server *server, const char *type,
list_for_each_entry_safe(saddr, tmp, &value->saddrs, list) {
list_del(&saddr->list);
- sync_cb(cfg, server, saddr);
+ sync_cb(server, saddr);
}
return true;
@@ -216,7 +213,7 @@ handle_dns(struct cfg *cfg, struct server *server, const char *type,
dns->cb = async_cb;
dns->priv = server;
list_add(&dns->list, &server->dnslookups);
- uring_task_get(cfg, &server->task);
+ uring_task_get(&server->task);
return true;
default:
@@ -225,15 +222,15 @@ handle_dns(struct cfg *cfg, struct server *server, const char *type,
}
static void
-scfg_parse(struct cfg *cfg, struct server *server)
+scfg_parse(struct server *server)
{
char *pos;
- assert_return(cfg && server);
+ assert_return(server);
pos = server->tbuf.buf;
- if (!config_parse_header(cfg, server->name, "server", &pos))
+ if (!config_parse_header(server->name, "server", &pos))
return;
while (true) {
@@ -241,7 +238,7 @@ scfg_parse(struct cfg *cfg, struct server *server)
const char *keyname;
struct cfg_value value;
- if (!config_parse_line(cfg, server->name, &pos, scfg_key_map,
+ if (!config_parse_line(server->name, &pos, scfg_key_map,
&key, &keyname, &value))
break;
@@ -254,87 +251,87 @@ scfg_parse(struct cfg *cfg, struct server *server)
case SCFG_KEY_TYPE:
if (streq(value.str, "proxy")) {
- if (!server_set_type(cfg, server, SERVER_TYPE_PROXY))
+ if (!server_set_type(server, SERVER_TYPE_PROXY))
return;
} else if (streq(value.str, "announce")) {
- if (!server_set_type(cfg, server, SERVER_TYPE_ANNOUNCE))
+ if (!server_set_type(server, SERVER_TYPE_ANNOUNCE))
return;
}
break;
case SCFG_KEY_NAME:
- if (!server_set_pretty_name(cfg, server, value.str))
+ if (!server_set_pretty_name(server, value.str))
return;
break;
case SCFG_KEY_PORT:
- if (!server_set_port(cfg, server, value.uint16))
+ if (!server_set_port(server, value.uint16))
return;
break;
case SCFG_KEY_LOCAL:
- if (!handle_dns(cfg, server, "local", &value,
+ if (!handle_dns(server, "local", &value,
scfg_local_dns_cb, server_add_local))
return;
break;
case SCFG_KEY_REMOTE:
- if (!handle_dns(cfg, server, "remote", &value,
+ if (!handle_dns(server, "remote", &value,
scfg_remote_dns_cb, server_add_remote))
return;
break;
case SCFG_KEY_IDLE_TIMEOUT:
- if (!server_set_idle_timeout(cfg, server, value.uint16))
+ if (!server_set_idle_timeout(server, value.uint16))
return;
break;
case SCFG_KEY_STOP_METHOD:
if (streq(value.str, "exec")) {
- if (server_set_stop_method(cfg, server, SERVER_STOP_METHOD_EXEC))
+ if (server_set_stop_method(server, SERVER_STOP_METHOD_EXEC))
break;
} else if (streq(value.str, "rcon")) {
- if (server_set_stop_method(cfg, server, SERVER_STOP_METHOD_RCON))
+ if (server_set_stop_method(server, SERVER_STOP_METHOD_RCON))
break;
} else if (streq(value.str, "systemd")) {
- if (server_set_stop_method(cfg, server, SERVER_STOP_METHOD_SYSTEMD))
+ if (server_set_stop_method(server, SERVER_STOP_METHOD_SYSTEMD))
break;
}
return;
case SCFG_KEY_START_METHOD:
if (streq(value.str, "exec")) {
- if (server_set_start_method(cfg, server, SERVER_START_METHOD_EXEC))
+ if (server_set_start_method(server, SERVER_START_METHOD_EXEC))
break;
} else if (streq(value.str, "systemd")) {
- if (server_set_start_method(cfg, server, SERVER_START_METHOD_SYSTEMD))
+ if (server_set_start_method(server, SERVER_START_METHOD_SYSTEMD))
break;
}
return;
case SCFG_KEY_STOP_EXEC:
- if (!server_set_stop_exec(cfg, server, value.str))
+ if (!server_set_stop_exec(server, value.str))
return;
break;
case SCFG_KEY_START_EXEC:
- if (!server_set_start_exec(cfg, server, value.str))
+ if (!server_set_start_exec(server, value.str))
return;
break;
case SCFG_KEY_RCON:
- if (!handle_dns(cfg, server, "rcon", &value,
+ if (!handle_dns(server, "rcon", &value,
scfg_rcon_dns_cb, server_add_rcon))
return;
break;
case SCFG_KEY_RCON_PASSWORD:
- if (!server_set_rcon_password(cfg, server, value.str))
+ if (!server_set_rcon_password(server, value.str))
return;
break;
case SCFG_KEY_SYSTEMD_SERVICE:
- if (!server_set_systemd_service(cfg, server, value.str))
+ if (!server_set_systemd_service(server, value.str))
return;
break;
@@ -346,42 +343,42 @@ scfg_parse(struct cfg *cfg, struct server *server)
}
static void
-scfg_read_cb(struct cfg *cfg, struct uring_task *task, int res)
+scfg_read_cb(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, task);
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_CFG, task);
if (res <= 0) {
error("error reading config file for %s: %s",
server->name, strerror(-res));
- server_delete(cfg, server);
+ server_delete(server);
}
debug(DBG_CFG, "%s: parsing cfg (%i bytes)", server->name, res);
- uring_task_close_fd(cfg, &server->task);
- scfg_parse(cfg, server);
- server_commit(cfg, server);
+ uring_task_close_fd(&server->task);
+ scfg_parse(server);
+ server_commit(server);
}
static void
-scfg_open_cb(struct cfg *cfg, struct uring_task *task, int res)
+scfg_open_cb(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, task);
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_CFG, task);
if (res < 0) {
error("open(%s) failed: %s", server->name, strerror(-res));
- server_delete(cfg, server);
+ server_delete(server);
return;
}
debug(DBG_CFG, "reading server cfg %s (fd %i)", server->name, res);
uring_task_set_fd(&server->task, res);
- uring_tbuf_read_until_eof(cfg, &server->task, scfg_read_cb);
+ uring_tbuf_read_until_eof(&server->task, scfg_read_cb);
}
static bool
@@ -410,9 +407,8 @@ static void
inotify_free(struct uring_task *task)
{
struct inotify_ev *iev = container_of(task, struct inotify_ev, task);
- struct cfg *cfg = container_of(task->parent, struct cfg, task);
- assert_return(task && iev && cfg);
+ assert_return(task);
debug(DBG_CFG, "called");
xfree(iev);
@@ -463,14 +459,14 @@ inotify_event_dump(const struct inotify_event *event)
}
static void
-inotify_cb(struct cfg *cfg, struct uring_task *task, int res)
+inotify_cb(struct uring_task *task, int res)
{
struct inotify_ev *iev = container_of(task, struct inotify_ev, task);
const struct inotify_event *event;
char *ptr;
struct server *server;
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_CFG, task);
if (res <= 0) {
@@ -496,38 +492,38 @@ inotify_cb(struct cfg *cfg, struct uring_task *task, int res)
continue;
if (event->mask & (IN_MOVED_FROM | IN_DELETE))
- server_delete_by_name(cfg, event->name);
+ server_delete_by_name(event->name);
else if (event->mask & (IN_MOVED_TO | IN_CREATE | IN_CLOSE_WRITE)) {
- server = server_new(cfg, event->name);
+ server = server_new(event->name);
verbose("New server config file detected: %s", server->name);
- uring_openat(cfg, &server->task, server->name, scfg_open_cb);
+ uring_openat(&server->task, server->name, scfg_open_cb);
} else
error("inotify: unknown event: 0x%08x", event->mask);
}
- uring_read(cfg, &iev->task, iev->buf, sizeof(iev->buf), inotify_cb);
+ uring_read(&iev->task, iev->buf, sizeof(iev->buf), inotify_cb);
}
void
-cfgdir_refdump(struct inotify_ev *iev)
+cfgdir_refdump()
{
- assert_return(iev);
+ assert_return_silent(cfg->iev);
- uring_task_refdump(&iev->task);
+ uring_task_refdump(&cfg->iev->task);
}
void
-cfgdir_delete(struct cfg *cfg)
+cfgdir_delete()
{
- assert_return(cfg && cfg->iev);
+ assert_return(cfg->iev);
debug(DBG_CFG, "closing fd %i", cfg->iev->task.fd);
- uring_task_destroy(cfg, &cfg->iev->task);
+ uring_task_destroy(&cfg->iev->task);
cfg->iev = NULL;
}
void
-cfgdir_init(struct cfg *cfg)
+cfgdir_init()
{
int ifd;
int iwd;
@@ -536,7 +532,7 @@ cfgdir_init(struct cfg *cfg)
struct dirent *dent;
struct server *server;
- assert_return(cfg);
+ assert_return(!cfg->iev);
iev = zmalloc(sizeof(*iev));
if (!iev)
@@ -555,10 +551,10 @@ cfgdir_init(struct cfg *cfg)
if (iwd < 0)
die("inotify_add_watch: %m");
- uring_task_init(cfg, &iev->task, "server_config", uring_parent(cfg), inotify_free);
+ uring_task_init(&iev->task, "server_config", uring_parent(), inotify_free);
uring_task_set_fd(&iev->task, ifd);
cfg->iev = iev;
- uring_read(cfg, &iev->task, iev->buf, sizeof(iev->buf), inotify_cb);
+ uring_read(&iev->task, iev->buf, sizeof(iev->buf), inotify_cb);
dir = opendir(".");
if (!dir)
@@ -570,9 +566,9 @@ cfgdir_init(struct cfg *cfg)
if (!scfg_valid_filename(dent->d_name))
continue;
- server = server_new(cfg, dent->d_name);
+ server = server_new(dent->d_name);
if (server)
- uring_openat(cfg, &server->task, server->name, scfg_open_cb);
+ uring_openat(&server->task, server->name, scfg_open_cb);
}
closedir(dir);
diff --git a/cfgdir.h b/cfgdir.h
index ff55fb9..2fe36eb 100644
--- a/cfgdir.h
+++ b/cfgdir.h
@@ -1,10 +1,10 @@
#ifndef foocfgdirhfoo
#define foocfgdirhfoo
-void cfgdir_delete(struct cfg *cfg);
+void cfgdir_delete();
-void cfgdir_refdump(struct inotify_ev *iev);
+void cfgdir_refdump();
-void cfgdir_init(struct cfg *cfg);
+void cfgdir_init();
#endif
diff --git a/config.c b/config.c
index f49baad..eb980f8 100644
--- a/config.c
+++ b/config.c
@@ -315,14 +315,14 @@ error:
/* Returns true if there's data left to parse in buf */
bool
-config_parse_line(struct cfg *cfg, const char *filename, char **buf,
+config_parse_line(const char *filename, char **buf,
struct cfg_key_value_map *kvmap, int *rkey,
const char **rkeyname, struct cfg_value *rvalue)
{
char *line, *tmp, *key;
int i;
- assert_return(cfg && buf && *buf && kvmap && rkey && rkeyname && rvalue, false);
+ assert_return(buf && *buf && kvmap && rkey && rkeyname && rvalue, false);
eat_whitespace_and_comments(buf);
line = get_line(buf);
@@ -466,12 +466,11 @@ error:
}
bool
-config_parse_header(struct cfg *cfg, const char *filename, const char *title,
- char **buf)
+config_parse_header(const char *filename, const char *title, char **buf)
{
char *line;
- assert_return(cfg && !empty_str(filename) && !empty_str(title) && buf && *buf, false);
+ assert_return(!empty_str(filename) && !empty_str(title) && buf && *buf, false);
eat_whitespace_and_comments(buf);
diff --git a/config.h b/config.h
index 0c28e0a..a88be90 100644
--- a/config.h
+++ b/config.h
@@ -48,12 +48,12 @@ struct cfg_value {
};
};
-bool config_parse_line(struct cfg *cfg, const char *filename, char **buf,
+bool config_parse_line(const char *filename, char **buf,
struct cfg_key_value_map *kvmap,
int *rkey, const char **rkeyname,
struct cfg_value *rvalue);
-bool config_parse_header(struct cfg *cfg, const char *filename,
+bool config_parse_header(const char *filename,
const char *title, char **buf);
#endif
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);
}
diff --git a/idle.h b/idle.h
index a0bf5c2..d7e4ab0 100644
--- a/idle.h
+++ b/idle.h
@@ -1,13 +1,13 @@
#ifndef fooidlehfoo
#define fooidlehfoo
-void idle_check_get_player_count(struct cfg *cfg, struct server *server,
+void idle_check_get_player_count(struct server *server,
struct connection *conn);
-void idle_refdump(struct idle *idle);
+void idle_refdump();
-void idle_delete(struct cfg *cfg);
+void idle_delete();
-void idle_init(struct cfg *cfg);
+void idle_init();
#endif
diff --git a/igmp.c b/igmp.c
index 01a4dc4..cebab40 100644
--- a/igmp.c
+++ b/igmp.c
@@ -183,7 +183,7 @@ igmp_match()
}
static void
-igmp_parse(struct cfg *cfg, struct igmp *igmp)
+igmp_parse(struct igmp *igmp)
{
char *buf;
size_t len;
@@ -191,7 +191,7 @@ igmp_parse(struct cfg *cfg, struct igmp *igmp)
size_t body_len;
union igmp_msg *igmp_msg;
- assert_return(cfg && igmp);
+ assert_return(igmp);
buf = igmp->task.tbuf->buf;
len = igmp->task.tbuf->len;
@@ -396,11 +396,11 @@ igmp_parse(struct cfg *cfg, struct igmp *igmp)
}
static void
-igmp_read_cb(struct cfg *cfg, struct uring_task *task, int res)
+igmp_read_cb(struct uring_task *task, int res)
{
struct igmp *igmp = container_of(task, struct igmp, task);
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_IGMP, task);
debug(DBG_IGMP, "task %p, igmp %p, res %i", task, igmp, res);
@@ -413,11 +413,11 @@ igmp_read_cb(struct cfg *cfg, struct uring_task *task, int res)
if (task->saddr.storage.ss_family == AF_PACKET ||
task->saddr.ll.sll_protocol == htons(ETH_P_IP))
- igmp_parse(cfg, igmp);
+ igmp_parse(igmp);
else
debug(DBG_IGMP, "invalid packet type received");
- uring_tbuf_read(cfg, &igmp->task, igmp_read_cb);
+ uring_tbuf_read(&igmp->task, igmp_read_cb);
}
static void
@@ -431,26 +431,25 @@ igmp_free(struct uring_task *task)
}
void
-igmp_refdump(struct igmp *igmp)
+igmp_refdump()
{
- assert_return_silent(igmp);
+ assert_return_silent(cfg->igmp);
- uring_task_refdump(&igmp->task);
+ uring_task_refdump(&cfg->igmp->task);
}
void
-igmp_delete(struct cfg *cfg)
+igmp_delete()
{
- assert_return(cfg);
assert_return_silent(cfg->igmp);
debug(DBG_IGMP, "closing fd %i", cfg->igmp->task.fd);
- uring_task_destroy(cfg, &cfg->igmp->task);
+ uring_task_destroy(&cfg->igmp->task);
cfg->igmp = NULL;
}
void
-igmp_init(struct cfg *cfg)
+igmp_init()
{
static const struct sock_filter filter[] = {
BPF_STMT(BPF_LD + BPF_W + BPF_LEN, 0), /* A <- packet length */
@@ -506,13 +505,13 @@ igmp_init(struct cfg *cfg)
int sfd;
int opt;
- assert_return(cfg);
-
if (!cfg->do_igmp) {
debug(DBG_IGMP, "igmp snooping disabled");
return;
}
+ assert_return(!cfg->igmp);
+
igmp = zmalloc(sizeof(*igmp));
if (!igmp)
return;
@@ -546,15 +545,11 @@ igmp_init(struct cfg *cfg)
r = snprintf(ifreq.ifr_name, sizeof(ifreq.ifr_name),
"%s", cfg->igmp_iface);
- if (r < 0 || r >= sizeof(ifreq.ifr_name)) {
- error("invalid interface name");
- goto error;
- }
+ if (r < 0 || r >= sizeof(ifreq.ifr_name))
+ die("invalid interface name: %s", cfg->igmp_iface);
- if (ioctl(sfd, SIOCGIFINDEX, &ifreq) < 0) {
- error("ioctl: %m");
- goto error;
- }
+ if (ioctl(sfd, SIOCGIFINDEX, &ifreq) < 0)
+ die("ioctl: %m");
debug(DBG_IGMP, "using interface %s (%i)",
cfg->igmp_iface, ifreq.ifr_ifindex);
@@ -578,11 +573,11 @@ igmp_init(struct cfg *cfg)
}
debug(DBG_IGMP, "init successful, using fd %i", sfd);
- uring_task_init(cfg, &igmp->task, "igmp", uring_parent(cfg), igmp_free);
+ uring_task_init(&igmp->task, "igmp", uring_parent(), igmp_free);
uring_task_set_fd(&igmp->task, sfd);
uring_task_set_buf(&igmp->task, &igmp->tbuf);
igmp->task.saddr.addrlen = sizeof(igmp->task.saddr.ll);
- uring_tbuf_recvmsg(cfg, &igmp->task, igmp_read_cb);
+ uring_tbuf_recvmsg(&igmp->task, igmp_read_cb);
cfg->igmp = igmp;
diff --git a/igmp.h b/igmp.h
index df370c0..80875b0 100644
--- a/igmp.h
+++ b/igmp.h
@@ -1,10 +1,10 @@
#ifndef fooigmphfoo
#define fooigmphfoo
-void igmp_refdump(struct igmp *igmp);
+void igmp_refdump();
-void igmp_delete(struct cfg *cfg);
+void igmp_delete();
-void igmp_init(struct cfg *cfg);
+void igmp_init();
#endif
diff --git a/main.c b/main.c
index d940771..b4d8449 100644
--- a/main.c
+++ b/main.c
@@ -31,6 +31,7 @@
#define DEFAULT_MAIN_CONFIG_FILE_PATH "./mcproxy.conf"
/* Global, not in struct cfg since they're too low-level */
+struct cfg *cfg = NULL;
bool exiting = false;
unsigned debug_mask = DBG_ERROR | DBG_INFO;
@@ -38,7 +39,6 @@ unsigned debug_mask = DBG_ERROR | DBG_INFO;
static bool daemonize = false;
static FILE *log_file = NULL;
static const char *log_file_path = NULL;
-static struct cfg *cfghack = NULL;
#define ANSI_RED "\x1B[0;31m"
#define ANSI_GREEN "\x1B[0;32m"
@@ -177,9 +177,9 @@ __die(const char *fmt, ...)
static void
cfg_free(struct uring_task *task)
{
- struct cfg *cfg = container_of(task, struct cfg, task);
+ struct cfg *xcfg = container_of(task, struct cfg, task);
- assert_return(task);
+ assert_return(task && xcfg == cfg);
debug(DBG_SIG, "called");
systemd_delete(cfg);
@@ -214,7 +214,7 @@ struct cfg_key_value_map mcfg_key_map[] = {
};
static void
-cfg_read(struct cfg *cfg)
+cfg_read()
{
FILE *cfgfile;
const char *path;
@@ -261,7 +261,7 @@ cfg_read(struct cfg *cfg)
*pos = '\0';
pos = buf;
- if (!config_parse_header(cfg, path, "mcproxy", &pos))
+ if (!config_parse_header(path, "mcproxy", &pos))
die("main config file (%s) invalid", path);
while (true) {
@@ -269,7 +269,7 @@ cfg_read(struct cfg *cfg)
const char *keyname;
struct cfg_value value;
- if (!config_parse_line(cfg, path, &pos, mcfg_key_map,
+ if (!config_parse_line(path, &pos, mcfg_key_map,
&key, &keyname, &value))
break;
@@ -370,10 +370,9 @@ usage(int argc, char **argv, bool invalid)
exit(invalid ? EXIT_FAILURE : EXIT_SUCCESS);
}
-static struct cfg *
+static void
cfg_init(int argc, char **argv)
{
- struct cfg *cfg;
int c;
unsigned i;
@@ -385,7 +384,7 @@ cfg_init(int argc, char **argv)
cfg->uid = geteuid();
cfg->gid = getegid();
- uring_task_init(cfg, &cfg->task, "main", NULL, cfg_free);
+ uring_task_init(&cfg->task, "main", NULL, cfg_free);
list_init(&cfg->servers);
while (true) {
@@ -482,16 +481,11 @@ cfg_init(int argc, char **argv)
if (!cfg->homedir)
cfg->homedir = DEFAULT_HOMEDIR_PATH;
-
- return cfg;
}
static void
-cfg_apply(struct cfg *cfg)
+cfg_apply()
{
- if (!cfg)
- die("invalid arguments");
-
if (cfg->uid == 0 || cfg->gid == 0)
/* This catches both -u root and running as root without -u */
die("Execution as root is not supported (use -u <someuser>)");
@@ -544,7 +538,6 @@ cfg_apply(struct cfg *cfg)
}
struct signalfd_ev {
- struct cfg *cfg;
struct uring_task task;
struct uring_task_buf tbuf;
int pipe[2];
@@ -559,17 +552,15 @@ signalfd_free(struct uring_task *task)
debug(DBG_SIG, "called");
close(sev->pipe[PIPE_WR]);
- sev->cfg->sev = NULL;
+ cfg->sev = NULL;
xfree(sev);
}
static void
-dump_tree(struct cfg *cfg)
+dump_tree()
{
struct server *server;
- assert_return(cfg);
-
if (!debug_enabled(DBG_REF))
return;
@@ -592,14 +583,14 @@ dump_tree(struct cfg *cfg)
}
static void
-signalfd_read(struct cfg *cfg, struct uring_task *task, int res)
+signalfd_read(struct uring_task *task, int res)
{
struct signalfd_ev *sev = container_of(task, struct signalfd_ev, task);
struct server *server, *stmp;
static unsigned count = 0;
siginfo_t *si;
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_SIG, task);
si = (siginfo_t *)task->tbuf->buf;
@@ -630,7 +621,7 @@ signalfd_read(struct cfg *cfg, struct uring_task *task, int res)
case SIGUSR2:
debug(DBG_SIG, "got a SIGUSR2");
- dump_tree(cfg);
+ dump_tree();
break;
case SIGTERM:
@@ -644,21 +635,21 @@ signalfd_read(struct cfg *cfg, struct uring_task *task, int res)
case SIGHUP:
count++;
if (count > 5) {
- dump_tree(cfghack);
+ dump_tree();
exit(EXIT_FAILURE);
}
verbose("got a signal to dump tree");
sd_notifyf(0, "STOPPING=1\nSTATUS=Received signal, exiting");
- dump_tree(cfg);
- uring_task_put(cfg, &sev->task);
- igmp_delete(cfg);
- announce_delete(cfg);
- idle_delete(cfg);
- cfgdir_delete(cfg);
+ dump_tree();
+ uring_task_put(&sev->task);
+ igmp_delete();
+ announce_delete();
+ idle_delete();
+ cfgdir_delete();
list_for_each_entry_safe(server, stmp, &cfg->servers, list)
- server_delete(cfg, server);
- uring_delete(cfg);
+ server_delete(server);
+ uring_delete();
return;
default:
@@ -667,7 +658,7 @@ signalfd_read(struct cfg *cfg, struct uring_task *task, int res)
}
out:
- uring_tbuf_read(cfg, &sev->task, signalfd_read);
+ uring_tbuf_read(&sev->task, signalfd_read);
}
static void
@@ -677,20 +668,18 @@ hack_signal_handler(int signum, siginfo_t *si, void *ucontext)
assert_return(signum > 0 && si);
- r = write(cfghack->sev->pipe[PIPE_WR], si, sizeof(*si));
+ r = write(cfg->sev->pipe[PIPE_WR], si, sizeof(*si));
if (r != sizeof(*si))
error("write: %zi\n", r);
}
static void
-signalfd_init(struct cfg *cfg)
+signalfd_init()
{
//sigset_t mask;
struct signalfd_ev *sev;
- assert_return(cfg);
-
sev = zmalloc(sizeof(*sev));
if (!sev)
die("malloc: %m");
@@ -725,31 +714,28 @@ signalfd_init(struct cfg *cfg)
debug(DBG_SIG, "using pipe fds %i -> %i",
sev->pipe[PIPE_WR], sev->pipe[PIPE_RD]);
- uring_task_init(cfg, &sev->task, "signal", uring_parent(cfg), signalfd_free);
+ uring_task_init(&sev->task, "signal", uring_parent(), signalfd_free);
uring_task_set_fd(&sev->task, sev->pipe[PIPE_RD]);
uring_task_set_buf(&sev->task, &sev->tbuf);
cfg->sev = sev;
- sev->cfg = cfg;
- uring_tbuf_read(cfg, &sev->task, signalfd_read);
+ uring_tbuf_read(&sev->task, signalfd_read);
}
int
main(int argc, char **argv)
{
- struct cfg *cfg;
struct server *server;
unsigned server_count;
- cfg = cfg_init(argc, argv);
- cfghack = cfg;
+ cfg_init(argc, argv);
- cfg_apply(cfg);
+ cfg_apply();
- cfg_read(cfg);
+ cfg_read();
- uring_init(cfg);
+ uring_init();
- igmp_init(cfg);
+ igmp_init();
/* Drop CAP_NET_RAW (if we have it), only used for igmp */
capng_clear(CAPNG_SELECT_BOTH);
@@ -765,17 +751,17 @@ main(int argc, char **argv)
die("capng_apply failed");
}
- signalfd_init(cfg);
+ signalfd_init();
- cfgdir_init(cfg);
+ cfgdir_init();
- announce_init(cfg);
+ announce_init();
- announce_start(cfg->aev);
+ announce_start();
- idle_init(cfg);
+ idle_init();
- uring_task_put(cfg, &cfg->task);
+ uring_task_put(&cfg->task);
server_count = 0;
list_for_each_entry(server, &cfg->servers, list)
@@ -790,11 +776,12 @@ main(int argc, char **argv)
info("mcproxy started, %u server configurations loaded",
server_count);
- uring_event_loop(cfg);
+ uring_event_loop();
verbose("Exiting");
xfree(cfg);
+ cfg = NULL;
if (debug_enabled(DBG_MALLOC))
debug_resource_usage();
diff --git a/main.h b/main.h
index e418f38..488ae8d 100644
--- a/main.h
+++ b/main.h
@@ -8,8 +8,8 @@ struct cfg;
#include "utils.h"
+extern struct cfg *cfg;
extern bool exiting;
-
extern unsigned debug_mask;
enum debug_lvl {
@@ -103,8 +103,8 @@ do { \
struct uring_task;
/* To save typing in all the function definitions below */
-typedef void (*utask_cb_t)(struct cfg *, struct uring_task *, int res);
-typedef int (*rutask_cb_t)(struct cfg *, struct uring_task *, int res);
+typedef void (*utask_cb_t)(struct uring_task *, int res);
+typedef int (*rutask_cb_t)(struct uring_task *, int res);
struct uring_task_buf {
char buf[4096];
diff --git a/proxy.c b/proxy.c
index 05117fd..28a207d 100644
--- a/proxy.c
+++ b/proxy.c
@@ -118,113 +118,113 @@ proxy_server_free(struct uring_task *task)
}
void
-proxy_delete(struct cfg *cfg, struct server_proxy *proxy)
+proxy_delete(struct server_proxy *proxy)
{
debug(DBG_PROXY, "%s: shutting down proxy %p", proxy->server->name, proxy);
- assert_return(cfg && proxy);
+ assert_return(proxy);
- uring_task_destroy(cfg, &proxy->servertask);
- uring_task_destroy(cfg, &proxy->clienttask);
- uring_task_destroy(cfg, &proxy->task);
+ uring_task_destroy(&proxy->servertask);
+ uring_task_destroy(&proxy->clienttask);
+ uring_task_destroy(&proxy->task);
}
-static void proxy_client_data_in(struct cfg *cfg, struct uring_task *task, int res);
+static void proxy_client_data_in(struct uring_task *task, int res);
static void
-proxy_client_data_out(struct cfg *cfg, struct uring_task *task, int res)
+proxy_client_data_out(struct uring_task *task, int res)
{
struct server_proxy *proxy = container_of(task, struct server_proxy, clienttask);
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_PROXY, task);
if (res <= 0) {
debug(DBG_PROXY, "%s: result was %i", proxy->server->name, res);
- uring_task_close_fd(cfg, task);
- proxy_delete(cfg, proxy);
+ uring_task_close_fd(task);
+ proxy_delete(proxy);
return;
}
proxy->client_bytes += res;
uring_task_set_fd(&proxy->clienttask, proxy->cfd);
- uring_tbuf_read(cfg, task, proxy_client_data_in);
+ uring_tbuf_read(task, proxy_client_data_in);
}
static void
-proxy_client_data_in(struct cfg *cfg, struct uring_task *task, int res)
+proxy_client_data_in(struct uring_task *task, int res)
{
struct server_proxy *proxy = container_of(task, struct server_proxy, clienttask);
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_PROXY, task);
if (res <= 0) {
debug(DBG_PROXY, "%s: result was %i", proxy->server->name, res);
- uring_task_close_fd(cfg, task);
- proxy_delete(cfg, proxy);
+ uring_task_close_fd(task);
+ proxy_delete(proxy);
return;
}
uring_task_set_fd(&proxy->clienttask, proxy->sfd);
- uring_tbuf_write(cfg, task, proxy_client_data_out);
+ uring_tbuf_write(task, proxy_client_data_out);
}
-static void proxy_server_data_in(struct cfg *cfg, struct uring_task *task,
+static void proxy_server_data_in(struct uring_task *task,
int res);
static void
-proxy_server_data_out(struct cfg *cfg, struct uring_task *task, int res)
+proxy_server_data_out(struct uring_task *task, int res)
{
struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_PROXY, task);
if (res <= 0) {
debug(DBG_PROXY, "%s: result was %i", proxy->server->name, res);
- uring_task_close_fd(cfg, task);
- proxy_delete(cfg, proxy);
+ uring_task_close_fd(task);
+ proxy_delete(proxy);
return;
}
proxy->server_bytes += res;
uring_task_set_fd(&proxy->servertask, proxy->sfd);
- uring_tbuf_read(cfg, &proxy->servertask, proxy_server_data_in);
+ uring_tbuf_read(&proxy->servertask, proxy_server_data_in);
}
static void
-proxy_server_data_in(struct cfg *cfg, struct uring_task *task, int res)
+proxy_server_data_in(struct uring_task *task, int res)
{
struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_PROXY, task);
if (res <= 0) {
debug(DBG_PROXY, "%s: result was %i", proxy->server->name, res);
- uring_task_close_fd(cfg, task);
- proxy_delete(cfg, proxy);
+ uring_task_close_fd(task);
+ proxy_delete(proxy);
return;
}
uring_task_set_fd(&proxy->servertask, proxy->cfd);
- uring_tbuf_write(cfg, task, proxy_server_data_out);
+ uring_tbuf_write(task, proxy_server_data_out);
}
static void
-proxy_connected_cb(struct cfg *cfg, struct connection *conn, bool connected)
+proxy_connected_cb(struct connection *conn, bool connected)
{
struct server_proxy *proxy = container_of(conn, struct server_proxy, server_conn);
- assert_return(cfg && conn);
+ assert_return(conn);
assert_task_alive(DBG_PROXY, &proxy->clienttask);
assert_task_alive(DBG_PROXY, &proxy->servertask);
if (!connected) {
error("%s: proxy connection to remote server failed",
proxy->server->name);
- proxy_delete(cfg, proxy);
+ proxy_delete(proxy);
return;
}
@@ -235,16 +235,16 @@ proxy_connected_cb(struct cfg *cfg, struct connection *conn, bool connected)
proxy->server_conn.remote.addrstr);
proxy->begin = time(NULL);
- uring_tbuf_read(cfg, &proxy->clienttask, proxy_client_data_in);
- uring_tbuf_read(cfg, &proxy->servertask, proxy_server_data_in);
+ uring_tbuf_read(&proxy->clienttask, proxy_client_data_in);
+ uring_tbuf_read(&proxy->servertask, proxy_server_data_in);
}
struct server_proxy *
-proxy_new(struct cfg *cfg, struct server *server, struct saddr *client, int fd)
+proxy_new(struct server *server, struct saddr *client, int fd)
{
struct server_proxy *proxy;
- assert_return(cfg && server && client && fd > 0, NULL);
+ assert_return(server && client && fd > 0, NULL);
proxy = zmalloc(sizeof(*proxy));
if (!proxy) {
@@ -255,22 +255,22 @@ proxy_new(struct cfg *cfg, struct server *server, struct saddr *client, int fd)
proxy->sfd = -1;
proxy->cfd = fd;
proxy->server = server;
- uring_task_init(cfg, &proxy->task, "proxy", &server->task, proxy_free);
+ uring_task_init(&proxy->task, "proxy", &server->task, proxy_free);
- connection_set_local(cfg, &proxy->client_conn, fd);
- connection_set_remote(cfg, &proxy->client_conn, client);
+ connection_set_local(&proxy->client_conn, fd);
+ connection_set_remote(&proxy->client_conn, client);
- uring_task_init(cfg, &proxy->clienttask, "proxy_client", &proxy->task,
+ uring_task_init(&proxy->clienttask, "proxy_client", &proxy->task,
proxy_client_free);
uring_task_set_buf(&proxy->clienttask, &proxy->clientbuf);
uring_task_set_fd(&proxy->clienttask, fd);
- uring_task_init(cfg, &proxy->servertask, "proxy_server", &proxy->task,
+ uring_task_init(&proxy->servertask, "proxy_server", &proxy->task,
proxy_server_free);
uring_task_set_buf(&proxy->servertask, &proxy->serverbuf);
list_add(&proxy->list, &server->proxys);
- connect_any(cfg, &proxy->servertask, &server->remotes,
+ connect_any(&proxy->servertask, &server->remotes,
&proxy->server_conn, proxy_connected_cb);
return proxy;
diff --git a/proxy.h b/proxy.h
index d0533e0..0726351 100644
--- a/proxy.h
+++ b/proxy.h
@@ -23,8 +23,9 @@ struct server_proxy {
void proxy_refdump(struct server_proxy *proxy);
-void proxy_delete(struct cfg *cfg, struct server_proxy *proxy);
+void proxy_delete(struct server_proxy *proxy);
-struct server_proxy *proxy_new(struct cfg *cfg, struct server *server, struct saddr *client, int fd);
+struct server_proxy *proxy_new(struct server *server, struct saddr *client,
+ int fd);
#endif
diff --git a/rcon.c b/rcon.c
index dc29364..0588da0 100644
--- a/rcon.c
+++ b/rcon.c
@@ -22,36 +22,6 @@ struct rcon {
struct uring_task_buf tbuf;
};
-static void
-rcon_free(struct uring_task *task)
-{
- struct rcon *rcon = container_of(task, struct rcon, task);
-
- assert_return(task);
-
- debug(DBG_RCON, "task %p, idle %p", task, rcon);
- rcon->server->rcon = NULL;
- xfree(rcon);
-}
-
-void
-rcon_refdump(struct rcon *rcon)
-{
- assert_return_silent(rcon);
-
- uring_task_refdump(&rcon->task);
-}
-
-void
-rcon_delete(struct cfg *cfg, struct server *server)
-{
- assert_return_silent(server->rcon);
-
- debug(DBG_RCON, "closing fd %i", server->rcon->task.fd);
- uring_task_destroy(cfg, &server->rcon->task);
- server->rcon = NULL;
-}
-
static int32_t
read_int(char **pos, size_t *len)
{
@@ -134,12 +104,12 @@ enum rcon_packet_type {
};
static void
-create_packet(struct cfg *cfg, struct rcon *rcon, int32_t reqid,
+create_packet(struct rcon *rcon, int32_t reqid,
enum rcon_packet_type type, const char *msg)
{
char *pos;
- assert_return(cfg && rcon && !empty_str(msg));
+ assert_return(rcon && !empty_str(msg));
/* Body */
pos = &rcon->tbuf.buf[4];
@@ -159,13 +129,13 @@ create_packet(struct cfg *cfg, struct rcon *rcon, int32_t reqid,
}
static int
-packet_complete(struct cfg *cfg, struct uring_task *task, int res)
+packet_complete(struct uring_task *task, int res)
{
char *pos;
size_t len;
int32_t plen;
- assert_return(cfg && task, 0);
+ assert_return(task, 0);
assert_task_alive_or(DBG_RCON, task, return -EINTR);
pos = task->tbuf->buf;
@@ -184,14 +154,14 @@ packet_complete(struct cfg *cfg, struct uring_task *task, int res)
}
static bool
-rcon_read_packet(struct cfg *cfg, struct rcon *rcon, int32_t *id,
+rcon_read_packet(struct rcon *rcon, int32_t *id,
int32_t *type, char **rmsg)
{
char *pos;
size_t len;
int32_t plen;
- assert_return(cfg && rcon && id && type && rmsg, false);
+ assert_return(rcon && id && type && rmsg, false);
pos = rcon->tbuf.buf;
len = rcon->tbuf.len;
@@ -229,14 +199,14 @@ rcon_read_packet(struct cfg *cfg, struct rcon *rcon, int32_t *id,
}
static void
-rcon_stop_reply(struct cfg *cfg, struct uring_task *task, int res)
+rcon_stop_reply(struct uring_task *task, int res)
{
struct rcon *rcon = container_of(task, struct rcon, task);
int32_t id;
int32_t type;
char *msg;
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_RCON, task);
if (res < 0) {
@@ -245,7 +215,7 @@ rcon_stop_reply(struct cfg *cfg, struct uring_task *task, int res)
}
debug(DBG_RCON, "packet complete");
- rcon_read_packet(cfg, rcon, &id, &type, &msg);
+ rcon_read_packet(rcon, &id, &type, &msg);
if (id != 2) {
error("rcon stop failed - reply id (%" PRIi32 ")", id);
@@ -258,36 +228,36 @@ rcon_stop_reply(struct cfg *cfg, struct uring_task *task, int res)
verbose("rcon stop successful (%s)", msg);
out:
- uring_task_put(cfg, &rcon->task);
+ uring_task_put(&rcon->task);
}
static void
-rcon_stop_sent(struct cfg *cfg, struct uring_task *task, int res)
+rcon_stop_sent(struct uring_task *task, int res)
{
struct rcon *rcon = container_of(task, struct rcon, task);
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_RCON, task);
if (res < 0) {
debug(DBG_RCON, "res: %i", res);
- uring_task_put(cfg, &rcon->task);
+ uring_task_put(&rcon->task);
return;
}
debug(DBG_RCON, "stop cmd sent");
- uring_tbuf_read_until(cfg, &rcon->task, packet_complete, rcon_stop_reply);
+ uring_tbuf_read_until(&rcon->task, packet_complete, rcon_stop_reply);
}
static void
-rcon_login_reply(struct cfg *cfg, struct uring_task *task, int res)
+rcon_login_reply(struct uring_task *task, int res)
{
struct rcon *rcon = container_of(task, struct rcon, task);
int32_t id;
int32_t type;
char *msg;
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_RCON, task);
if (res < 0) {
@@ -296,7 +266,7 @@ rcon_login_reply(struct cfg *cfg, struct uring_task *task, int res)
}
debug(DBG_RCON, "packet complete");
- rcon_read_packet(cfg, rcon, &id, &type, &msg);
+ rcon_read_packet(rcon, &id, &type, &msg);
if (id != 1) {
error("rcon login failed - unexpected reply id (%" PRIi32 ")", id);
@@ -310,66 +280,95 @@ rcon_login_reply(struct cfg *cfg, struct uring_task *task, int res)
}
debug(DBG_RCON, "rcon login successful");
- create_packet(cfg, rcon, 2, RCON_PACKET_COMMAND, "stop");
- uring_tbuf_write(cfg, &rcon->task, rcon_stop_sent);
+ create_packet(rcon, 2, RCON_PACKET_COMMAND, "stop");
+ uring_tbuf_write(&rcon->task, rcon_stop_sent);
return;
error:
- uring_task_put(cfg, &rcon->task);
+ uring_task_put(&rcon->task);
}
static void
-rcon_login_sent(struct cfg *cfg, struct uring_task *task, int res)
+rcon_login_sent(struct uring_task *task, int res)
{
struct rcon *rcon = container_of(task, struct rcon, task);
- assert_return(cfg && task);
+ assert_return(task);
assert_task_alive(DBG_RCON, task);
if (res < 0) {
debug(DBG_RCON, "res: %i", res);
- uring_task_put(cfg, &rcon->task);
+ uring_task_put(&rcon->task);
return;
}
debug(DBG_RCON, "login sent");
- uring_tbuf_read_until(cfg, &rcon->task, packet_complete, rcon_login_reply);
+ uring_tbuf_read_until(&rcon->task, packet_complete, rcon_login_reply);
}
static void
-rcon_connected_cb(struct cfg *cfg, struct connection *conn, bool connected)
+rcon_connected_cb(struct connection *conn, bool connected)
{
struct rcon *rcon = container_of(conn, struct rcon, conn);
- assert_return(cfg && conn);
+ assert_return(conn);
assert_task_alive(DBG_RCON, &rcon->task);
if (!connected) {
error("rcon connection to remote server (%s) failed",
rcon->server->name);
- uring_task_put(cfg, &rcon->task);
+ uring_task_put(&rcon->task);
return;
}
- create_packet(cfg, rcon, 1, RCON_PACKET_LOGIN, rcon->server->rcon_password);
- uring_tbuf_write(cfg, &rcon->task, rcon_login_sent);
+ create_packet(rcon, 1, RCON_PACKET_LOGIN, rcon->server->rcon_password);
+ uring_tbuf_write(&rcon->task, rcon_login_sent);
+}
+
+static void
+rcon_free(struct uring_task *task)
+{
+ struct rcon *rcon = container_of(task, struct rcon, task);
+
+ assert_return(task);
+
+ debug(DBG_RCON, "task %p, idle %p", task, rcon);
+ xfree(rcon);
+}
+
+void
+rcon_refdump(struct rcon *rcon)
+{
+ assert_return_silent(rcon);
+
+ uring_task_refdump(&rcon->task);
+}
+
+void
+rcon_delete(struct server *server)
+{
+ assert_return_silent(server->rcon);
+
+ debug(DBG_RCON, "closing fd %i", server->rcon->task.fd);
+ uring_task_destroy(&server->rcon->task);
+ server->rcon = NULL;
}
void
-rcon_init(struct cfg *cfg, struct server *server)
+rcon_init(struct server *server)
{
struct rcon *rcon;
- assert_return(cfg && server && !list_empty(&server->rcons) && !empty_str(server->rcon_password));
+ assert_return(server && !server->rcon && !list_empty(&server->rcons) && !empty_str(server->rcon_password));
rcon = zmalloc(sizeof(*rcon));
if (!rcon)
die("malloc: %m");
- uring_task_init(cfg, &rcon->task, "rcon", &server->task, rcon_free);
+ uring_task_init(&rcon->task, "rcon", &server->task, rcon_free);
uring_task_set_buf(&rcon->task, &rcon->tbuf);
rcon->server = server;
server->rcon = rcon;
- connect_any(cfg, &rcon->task, &server->rcons, &rcon->conn, rcon_connected_cb);
+ connect_any(&rcon->task, &server->rcons, &rcon->conn, rcon_connected_cb);
}
diff --git a/rcon.h b/rcon.h
index 8b410e1..6604304 100644
--- a/rcon.h
+++ b/rcon.h
@@ -3,8 +3,8 @@
void rcon_refdump(struct rcon *rcon);
-void rcon_delete(struct cfg *cfg, struct server *server);
+void rcon_delete(struct server *server);
-void rcon_init(struct cfg *cfg, struct server *server);
+void rcon_init(struct server *server);
#endif
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);
diff --git a/server.h b/server.h
index b104ef1..e5913ae 100644
--- a/server.h
+++ b/server.h
@@ -39,7 +39,6 @@ struct server {
struct list_head rcons;
struct list_head dnslookups;
enum server_state state;
- struct cfg *cfg;
enum server_stop_method stop_method;
enum server_start_method start_method;
@@ -77,59 +76,51 @@ struct server {
void server_refdump(struct server *server);
-void server_delete(struct cfg *cfg, struct server *server);
+void server_delete(struct server *server);
-void server_delete_by_name(struct cfg *cfg, const char *name);
+void server_delete_by_name(const char *name);
-bool server_start(struct cfg *cfg, struct server *server);
+bool server_start(struct server *server);
-bool server_stop(struct cfg *cfg, struct server *server);
+bool server_stop(struct server *server);
-void server_set_active_players(struct cfg *cfg, struct server *server,
- int count);
+void server_set_active_players(struct server *server, int count);
-bool server_idle_check(struct cfg *cfg, struct server *server);
+bool server_idle_check(struct server *server);
-bool server_announce(struct cfg *cfg, struct server *server, int fd);
+bool server_announce(struct server *server, int fd);
-bool server_commit(struct cfg *cfg, struct server *server);
+bool server_commit(struct server *server);
-bool server_add_remote(struct cfg *cfg, struct server *server,
- struct saddr *remote);
+bool server_add_remote(struct server *server, struct saddr *remote);
-bool server_add_local(struct cfg *cfg, struct server *server,
- struct saddr *saddr);
+bool server_add_local(struct server *server, struct saddr *saddr);
-bool server_add_rcon(struct cfg *cfg, struct server *server,
- struct saddr *rcon);
+bool server_add_rcon(struct server *server, struct saddr *rcon);
-bool server_set_rcon_password(struct cfg *cfg, struct server *server,
- const char *password);
+bool server_set_rcon_password(struct server *server, const char *password);
-bool server_set_systemd_service(struct cfg *cfg, struct server *server,
- const char *service);
+bool server_set_systemd_service(struct server *server, const char *service);
-bool server_set_stop_method(struct cfg *cfg, struct server *server,
+bool server_set_stop_method(struct server *server,
enum server_stop_method stop_method);
-bool server_set_start_method(struct cfg *cfg, struct server *server,
+bool server_set_start_method(struct server *server,
enum server_start_method start_method);
-bool server_set_stop_exec(struct cfg *cfg, struct server *server, const char *cmd);
+bool server_set_stop_exec(struct server *server, const char *cmd);
-bool server_set_start_exec(struct cfg *cfg, struct server *server, const char *cmd);
+bool server_set_start_exec(struct server *server, const char *cmd);
-bool server_set_idle_timeout(struct cfg *cfg, struct server *server, uint16_t timeout);
+bool server_set_idle_timeout(struct server *server, uint16_t timeout);
-bool server_set_port(struct cfg *cfg, struct server *server, uint16_t port);
+bool server_set_port(struct server *server, uint16_t port);
-bool server_set_type(struct cfg *cfg, struct server *server,
- enum server_type type);
+bool server_set_type(struct server *server, enum server_type type);
-bool server_set_pretty_name(struct cfg *cfg, struct server *server,
- const char *pretty_name);
+bool server_set_pretty_name(struct server *server, const char *pretty_name);
-struct server *server_new(struct cfg *cfg, const char *name);
+struct server *server_new(const char *name);
#endif
diff --git a/systemd.c b/systemd.c
index 8752b4e..c5c62d3 100644
--- a/systemd.c
+++ b/systemd.c
@@ -30,13 +30,13 @@ tohex(uint8_t val)
* Example: minecraft@world1.service -> minecraft_40world1_2eservice
*/
char *
-systemd_service_object_path(struct cfg *cfg, const char *service)
+systemd_object_path(const char *service)
{
char *r;
char *d;
const char *s;
- assert_return(cfg && service && !empty_str(service), NULL);
+ assert_return(service && !empty_str(service), NULL);
r = zmalloc(strlen(SYSTEMD_DBUS_PATH_PREFIX) + strlen(service) * 3 + 1);
if (!r)
@@ -63,9 +63,8 @@ systemd_service_object_path(struct cfg *cfg, const char *service)
}
void
-systemd_delete(struct cfg *cfg)
+systemd_delete()
{
- assert_return(cfg);
assert_return_silent(cfg->sd_bus);
sd_bus_unref(cfg->sd_bus);
@@ -73,12 +72,10 @@ systemd_delete(struct cfg *cfg)
}
static sd_bus *
-get_bus(struct cfg *cfg)
+get_bus()
{
int r;
- assert_return(cfg, NULL);
-
if (cfg->sd_bus_failed)
return NULL;
@@ -106,15 +103,15 @@ get_bus(struct cfg *cfg)
* "ActiveState"
*/
bool
-systemd_service_running(struct cfg *cfg, struct server *server)
+systemd_service_running(struct server *server)
{
- sd_bus *bus = get_bus(cfg);
+ sd_bus *bus = get_bus();
sd_bus_error error = SD_BUS_ERROR_NULL;
char *status = NULL;
bool running = false;
int r;
- assert_return(cfg && server && bus && server->systemd_service && server->systemd_obj, false);
+ assert_return(server && bus && server->systemd_service && server->systemd_obj, false);
r = sd_bus_get_property_string(bus,
SYSTEMD_DBUS_SERVICE,
@@ -144,16 +141,16 @@ out:
}
static bool
-systemd_service_action(struct cfg *cfg, struct server *server, const char *action)
+systemd_service_action(struct server *server, const char *action)
{
sd_bus_error error = SD_BUS_ERROR_NULL;
sd_bus_message *m = NULL;
- sd_bus *bus = get_bus(cfg);
+ sd_bus *bus = get_bus();
const char *path;
bool performed = false;
int r;
- assert_return(cfg && server && bus && server->systemd_service && server->systemd_obj && action, false);
+ assert_return(server && bus && server->systemd_service && server->systemd_obj && action, false);
r = sd_bus_call_method(bus,
SYSTEMD_DBUS_SERVICE,
@@ -196,11 +193,11 @@ out:
* --method org.freedesktop.systemd1.Unit.Stop "fail"
*/
bool
-systemd_service_stop(struct cfg *cfg, struct server *server)
+systemd_service_stop(struct server *server)
{
- assert_return(cfg && server, false);
+ assert_return(server, false);
- return systemd_service_action(cfg, server, "Stop");
+ return systemd_service_action(server, "Stop");
}
/*
@@ -213,10 +210,10 @@ systemd_service_stop(struct cfg *cfg, struct server *server)
* --method org.freedesktop.systemd1.Unit.Start "fail"
*/
bool
-systemd_service_start(struct cfg *cfg, struct server *server)
+systemd_service_start(struct server *server)
{
- assert_return(cfg && server, false);
+ assert_return(server, false);
- return systemd_service_action(cfg, server, "Start");
+ return systemd_service_action(server, "Start");
}
diff --git a/systemd.h b/systemd.h
index ccf63dd..d455044 100644
--- a/systemd.h
+++ b/systemd.h
@@ -1,22 +1,14 @@
#ifndef foosystemdhfoo
#define foosystemdhfoo
-char *systemd_service_object_path(struct cfg *cfg, const char *service);
+char *systemd_object_path(const char *service);
-void systemd_delete(struct cfg *cfg);
+void systemd_delete();
-bool systemd_service_running(struct cfg *cfg, struct server *server);
+bool systemd_service_running(struct server *server);
-bool systemd_service_stop(struct cfg *cfg, struct server *server);
+bool systemd_service_stop(struct server *server);
-bool systemd_service_start(struct cfg *cfg, struct server *server);
-
-/*
-void idle_refdump(struct idle *idle);
-
-void idle_delete(struct cfg *cfg, struct server *server);
-
-void idle_init(struct cfg *cfg, struct server *server);
-*/
+bool systemd_service_start(struct server *server);
#endif
diff --git a/uring.c b/uring.c
index 9430ca9..65b59f9 100644
--- a/uring.c
+++ b/uring.c
@@ -11,7 +11,6 @@
struct uring_ev {
struct io_uring uring;
struct io_uring_params uring_params;
- struct cfg *cfg;
struct uring_task task;
};
@@ -28,11 +27,11 @@ uint64_t sqe_count = 0;
uint64_t cqe_count = 0;
static struct io_uring_sqe *
-get_sqe(struct cfg *cfg, struct uring_task *task)
+get_sqe(struct uring_task *task)
{
struct io_uring_sqe *sqe;
- assert_die(cfg && task, "invalid arguments");
+ assert_die(task, "invalid arguments");
sqe = io_uring_get_sqe(&cfg->uev->uring);
if (!sqe) {
@@ -43,7 +42,7 @@ get_sqe(struct cfg *cfg, struct uring_task *task)
}
sqe_count++;
- uring_task_get(cfg, task);
+ uring_task_get(task);
return sqe;
}
@@ -89,9 +88,9 @@ uring_task_refdump(struct uring_task *task)
* while the task is active.
*/
void
-uring_task_destroy(struct cfg *cfg, struct uring_task *task)
+uring_task_destroy(struct uring_task *task)
{
- assert_return(cfg && task);
+ assert_return(task);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
@@ -99,21 +98,21 @@ uring_task_destroy(struct cfg *cfg, struct uring_task *task)
if (task->fd >= 0) {
struct io_uring_sqe *sqe;
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
io_uring_prep_cancel(sqe, task, 0);
io_uring_sqe_set_data(sqe, (void *)((uintptr_t)task | CQE_TYPE_CANCEL));
}
task->dead = true;
- uring_task_put(cfg, task);
+ uring_task_put(task);
}
void
-uring_task_put(struct cfg *cfg, struct uring_task *task)
+uring_task_put(struct uring_task *task)
{
struct uring_task *parent;
- assert_return(cfg && task);
+ assert_return(task);
debug(DBG_REF, "task %s (%p), refcount %u -> %u",
task->name, task, task->refcount, task->refcount - 1);
@@ -127,7 +126,7 @@ uring_task_put(struct cfg *cfg, struct uring_task *task)
error("Negative refcount!");
if (task->fd >= 0) {
- uring_task_close_fd(cfg, task);
+ uring_task_close_fd(task);
/* We'll be called again once the fd is closed */
return;
}
@@ -138,14 +137,14 @@ uring_task_put(struct cfg *cfg, struct uring_task *task)
if (parent) {
debug(DBG_REF, "putting parent %s (%p)", parent->name, parent);
- uring_task_put(cfg, parent);
+ uring_task_put(parent);
}
}
void
-uring_task_get(struct cfg *cfg, struct uring_task *task)
+uring_task_get(struct uring_task *task)
{
- assert_return(cfg && task);
+ assert_return(task);
debug(DBG_REF, "task %s (%p), refcount %u -> %u",
task->name, task, task->refcount, task->refcount + 1);
@@ -187,9 +186,9 @@ uring_task_set_fd(struct uring_task *task, int fd)
}
void
-uring_task_close_fd(struct cfg *cfg, struct uring_task *task)
+uring_task_close_fd(struct uring_task *task)
{
- assert_return(cfg && task);
+ assert_return(task);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
@@ -197,25 +196,25 @@ uring_task_close_fd(struct cfg *cfg, struct uring_task *task)
if (task->fd < 0)
return;
- uring_close(cfg, task, task->fd);
+ uring_close(task, task->fd);
task->fd = -1;
}
struct uring_task *
-uring_parent(struct cfg *cfg)
+uring_parent()
{
- assert_die(cfg && cfg->uev, "invalid arguments");
+ assert_die(cfg->uev, "invalid arguments");
return &cfg->uev->task;
}
void
-uring_task_init(struct cfg *cfg, struct uring_task *task, const char *name,
+uring_task_init(struct uring_task *task, const char *name,
struct uring_task *parent, void (*free)(struct uring_task *))
{
static bool first = true;
- assert_die(cfg && task && !empty_str(name) && free, "invalid arguments");
+ assert_die(task && !empty_str(name) && free, "invalid arguments");
if (first)
first = false;
@@ -235,31 +234,31 @@ uring_task_init(struct cfg *cfg, struct uring_task *task, const char *name,
"getting parent %s (%p), refcount %u",
task->name, task, task->refcount,
task->parent->name, task->parent, task->parent->refcount);
- uring_task_get(cfg, task->parent);
+ uring_task_get(task->parent);
}
}
void
-uring_close(struct cfg *cfg, struct uring_task *task, int fd)
+uring_close(struct uring_task *task, int fd)
{
struct io_uring_sqe *sqe;
- assert_return(cfg && task && fd >= 0);
+ assert_return(task && fd >= 0);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
io_uring_prep_close(sqe, fd);
io_uring_sqe_set_data(sqe, (void *)((uintptr_t)task | CQE_TYPE_CLOSE));
}
static void
-uring_tbuf_write_cb(struct cfg *cfg, struct uring_task *task, int res)
+uring_tbuf_write_cb(struct uring_task *task, int res)
{
int r;
- assert_return(cfg && task && task->tbuf && task->final_cb);
+ assert_return(task && task->tbuf && task->final_cb);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
@@ -276,50 +275,50 @@ uring_tbuf_write_cb(struct cfg *cfg, struct uring_task *task, int res)
goto finished;
}
- uring_write(cfg, task, task->tbuf->buf + task->tbuf->done,
+ uring_write(task, task->tbuf->buf + task->tbuf->done,
task->tbuf->len - task->tbuf->done,
uring_tbuf_write_cb);
return;
finished:
- task->final_cb(cfg, task, r);
+ task->final_cb(task, r);
}
void
-uring_tbuf_write(struct cfg *cfg, struct uring_task *task, utask_cb_t final_cb)
+uring_tbuf_write(struct uring_task *task, utask_cb_t final_cb)
{
- assert_return(cfg && task && task->fd >= 0 && task->tbuf && task->tbuf->len > 0);
+ assert_return(task && task->fd >= 0 && task->tbuf && task->tbuf->len > 0);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
task->tbuf->done = 0;
task->final_cb = final_cb;
- uring_write(cfg, task, &task->tbuf->buf, task->tbuf->len, uring_tbuf_write_cb);
+ uring_write(task, &task->tbuf->buf, task->tbuf->len, uring_tbuf_write_cb);
}
void
-uring_write(struct cfg *cfg, struct uring_task *task, void *buf, size_t len, utask_cb_t cb)
+uring_write(struct uring_task *task, void *buf, size_t len, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
- assert_return(cfg && task && buf && len > 0 && cb && task->fd >= 0);
+ assert_return(task && buf && len > 0 && cb && task->fd >= 0);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
task->cb = cb;
io_uring_prep_write(sqe, task->fd, buf, len, 0);
io_uring_sqe_set_data(sqe, task);
}
static void
-uring_tbuf_read_until_cb(struct cfg *cfg, struct uring_task *task, int res)
+uring_tbuf_read_until_cb(struct uring_task *task, int res)
{
int r;
- assert_return(cfg && task && task->tbuf && task->final_cb && task->is_complete_cb);
+ assert_return(task && task->tbuf && task->final_cb && task->is_complete_cb);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
@@ -330,7 +329,7 @@ uring_tbuf_read_until_cb(struct cfg *cfg, struct uring_task *task, int res)
}
task->tbuf->len += res;
- r = task->is_complete_cb(cfg, task, res);
+ r = task->is_complete_cb(task, res);
if (r < 0) {
r = res;
goto finished;
@@ -345,20 +344,20 @@ uring_tbuf_read_until_cb(struct cfg *cfg, struct uring_task *task, int res)
goto finished;
}
- uring_read_offset(cfg, task, task->tbuf->buf + task->tbuf->len,
+ uring_read_offset(task, task->tbuf->buf + task->tbuf->len,
sizeof(task->tbuf->buf) - task->tbuf->len,
task->tbuf->len, uring_tbuf_read_until_cb);
return;
finished:
- task->final_cb(cfg, task, r);
+ task->final_cb(task, r);
}
void
-uring_tbuf_read_until(struct cfg *cfg, struct uring_task *task,
+uring_tbuf_read_until(struct uring_task *task,
rutask_cb_t is_complete_cb, utask_cb_t final_cb)
{
- assert_return(cfg && task && task->fd >= 0 && task->tbuf && is_complete_cb && final_cb);
+ assert_return(task && task->fd >= 0 && task->tbuf && is_complete_cb && final_cb);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
@@ -366,14 +365,14 @@ uring_tbuf_read_until(struct cfg *cfg, struct uring_task *task,
task->tbuf->len = 0;
task->is_complete_cb = is_complete_cb;
task->final_cb = final_cb;
- uring_read(cfg, task, &task->tbuf->buf, sizeof(task->tbuf->buf),
+ uring_read(task, &task->tbuf->buf, sizeof(task->tbuf->buf),
uring_tbuf_read_until_cb);
}
static int
-uring_tbuf_eof(struct cfg *cfg, struct uring_task *task, int res)
+uring_tbuf_eof(struct uring_task *task, int res)
{
- assert_return(cfg && task && task->tbuf, -EINVAL);
+ assert_return(task && task->tbuf, -EINVAL);
assert_task_alive_or(DBG_UR, task, return -EINTR);
if (task->tbuf->len + 1 >= sizeof(task->tbuf->buf))
@@ -388,18 +387,18 @@ uring_tbuf_eof(struct cfg *cfg, struct uring_task *task, int res)
}
void
-uring_tbuf_read_until_eof(struct cfg *cfg, struct uring_task *task,
+uring_tbuf_read_until_eof(struct uring_task *task,
utask_cb_t final_cb)
{
- assert_return(cfg && task && task->tbuf && final_cb);
+ assert_return(task && task->tbuf && final_cb);
- uring_tbuf_read_until(cfg, task, uring_tbuf_eof, final_cb);
+ uring_tbuf_read_until(task, uring_tbuf_eof, final_cb);
}
static int
-uring_tbuf_have_data(struct cfg *cfg, struct uring_task *task, int res)
+uring_tbuf_have_data(struct uring_task *task, int res)
{
- assert_return(cfg && task, -EINVAL);
+ assert_return(task, -EINVAL);
if (res < 0)
return res;
@@ -408,56 +407,56 @@ uring_tbuf_have_data(struct cfg *cfg, struct uring_task *task, int res)
}
void
-uring_tbuf_read(struct cfg *cfg, struct uring_task *task, utask_cb_t final_cb)
+uring_tbuf_read(struct uring_task *task, utask_cb_t final_cb)
{
- assert_return(cfg && task && final_cb);
+ assert_return(task && final_cb);
- uring_tbuf_read_until(cfg, task, uring_tbuf_have_data, final_cb);
+ uring_tbuf_read_until(task, uring_tbuf_have_data, final_cb);
}
void
-uring_read_offset(struct cfg *cfg, struct uring_task *task, void *buf, size_t len, off_t offset, utask_cb_t cb)
+uring_read_offset(struct uring_task *task, void *buf, size_t len, off_t offset, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
- assert_return(cfg && task && buf && len > 0 && task->fd >= 0);
+ assert_return(task && buf && len > 0 && task->fd >= 0);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
task->cb = cb;
io_uring_prep_read(sqe, task->fd, buf, len, offset);
io_uring_sqe_set_data(sqe, task);
}
void
-uring_openat(struct cfg *cfg, struct uring_task *task, const char *path, utask_cb_t cb)
+uring_openat(struct uring_task *task, const char *path, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
- assert_return(cfg && task && !empty_str(path) && cb);
+ assert_return(task && !empty_str(path) && cb);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
task->cb = cb;
io_uring_prep_openat(sqe, AT_FDCWD, path, O_RDONLY | O_CLOEXEC, 0);
io_uring_sqe_set_data(sqe, task);
}
void
-uring_tbuf_recvmsg(struct cfg *cfg, struct uring_task *task, utask_cb_t cb)
+uring_tbuf_recvmsg(struct uring_task *task, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
- assert_return(cfg && task && task->fd >= 0 && task->tbuf && cb);
+ assert_return(task && task->fd >= 0 && task->tbuf && cb);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
task->tbuf->done = 0;
task->tbuf->len = 0;
task->tbuf->iov.iov_len = sizeof(task->tbuf->buf);
@@ -468,16 +467,16 @@ uring_tbuf_recvmsg(struct cfg *cfg, struct uring_task *task, utask_cb_t cb)
}
void
-uring_tbuf_sendmsg(struct cfg *cfg, struct uring_task *task, utask_cb_t cb)
+uring_tbuf_sendmsg(struct uring_task *task, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
- assert_return(cfg && task && task->fd >= 0 && task->tbuf && cb);
+ assert_return(task && task->fd >= 0 && task->tbuf && cb);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
task->tbuf->done = 0;
task->tbuf->iov.iov_len = task->tbuf->len;
task->tbuf->msg.msg_namelen = task->saddr.addrlen;
@@ -487,32 +486,32 @@ uring_tbuf_sendmsg(struct cfg *cfg, struct uring_task *task, utask_cb_t cb)
}
void
-uring_connect(struct cfg *cfg, struct uring_task *task, struct saddr *saddr, utask_cb_t cb)
+uring_connect(struct uring_task *task, struct saddr *saddr, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
- assert_return(cfg && task && task->fd >= 0 && saddr && cb);
+ assert_return(task && task->fd >= 0 && saddr && cb);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
task->cb = cb;
io_uring_prep_connect(sqe, task->fd, (struct sockaddr *)&saddr->storage, saddr->addrlen);
io_uring_sqe_set_data(sqe, task);
}
void
-uring_accept(struct cfg *cfg, struct uring_task *task, struct saddr *saddr, utask_cb_t cb)
+uring_accept(struct uring_task *task, struct saddr *saddr, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
- assert_return(cfg && task && task->fd >= 0 && saddr && cb);
+ assert_return(task && task->fd >= 0 && saddr && cb);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
saddr->addrlen = sizeof(saddr->storage);
task->cb = cb;
io_uring_prep_accept(sqe, task->fd, (struct sockaddr *)&saddr->storage, &saddr->addrlen, SOCK_CLOEXEC);
@@ -520,27 +519,27 @@ uring_accept(struct cfg *cfg, struct uring_task *task, struct saddr *saddr, utas
}
void
-uring_poll(struct cfg *cfg, struct uring_task *task, short poll_mask, utask_cb_t cb)
+uring_poll(struct uring_task *task, short poll_mask, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
- assert_return(cfg && task && task->fd >= 0 && poll_mask && cb);
+ assert_return(task && task->fd >= 0 && poll_mask && cb);
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
task->cb = cb;
io_uring_prep_poll_add(sqe, task->fd, poll_mask);
io_uring_sqe_set_data(sqe, task);
}
void
-uring_poll_cancel(struct cfg *cfg, struct uring_task *task)
+uring_poll_cancel(struct uring_task *task)
{
struct io_uring_sqe *sqe;
- assert_return(cfg && task);
+ assert_return(task);
if (task->fd < 0) {
/* not an error, no need to print error msg */
@@ -550,7 +549,7 @@ uring_poll_cancel(struct cfg *cfg, struct uring_task *task)
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- sqe = get_sqe(cfg, task);
+ sqe = get_sqe(task);
task->dead = true;
io_uring_prep_poll_remove(sqe, task);
io_uring_sqe_set_data(sqe, (void *)((uintptr_t)task | CQE_TYPE_POLL_CANCEL));
@@ -567,7 +566,7 @@ uring_free(struct uring_task *task)
task->name, task, task->fd, task->refcount);
io_uring_queue_exit(&uev->uring);
- uev->cfg->uev = NULL;
+ cfg->uev = NULL;
xfree(uev);
}
@@ -580,26 +579,24 @@ uring_refdump(struct uring_ev *uev)
}
void
-uring_delete(struct cfg *cfg)
+uring_delete()
{
struct uring_task *task;
- assert_return(cfg && cfg->uev);
+ assert_return(cfg->uev);
task = &cfg->uev->task;
debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
task->name, task, task->fd, task->refcount);
- uring_task_put(cfg, task);
+ uring_task_put(task);
}
void
-uring_init(struct cfg *cfg)
+uring_init()
{
struct uring_ev *uev;
- assert_return(cfg);
-
uev = zmalloc(sizeof(*uev));
if (!uev)
die("malloc: %m");
@@ -610,16 +607,15 @@ uring_init(struct cfg *cfg)
debug(DBG_UR, "uring initialized, features: 0x%08x",
uev->uring_params.features);
- uring_task_init(cfg, &uev->task, "io_uring", &cfg->task, uring_free);
+ uring_task_init(&uev->task, "io_uring", &cfg->task, uring_free);
cfg->uev = uev;
- uev->cfg = cfg;
}
static inline void
-uring_print_cqe(struct cfg *cfg, const char *type, struct uring_task *task,
+uring_print_cqe(const char *type, struct uring_task *task,
struct io_uring_cqe *cqe)
{
- assert_return(cfg && !empty_str(type) && task && cqe);
+ assert_return(!empty_str(type) && task && cqe);
debug(DBG_UR, "got CQE "
"(type: %s, res: %i (%s), task: %s (%p), fd: %i, cb: %p)",
@@ -633,10 +629,8 @@ uring_print_cqe(struct cfg *cfg, const char *type, struct uring_task *task,
}
void
-uring_event_loop(struct cfg *cfg)
+uring_event_loop()
{
- assert_return(cfg);
-
while (true) {
struct io_uring_cqe *cqe;
unsigned nr, head;
@@ -667,22 +661,22 @@ uring_event_loop(struct cfg *cfg)
switch (cqe_type) {
case CQE_TYPE_CANCEL:
- uring_print_cqe(cfg, "cancel", task, cqe);
+ uring_print_cqe("cancel", task, cqe);
do_cb = false;
break;
case CQE_TYPE_CLOSE:
- uring_print_cqe(cfg, "close", task, cqe);
+ uring_print_cqe("close", task, cqe);
do_cb = false;
break;
case CQE_TYPE_POLL_CANCEL:
- uring_print_cqe(cfg, "poll_cancel", task, cqe);
+ uring_print_cqe("poll_cancel", task, cqe);
do_cb = false;
break;
case CQE_TYPE_NORMAL:
- uring_print_cqe(cfg, "standard", task, cqe);
+ uring_print_cqe("standard", task, cqe);
do_cb = true;
break;
@@ -691,9 +685,9 @@ uring_event_loop(struct cfg *cfg)
}
if (do_cb && task->cb)
- task->cb(cfg, task, cqe->res);
+ task->cb(task, cqe->res);
- uring_task_put(cfg, task);
+ uring_task_put(task);
if (exiting)
return;
diff --git a/uring.h b/uring.h
index dbf7faf..70c72e5 100644
--- a/uring.h
+++ b/uring.h
@@ -6,75 +6,66 @@ extern uint64_t cqe_count;
void uring_task_refdump(struct uring_task *task);
-void uring_task_destroy(struct cfg *cfg, struct uring_task *task);
+void uring_task_destroy(struct uring_task *task);
-void uring_task_put(struct cfg *cfg, struct uring_task *task);
+void uring_task_put(struct uring_task *task);
-void uring_task_get(struct cfg *cfg, struct uring_task *task);
+void uring_task_get(struct uring_task *task);
void uring_task_set_buf(struct uring_task *task, struct uring_task_buf *tbuf);
void uring_task_set_fd(struct uring_task *task, int fd);
-void uring_task_close_fd(struct cfg *cfg, struct uring_task *task);
+void uring_task_close_fd(struct uring_task *task);
-struct uring_task *uring_parent(struct cfg *cfg);
+struct uring_task *uring_parent();
-void uring_task_init(struct cfg *cfg, struct uring_task *task, const char *name,
+void uring_task_init(struct uring_task *task, const char *name,
struct uring_task *parent,
void (*free)(struct uring_task *));
-void uring_close(struct cfg *cfg, struct uring_task *task, int fd);
+void uring_close(struct uring_task *task, int fd);
-void uring_tbuf_write(struct cfg *cfg, struct uring_task *task,
- utask_cb_t final_cb);
+void uring_tbuf_write(struct uring_task *task, utask_cb_t final_cb);
-void uring_write(struct cfg *cfg, struct uring_task *task, void *buf,
- size_t len, utask_cb_t cb);
+void uring_write(struct uring_task *task, void *buf, size_t len, utask_cb_t cb);
-void uring_tbuf_read_until(struct cfg *cfg, struct uring_task *task,
+void uring_tbuf_read_until(struct uring_task *task,
rutask_cb_t is_complete_cb, utask_cb_t final_cb);
-void uring_tbuf_read_until_eof(struct cfg *cfg, struct uring_task *task,
- utask_cb_t final_cb);
+void uring_tbuf_read_until_eof(struct uring_task *task, utask_cb_t final_cb);
-void uring_tbuf_read(struct cfg *cfg, struct uring_task *task,
- utask_cb_t final_cb);
+void uring_tbuf_read(struct uring_task *task, utask_cb_t final_cb);
-void uring_read_offset(struct cfg *cfg, struct uring_task *task, void *buf,
+void uring_read_offset(struct uring_task *task, void *buf,
size_t len, off_t offset, utask_cb_t cb);
static inline void
-uring_read(struct cfg *cfg, struct uring_task *task, void *buf, size_t len,
- utask_cb_t cb)
+uring_read(struct uring_task *task, void *buf, size_t len, utask_cb_t cb)
{
- uring_read_offset(cfg, task, buf, len, 0, cb);
+ uring_read_offset(task, buf, len, 0, cb);
}
-void uring_openat(struct cfg *cfg, struct uring_task *task, const char *path,
- utask_cb_t cb);
+void uring_openat(struct uring_task *task, const char *path, utask_cb_t cb);
-void uring_tbuf_recvmsg(struct cfg *cfg, struct uring_task *task, utask_cb_t cb);
+void uring_tbuf_recvmsg(struct uring_task *task, utask_cb_t cb);
-void uring_tbuf_sendmsg(struct cfg *cfg, struct uring_task *task, utask_cb_t cb);
+void uring_tbuf_sendmsg(struct uring_task *task, utask_cb_t cb);
-void uring_connect(struct cfg *cfg, struct uring_task *task,
- struct saddr *saddr, utask_cb_t cb);
+void uring_connect(struct uring_task *task, struct saddr *saddr, utask_cb_t cb);
-void uring_accept(struct cfg *cfg, struct uring_task *task,
- struct saddr *saddr, utask_cb_t cb);
+void uring_accept(struct uring_task *task, struct saddr *saddr, utask_cb_t cb);
-void uring_poll(struct cfg *cfg, struct uring_task *task, short poll_mask,
- utask_cb_t cb);
+void uring_poll(struct uring_task *task, short poll_mask, utask_cb_t cb);
-void uring_poll_cancel(struct cfg *cfg, struct uring_task *task);
+void uring_poll_cancel(struct uring_task *task);
-void uring_delete(struct cfg *cfg);
+void uring_delete();
void uring_refdump(struct uring_ev *uev);
-void uring_init(struct cfg *cfg);
+void uring_init();
-void uring_event_loop(struct cfg *cfg);
+void uring_event_loop();
#endif
diff --git a/utils.c b/utils.c
index ff18fb1..92e607d 100644
--- a/utils.c
+++ b/utils.c
@@ -169,11 +169,11 @@ debug_resource_usage()
}
void
-socket_set_low_latency(struct cfg *cfg, int sfd)
+socket_set_low_latency(int sfd)
{
int option;
- assert_return(cfg && sfd >= 0);
+ assert_return(sfd >= 0);
/* FIXME: could make this configurable */
option = true;
@@ -192,9 +192,9 @@ socket_set_low_latency(struct cfg *cfg, int sfd)
}
void
-connection_set_local(struct cfg *cfg, struct connection *conn, int fd)
+connection_set_local(struct connection *conn, int fd)
{
- assert_return(cfg && conn && fd >= 0);
+ assert_return(conn && fd >= 0);
conn->local.addrlen = sizeof(conn->local.storage);
if (getsockname(fd, (struct sockaddr *)&conn->local.storage,
@@ -205,48 +205,48 @@ connection_set_local(struct cfg *cfg, struct connection *conn, int fd)
}
void
-connection_set_remote(struct cfg *cfg, struct connection *conn, struct saddr *remote)
+connection_set_remote(struct connection *conn, struct saddr *remote)
{
- assert_return(cfg && conn && remote);
+ assert_return(conn && remote);
conn->remote = *remote;
saddr_set_addrstr(&conn->remote);
}
-static void connect_next(struct cfg *cfg, struct uring_task *task, struct connection *conn);
+static void connect_next(struct uring_task *task, struct connection *conn);
static void
-connect_cb(struct cfg *cfg, struct uring_task *task, int res)
+connect_cb(struct uring_task *task, int res)
{
struct connection *conn;
- assert_return(cfg && task && task->priv);
+ assert_return(task && task->priv);
conn = task->priv;
if (res < 0) {
debug(DBG_UR, "%s: connection to %s failed",
task->name, conn->remote.addrstr);
- uring_task_close_fd(cfg, task);
- connect_next(cfg, task, conn);
+ uring_task_close_fd(task);
+ connect_next(task, conn);
return;
}
- connection_set_local(cfg, conn, task->fd);
+ connection_set_local(conn, task->fd);
debug(DBG_UR, "%s: connection established %s -> %s",
task->name, conn->local.addrstr, conn->remote.addrstr);
- conn->callback(cfg, conn, true);
+ conn->cb(conn, true);
}
static void
-connect_next(struct cfg *cfg, struct uring_task *task, struct connection *conn)
+connect_next(struct uring_task *task, struct connection *conn)
{
struct saddr *remote, *tmp;
int sfd;
unsigned i;
- assert_return(cfg && task && conn && conn->callback);
+ assert_return(task && conn && conn->cb);
again:
assert_task_alive_or(DBG_UR, task, goto out);
@@ -267,7 +267,7 @@ again:
}
conn->next_addr++;
- connection_set_remote(cfg, conn, remote);
+ connection_set_remote(conn, remote);
debug(DBG_MALLOC, "%s: attempting to connect to %s",
task->name, conn->remote.addrstr);
@@ -277,28 +277,28 @@ again:
goto again;
}
- socket_set_low_latency(cfg, sfd);
+ socket_set_low_latency(sfd);
task->priv = conn;
uring_task_set_fd(task, sfd);
- uring_connect(cfg, task, &conn->remote, connect_cb);
+ uring_connect(task, &conn->remote, connect_cb);
return;
out:
- conn->callback(cfg, conn, false);
+ conn->cb(conn, false);
}
void
-connect_any(struct cfg *cfg, struct uring_task *task,
+connect_any(struct uring_task *task,
struct list_head *addrs, struct connection *conn,
- void (*callback)(struct cfg *, struct connection *, bool res))
+ connection_cb_t cb)
{
- assert_return(cfg && task && addrs && conn && callback);
+ assert_return(task && addrs && conn && cb);
conn->next_addr = 0;
conn->addrs = addrs;
- conn->callback = callback;
- connect_next(cfg, task, conn);
+ conn->cb = cb;
+ connect_next(task, conn);
}
uint16_t
diff --git a/utils.h b/utils.h
index 3e807bc..ff29d6c 100644
--- a/utils.h
+++ b/utils.h
@@ -49,6 +49,10 @@ struct saddr {
struct list_head list;
};
+struct connection;
+
+typedef void(*connection_cb_t)(struct connection *, bool);
+
struct connection {
struct saddr remote;
struct saddr local;
@@ -56,21 +60,20 @@ struct connection {
struct list_head *addrs;
unsigned next_addr;
- void (*callback)(struct cfg *, struct connection *, bool);
+ connection_cb_t cb;
};
struct uring_task;
-void socket_set_low_latency(struct cfg *cfg, int sfd);
+void socket_set_low_latency(int sfd);
-void connection_set_local(struct cfg *cfg, struct connection *conn, int fd);
+void connection_set_local(struct connection *conn, int fd);
-void connection_set_remote(struct cfg *cfg, struct connection *conn,
- struct saddr *remote);
+void connection_set_remote(struct connection *conn, struct saddr *remote);
-void connect_any(struct cfg *cfg, struct uring_task *task,
+void connect_any(struct uring_task *task,
struct list_head *addrs, struct connection *conn,
- void (*callback)(struct cfg *, struct connection *, bool));
+ connection_cb_t cb);
char *saddr_addr(struct saddr *saddr, char *buf, size_t len);
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-26 05:34:40 +0000