summaryrefslogtreecommitdiff
path: root/minecproxy
diff options
context:
space:
mode:
Diffstat (limited to 'minecproxy')
-rw-r--r--minecproxy/announce.c31
-rw-r--r--minecproxy/idle.c42
-rw-r--r--minecproxy/igmp.c115
-rw-r--r--minecproxy/main.c105
-rw-r--r--minecproxy/main.h2
-rw-r--r--minecproxy/misc.c124
-rw-r--r--minecproxy/misc.h7
-rw-r--r--minecproxy/ptimer.c59
-rw-r--r--minecproxy/ptimer.h5
-rw-r--r--minecproxy/server-config.c158
-rw-r--r--minecproxy/server-proxy.c185
-rw-r--r--minecproxy/server-proxy.h2
-rw-r--r--minecproxy/server-rcon.c64
-rw-r--r--minecproxy/server.c231
-rw-r--r--minecproxy/server.h5
-rw-r--r--minecproxy/signal-handler.c31
-rw-r--r--minecproxy/systemd.c133
-rw-r--r--minecproxy/uring.c290
-rw-r--r--minecproxy/uring.h15
19 files changed, 759 insertions, 845 deletions
diff --git a/minecproxy/announce.c b/minecproxy/announce.c
index 13ef423..78a7ccd 100644
--- a/minecproxy/announce.c
+++ b/minecproxy/announce.c
@@ -18,8 +18,7 @@ struct announce {
int mcast_fd;
};
-static void
-announce_cb(struct ptimer_task *ptask)
+static void announce_cb(struct ptimer_task *ptask)
{
struct announce *announce = container_of(ptask, struct announce, ptask);
struct server *server;
@@ -32,28 +31,25 @@ announce_cb(struct ptimer_task *ptask)
server_announce(server, announce->mcast_fd);
}
-static void
-announce_free(struct uring_task *task)
+static void announce_free(struct uring_task *task)
{
struct announce *announce = container_of(task, struct announce, task);
assert_return(task);
- debug(DBG_ANN, "task %p, announce 0x%p, mcast_fd: %i",
- task, announce, announce->mcast_fd);
+ debug(DBG_ANN, "task %p, announce 0x%p, mcast_fd: %i", task, announce,
+ announce->mcast_fd);
close(announce->mcast_fd);
xfree(announce);
}
-void
-announce_refdump()
+void announce_refdump()
{
assert_return_silent(cfg->announce);
uring_task_refdump(&cfg->announce->task);
}
-void
-announce_delete()
+void announce_delete()
{
assert_return_silent(cfg->announce);
@@ -63,8 +59,7 @@ announce_delete()
cfg->announce = NULL;
}
-void
-announce_stop()
+void announce_stop()
{
struct announce *announce = cfg->announce;
@@ -73,8 +68,7 @@ announce_stop()
ptimer_del_task(&announce->ptask);
}
-void
-announce_start(unsigned duration)
+void announce_start(unsigned duration)
{
struct announce *announce = cfg->announce;
unsigned times;
@@ -91,12 +85,11 @@ announce_start(unsigned duration)
ptimer_add_task(&announce->ptask);
}
-void
-announce_init()
+void announce_init()
{
struct announce *announce;
int sfd;
-
+
assert_return(!cfg->announce);
assert_return_silent(cfg->announce_interval > 0);
@@ -108,9 +101,9 @@ announce_init()
if (sfd < 0)
die("socket: %m");
- uring_task_init(&announce->task, "announce", uring_parent(), announce_free);
+ uring_task_init(&announce->task, "announce", uring_parent(),
+ announce_free);
ptask_init(&announce->ptask, cfg->announce_interval, 0, announce_cb);
announce->mcast_fd = sfd;
cfg->announce = announce;
}
-
diff --git a/minecproxy/idle.c b/minecproxy/idle.c
index 70d8099..ec9e2da 100644
--- a/minecproxy/idle.c
+++ b/minecproxy/idle.c
@@ -18,8 +18,8 @@ struct idle {
struct uring_task task;
};
-static int
-idle_check_handshake_complete(struct uring_task *task, _unused_ int res)
+static int idle_check_handshake_complete(struct uring_task *task,
+ _unused_ int res)
{
int r;
@@ -31,8 +31,7 @@ idle_check_handshake_complete(struct uring_task *task, _unused_ int res)
return r;
}
-static void
-idle_check_handshake_reply(struct uring_task *task, int res)
+static void idle_check_handshake_reply(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, idle_task);
unsigned online, max;
@@ -46,8 +45,7 @@ idle_check_handshake_reply(struct uring_task *task, int res)
goto out;
if (mc_protocol_parse_status_reply(server->idle_buf.buf,
- server->idle_buf.len,
- &online, &max))
+ server->idle_buf.len, &online, &max))
player_count = online;
else
error("failed to parse reply");
@@ -58,8 +56,7 @@ out:
return;
}
-static void
-idle_check_handshake_sent(struct uring_task *task, int res)
+static void idle_check_handshake_sent(struct uring_task *task, int res)
{
assert_return(task);
assert_task_alive(DBG_IDLE, task);
@@ -70,20 +67,17 @@ idle_check_handshake_sent(struct uring_task *task, int res)
return;
}
- uring_tbuf_read_until(task,
- idle_check_handshake_complete,
+ uring_tbuf_read_until(task, idle_check_handshake_complete,
idle_check_handshake_reply);
}
-void
-idle_check_get_player_count(struct server *server, struct connection *conn)
+void idle_check_get_player_count(struct server *server, struct connection *conn)
{
assert_return(server && conn && server->idle_task.priv);
- if (!mc_protocol_create_status_request(server->idle_buf.buf,
- sizeof(server->idle_buf.buf),
- &server->idle_buf.len,
- &conn->remote)) {
+ if (!mc_protocol_create_status_request(
+ server->idle_buf.buf, sizeof(server->idle_buf.buf),
+ &server->idle_buf.len, &conn->remote)) {
error("failed to create mc request");
/* FIXME: is this enough? */
return;
@@ -94,8 +88,7 @@ idle_check_get_player_count(struct server *server, struct connection *conn)
uring_tbuf_write(&server->idle_task, idle_check_handshake_sent);
}
-static void
-idle_cb(struct ptimer_task *ptask)
+static void idle_cb(struct ptimer_task *ptask)
{
struct idle *idle = container_of(ptask, struct idle, ptask);
struct server *server;
@@ -109,8 +102,7 @@ idle_cb(struct ptimer_task *ptask)
server_idle_check(server);
}
-static void
-idle_free(struct uring_task *task)
+static void idle_free(struct uring_task *task)
{
struct idle *idle = container_of(task, struct idle, task);
@@ -119,16 +111,14 @@ idle_free(struct uring_task *task)
xfree(idle);
}
-void
-idle_refdump()
+void idle_refdump()
{
assert_return_silent(cfg->idle);
uring_task_refdump(&cfg->idle->task);
}
-void
-idle_delete()
+void idle_delete()
{
assert_return(cfg->idle);
@@ -138,8 +128,7 @@ idle_delete()
cfg->idle = NULL;
}
-void
-idle_init()
+void idle_init()
{
struct idle *idle;
@@ -154,4 +143,3 @@ idle_init()
ptimer_add_task(&idle->ptask);
cfg->idle = idle;
}
-
diff --git a/minecproxy/igmp.c b/minecproxy/igmp.c
index f1d380d..f3579f4 100644
--- a/minecproxy/igmp.c
+++ b/minecproxy/igmp.c
@@ -345,7 +345,8 @@ igmp_parse(struct igmp *igmp)
body_len -= sizeof(*record);
pos += sizeof(*record);
- if (body_len < record->nsrcs * sizeof(uint32_t) + record->auxlen) {
+ if (body_len <
+ (record->nsrcs * sizeof(uint32_t) + record->auxlen)) {
error("IGMPv3 too short");
break;
}
@@ -364,10 +365,12 @@ igmp_parse(struct igmp *igmp)
}
/* Yes, EXCL, not INCL, see RFC3376 */
+ /* clang-format off */
if ((htonl(record->addr) == cinet_addr(224,0,2,60)) &&
((record->type == IGMP_V3_REC_MODE_IS_EXCL) ||
(record->type == IGMP_V3_REC_MODE_CH_EXCL)))
igmp_match();
+ /* clang-format on */
body_len -= record->auxlen;
pos += record->auxlen;
@@ -409,7 +412,7 @@ igmp_read_cb(struct uring_task *task, int res)
task->tbuf->len = res;
- if (task->saddr.storage.ss_family == AF_PACKET ||
+ if (task->saddr.st.ss_family == AF_PACKET ||
task->saddr.ll.sll_protocol == htons(ETH_P_IP))
igmp_parse(igmp);
else
@@ -450,46 +453,74 @@ void
igmp_init()
{
static const struct sock_filter filter[] = {
- BPF_STMT(BPF_LD + BPF_W + BPF_LEN, 0), /* A <- packet length */
- BPF_JUMP(BPF_JMP + BPF_JGE + BPF_K, sizeof(struct iphdr), 1, 0), /* A < sizeof(iphdr) */
- BPF_STMT(BPF_RET + BPF_K, 0), /* drop packet */
-
- BPF_STMT(BPF_LD + BPF_B + BPF_ABS, 0 /* iphdr[0] */), /* A <- version + ihl */
- BPF_STMT(BPF_ALU + BPF_RSH + BPF_K, 4), /* A <- A >> 4 (version) */
- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x04, 1, 0), /* A != 4 */
- BPF_STMT(BPF_RET + BPF_K, 0), /* drop packet */
-
- BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(struct iphdr, protocol)), /* A <- ip protocol */
- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_IGMP, 1, 0), /* A != IPPROTO_IGMP */
- BPF_STMT(BPF_RET + BPF_K, 0), /* drop packet */
-
- BPF_STMT(BPF_LD + BPF_W + BPF_ABS, offsetof(struct iphdr, daddr)), /* A <- ip dst addr */
- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, chtobe32(cinet_addr(224,0,2,60)), 2, 0), /* A != 224.0.2.60 */
- //BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0xe000023c, 2, 0), /* A != 224.0.2.60 */
- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, chtobe32(cinet_addr(224,0,0,22)), 1, 0), /* A != 224.0.0.22 */
- //BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0xe0000016, 1, 0), /* A != 224.0.0.22 */
- BPF_STMT(BPF_RET + BPF_K, 0), /* drop packet */
-
- BPF_STMT(BPF_LDX + BPF_B + BPF_MSH, 0 /* iphdr[0] */), /* X <- pkt->ihl * 4 */
- BPF_STMT(BPF_LD + BPF_IMM, 20), /* A <- 20 */
- BPF_JUMP(BPF_JMP + BPF_JGT + BPF_X, 0, 0, 1), /* A > X */
- BPF_STMT(BPF_RET + BPF_K, 0), /* drop packet */
-
- BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(struct iphdr, tot_len)), /* A <- ip tot_len */
- BPF_JUMP(BPF_JMP + BPF_JGT + BPF_X, 0, 1, 0), /* A <= ip->ihl * 4 */
- BPF_STMT(BPF_RET + BPF_K, 0), /* drop packet */
- BPF_STMT(BPF_ALU + BPF_SUB + BPF_X, 0), /* A <- A - X (bodylen) */
- BPF_JUMP(BPF_JMP + BPF_JGE + BPF_K, 8, 1, 0), /* A < 8 */
- BPF_STMT(BPF_RET + BPF_K, 0), /* drop packet */
-
- BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(struct iphdr, tot_len)), /* A <- ip->tot_len */
- BPF_STMT(BPF_MISC + BPF_TAX, 0), /* X <- A */
- BPF_STMT(BPF_LD + BPF_W + BPF_LEN, 0), /* A <- packet length */
- BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_X, 0, 1, 0), /* A != ip->tot_len */
- BPF_STMT(BPF_RET + BPF_K, 0), /* drop packet */
-
- BPF_STMT(BPF_RET + BPF_K, (uint32_t) -1), /* accept packet */
- };
+ /* A <- packet length */
+ BPF_STMT(BPF_LD + BPF_W + BPF_LEN, 0),
+ /* A < sizeof(iphdr) */
+ BPF_JUMP(BPF_JMP + BPF_JGE + BPF_K, sizeof(struct iphdr), 1, 0),
+ /* drop packet */
+ BPF_STMT(BPF_RET + BPF_K, 0),
+
+ /* A <- version + ihl */
+ BPF_STMT(BPF_LD + BPF_B + BPF_ABS, 0 /* iphdr[0] */),
+ /* A <- A >> 4 (version) */
+ BPF_STMT(BPF_ALU + BPF_RSH + BPF_K, 4),
+ /* A != 4 */
+ BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x04, 1, 0),
+ /* drop packet */
+ BPF_STMT(BPF_RET + BPF_K, 0),
+
+ /* A <- ip protocol */
+ BPF_STMT(BPF_LD + BPF_B + BPF_ABS, offsetof(struct iphdr, protocol)),
+ /* A != IPPROTO_IGMP */
+ BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_IGMP, 1, 0),
+ /* drop packet */
+ BPF_STMT(BPF_RET + BPF_K, 0),
+
+ /* A <- ip dst addr */
+ BPF_STMT(BPF_LD + BPF_W + BPF_ABS, offsetof(struct iphdr, daddr)),
+ /* A != 224.0.2.60 */
+ BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, chtobe32(cinet_addr(224,0,2,60)), 2, 0),
+ /* A != 224.0.0.22 */
+ BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, chtobe32(cinet_addr(224,0,0,22)), 1, 0),
+ /* drop packet */
+ BPF_STMT(BPF_RET + BPF_K, 0),
+
+ /* X <- pkt->ihl * 4 */
+ BPF_STMT(BPF_LDX + BPF_B + BPF_MSH, 0 /* iphdr[0] */),
+ /* A <- 20 */
+ BPF_STMT(BPF_LD + BPF_IMM, 20),
+ /* A > X */
+ BPF_JUMP(BPF_JMP + BPF_JGT + BPF_X, 0, 0, 1),
+ /* drop packet */
+ BPF_STMT(BPF_RET + BPF_K, 0),
+
+ /* A <- ip tot_len */
+ BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(struct iphdr, tot_len)),
+ /* A <= ip->ihl * 4 */
+ BPF_JUMP(BPF_JMP + BPF_JGT + BPF_X, 0, 1, 0),
+ /* drop packet */
+ BPF_STMT(BPF_RET + BPF_K, 0),
+ /* A <- A - X (bodylen) */
+ BPF_STMT(BPF_ALU + BPF_SUB + BPF_X, 0),
+ /* A < 8 */
+ BPF_JUMP(BPF_JMP + BPF_JGE + BPF_K, 8, 1, 0),
+ /* drop packet */
+ BPF_STMT(BPF_RET + BPF_K, 0),
+
+ /* A <- ip->tot_len */
+ BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(struct iphdr, tot_len)),
+ /* X <- A */
+ BPF_STMT(BPF_MISC + BPF_TAX, 0),
+ /* A <- packet length */
+ BPF_STMT(BPF_LD + BPF_W + BPF_LEN, 0),
+ /* A != ip->tot_len */
+ BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_X, 0, 1, 0),
+ /* drop packet */
+ BPF_STMT(BPF_RET + BPF_K, 0),
+
+ /* accept packet */
+ BPF_STMT(BPF_RET + BPF_K, (uint32_t) -1),
+ };
static const struct sock_fprog fprog = {
.len = ARRAY_SIZE(filter),
.filter = (struct sock_filter*) filter,
diff --git a/minecproxy/main.c b/minecproxy/main.c
index f5e6c88..b5a195b 100644
--- a/minecproxy/main.c
+++ b/minecproxy/main.c
@@ -38,8 +38,7 @@ static bool daemonize = false;
static FILE *log_file = NULL;
static const char *log_file_path = NULL;
-static void
-msg(enum debug_lvl lvl, const char *fmt, va_list ap)
+static void msg(enum debug_lvl lvl, const char *fmt, va_list ap)
{
static bool first = true;
static bool use_colors = false;
@@ -136,8 +135,7 @@ msg(enum debug_lvl lvl, const char *fmt, va_list ap)
fprintf(stderr, ANSI_NORMAL);
}
-void
-__debug(enum debug_lvl lvl, const char *fmt, ...)
+void __debug(enum debug_lvl lvl, const char *fmt, ...)
{
va_list ap;
@@ -148,8 +146,7 @@ __debug(enum debug_lvl lvl, const char *fmt, ...)
va_end(ap);
}
-_noreturn_ void
-__die(const char *fmt, ...)
+_noreturn_ void __die(const char *fmt, ...)
{
va_list ap;
@@ -164,8 +161,7 @@ __die(const char *fmt, ...)
exit(EXIT_FAILURE);
}
-static void
-cfg_free(struct uring_task *task)
+static void cfg_free(struct uring_task *task)
{
struct cfg *xcfg = container_of(task, struct cfg, task);
@@ -198,51 +194,60 @@ struct cfg_key_value_map mcfg_key_map[] = {
.key_name = "igmp",
.key_value = MCFG_KEY_IGMP,
.value_type = CFG_VAL_TYPE_BOOL,
- }, {
+ },
+ {
.key_name = "igmp_iface",
.key_value = MCFG_KEY_IGMP_IFACE,
.value_type = CFG_VAL_TYPE_STRING,
- }, {
+ },
+ {
.key_name = "announce_interval",
.key_value = MCFG_KEY_ANN_INTERVAL,
.value_type = CFG_VAL_TYPE_UINT16,
- }, {
+ },
+ {
.key_name = "proxy_connection_interval",
.key_value = MCFG_KEY_PROXY_CONN_INTERVAL,
.value_type = CFG_VAL_TYPE_UINT16,
- }, {
+ },
+ {
.key_name = "proxy_connection_attempts",
.key_value = MCFG_KEY_PROXY_CONN_ATTEMPTS,
.value_type = CFG_VAL_TYPE_UINT16,
- }, {
+ },
+ {
.key_name = "socket_defer",
.key_value = MCFG_KEY_SOCKET_DEFER,
.value_type = CFG_VAL_TYPE_BOOL,
- }, {
+ },
+ {
.key_name = "socket_freebind",
.key_value = MCFG_KEY_SOCKET_FREEBIND,
.value_type = CFG_VAL_TYPE_BOOL,
- }, {
+ },
+ {
.key_name = "socket_keepalive",
.key_value = MCFG_KEY_SOCKET_KEEPALIVE,
.value_type = CFG_VAL_TYPE_BOOL,
- }, {
+ },
+ {
.key_name = "socket_iptos",
.key_value = MCFG_KEY_SOCKET_IPTOS,
.value_type = CFG_VAL_TYPE_BOOL,
- }, {
+ },
+ {
.key_name = "socket_nodelay",
.key_value = MCFG_KEY_SOCKET_NODELAY,
.value_type = CFG_VAL_TYPE_BOOL,
- }, {
+ },
+ {
.key_name = NULL,
.key_value = MCFG_KEY_INVALID,
.value_type = CFG_VAL_TYPE_INVALID,
}
};
-static void
-cfg_read()
+static void cfg_read()
{
FILE *cfgfile;
const char *path;
@@ -297,8 +302,8 @@ cfg_read()
const char *keyname;
struct cfg_value value;
- if (!config_parse_line(path, &pos, mcfg_key_map,
- &key, &keyname, &value, false))
+ if (!config_parse_line(path, &pos, mcfg_key_map, &key, &keyname,
+ &value, false))
break;
if (key == MCFG_KEY_INVALID)
@@ -307,7 +312,6 @@ cfg_read()
debug(DBG_CFG, "main cfg: key %s", keyname);
switch (key) {
-
case MCFG_KEY_IGMP:
cfg->do_igmp = value.boolean;
break;
@@ -358,6 +362,7 @@ cfg_read()
}
}
+/* clang-format off */
const struct {
const char *name;
unsigned val;
@@ -409,9 +414,9 @@ const struct {
.val = 0,
}
};
+/* clang-format on */
-_noreturn_ static void
-usage(bool invalid)
+_noreturn_ static void usage(bool invalid)
{
if (invalid)
info("Invalid option(s)");
@@ -434,8 +439,7 @@ usage(bool invalid)
exit(invalid ? EXIT_FAILURE : EXIT_SUCCESS);
}
-static void
-cfg_init(int argc, char **argv)
+static void cfg_init(int argc, char **argv)
{
int c;
unsigned i;
@@ -463,6 +467,7 @@ cfg_init(int argc, char **argv)
while (true) {
int option_index = 0;
+ /* clang-format off */
static struct option long_options[] = {
{ "cfgdir", required_argument, 0, 'c' },
{ "cfgfile", required_argument, 0, 'C' },
@@ -474,9 +479,10 @@ cfg_init(int argc, char **argv)
{ "debug", required_argument, 0, 'd' },
{ 0, 0, 0, 0 }
};
+ /* clang-format on */
- c = getopt_long(argc, argv, ":c:C:u:Dl:hvd:",
- long_options, &option_index);
+ c = getopt_long(argc, argv, ":c:C:u:Dl:hvd:", long_options,
+ &option_index);
if (c == -1)
break;
@@ -512,12 +518,12 @@ cfg_init(int argc, char **argv)
if (errno == ESRCH)
die("failed to find user %s", optarg);
else
- die("failed to find user %s (%m)", optarg);
+ die("failed to find user %s (%m)",
+ optarg);
}
debug(DBG_CFG, "asked to execute with uid %ji gid %ji",
- (intmax_t)pwd->pw_uid,
- (intmax_t)pwd->pw_gid);
+ (intmax_t)pwd->pw_uid, (intmax_t)pwd->pw_gid);
cfg->uid = pwd->pw_uid;
cfg->gid = pwd->pw_gid;
break;
@@ -531,12 +537,14 @@ cfg_init(int argc, char **argv)
info("Debug categories:");
info(" * all");
for (i = 0; debug_category_str[i].name; i++)
- info(" * %s", debug_category_str[i].name);
+ info(" * %s",
+ debug_category_str[i].name);
exit(EXIT_FAILURE);
}
for (i = 0; debug_category_str[i].name; i++) {
- if (strcaseeq(optarg, debug_category_str[i].name))
+ if (strcaseeq(optarg,
+ debug_category_str[i].name))
break;
}
@@ -553,29 +561,25 @@ cfg_init(int argc, char **argv)
default:
usage(true);
}
-
}
if (optind < argc)
usage(true);
}
-static void
-cfg_apply()
+static void cfg_apply()
{
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>)");
capng_clear(CAPNG_SELECT_BOTH);
- if (capng_updatev(CAPNG_ADD,
- CAPNG_EFFECTIVE | CAPNG_PERMITTED,
+ if (capng_updatev(CAPNG_ADD, CAPNG_EFFECTIVE | CAPNG_PERMITTED,
CAP_NET_RAW, CAP_NET_BIND_SERVICE, -1))
die("capng_updatev failed");
if (geteuid() != cfg->uid) {
- if (capng_change_id(cfg->uid,
- cfg->gid,
+ if (capng_change_id(cfg->uid, cfg->gid,
CAPNG_DROP_SUPP_GRP | CAPNG_CLEAR_BOUNDING))
die("capng_change_id failed");
} else {
@@ -614,8 +618,7 @@ cfg_apply()
}
}
-void
-dump_tree()
+void dump_tree()
{
struct server *server;
@@ -639,8 +642,7 @@ dump_tree()
info("\n\n");
}
-int
-main(int argc, char **argv)
+int main(int argc, char **argv)
{
struct server *server;
unsigned server_count;
@@ -679,8 +681,7 @@ main(int argc, char **argv)
/* Drop CAP_NET_RAW (if we have it), only used for igmp */
capng_clear(CAPNG_SELECT_BOTH);
- if (capng_update(CAPNG_ADD,
- CAPNG_EFFECTIVE | CAPNG_PERMITTED,
+ if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE | CAPNG_PERMITTED,
CAP_NET_BIND_SERVICE))
die("capng_update failed");
@@ -708,14 +709,14 @@ main(int argc, char **argv)
list_for_each_entry(server, &cfg->servers, list)
server_count++;
- sd_notifyf(0, "READY=1\n"
+ sd_notifyf(0,
+ "READY=1\n"
"STATUS=Running, %u server configurations loaded\n"
"MAINPID=%lu",
- server_count,
- (unsigned long)getpid());
+ server_count, (unsigned long)getpid());
- info("mcproxy (%s) started, %u server configurations loaded",
- VERSION, server_count);
+ info("mcproxy (%s) started, %u server configurations loaded", VERSION,
+ server_count);
uring_event_loop();
diff --git a/minecproxy/main.h b/minecproxy/main.h
index 8c8add0..c46169a 100644
--- a/minecproxy/main.h
+++ b/minecproxy/main.h
@@ -62,7 +62,7 @@ struct uring_task {
utask_cb_t cb;
/* returns: 0 = not complete; < 0 = error; > 0 = complete */
- rutask_cb_t is_complete_cb;
+ rutask_cb_t is_complete_cb;
/* called once tbuf processing is done */
utask_cb_t final_cb;
diff --git a/minecproxy/misc.c b/minecproxy/misc.c
index 152de1a..e3872c5 100644
--- a/minecproxy/misc.c
+++ b/minecproxy/misc.c
@@ -31,12 +31,14 @@ struct allocation {
struct list_head list;
};
-static void
-add_allocation(const char *allocfn, const char *callerfn, int line, void *ptr, size_t size)
+static void add_allocation(const char *allocfn, const char *callerfn, int line,
+ void *ptr, size_t size)
{
struct allocation *a;
- assert_die(!empty_str(allocfn) && !empty_str(callerfn) && line > 0 && ptr && size > 0, "invalid arguments");
+ assert_die(!empty_str(allocfn) && !empty_str(callerfn) && line > 0 &&
+ ptr && size > 0,
+ "invalid arguments");
a = malloc(sizeof(*a));
if (!a)
@@ -49,12 +51,11 @@ add_allocation(const char *allocfn, const char *callerfn, int line, void *ptr, s
list_add(&a->list, &malloc_list);
total_malloc_count++;
malloc_count++;
- debug(DBG_MALLOC, "called from %s:%i - %s(%zu) = %p (%p)",
- callerfn, line, allocfn, size, ptr, a);
+ debug(DBG_MALLOC, "called from %s:%i - %s(%zu) = %p (%p)", callerfn,
+ line, allocfn, size, ptr, a);
}
-void *
-__zmalloc(const char *fn, int line, size_t size)
+void *__zmalloc(const char *fn, int line, size_t size)
{
void *ptr;
@@ -66,12 +67,12 @@ __zmalloc(const char *fn, int line, size_t size)
return ptr;
}
-char *
-__xstrdup(const char *fn, int line, const char *s)
+char *__xstrdup(const char *fn, int line, const char *s)
{
char *ptr;
- assert_die(!empty_str(fn) && line > 0 && !empty_str(s), "invalid arguments");
+ assert_die(!empty_str(fn) && line > 0 && !empty_str(s),
+ "invalid arguments");
ptr = strdup(s);
if (ptr)
@@ -79,12 +80,12 @@ __xstrdup(const char *fn, int line, const char *s)
return ptr;
}
-char *
-__xstrndup(const char *fn, int line, const char *s, size_t n)
+char *__xstrndup(const char *fn, int line, const char *s, size_t n)
{
char *ptr;
- assert_die(!empty_str(fn) && line > 0 && !empty_str(s) && n > 0, "invalid arguments");
+ assert_die(!empty_str(fn) && line > 0 && !empty_str(s) && n > 0,
+ "invalid arguments");
ptr = strndup(s, n);
if (ptr)
@@ -92,8 +93,7 @@ __xstrndup(const char *fn, int line, const char *s, size_t n)
return ptr;
}
-void
-__xfree(const char *fn, int line, void *ptr)
+void __xfree(const char *fn, int line, void *ptr)
{
struct allocation *a, *tmp;
unsigned delete_count = 0;
@@ -121,8 +121,7 @@ __xfree(const char *fn, int line, void *ptr)
}
}
-void
-debug_resource_usage()
+void debug_resource_usage()
{
struct allocation *a;
DIR *dir;
@@ -131,11 +130,12 @@ debug_resource_usage()
ssize_t r;
unsigned file_count = 0;
- debug(DBG_MALLOC, "Still malloced %i (total %u)",
- malloc_count, total_malloc_count);
+ debug(DBG_MALLOC, "Still malloced %i (total %u)", malloc_count,
+ total_malloc_count);
list_for_each_entry(a, &malloc_list, list) {
- debug(DBG_MALLOC, "* Lost allocation - %s:%i - ptr: %p, size: %zu",
+ debug(DBG_MALLOC,
+ "* Lost allocation - %s:%i - ptr: %p, size: %zu",
a->callerfn, a->line, a->ptr, a->size);
}
@@ -152,7 +152,8 @@ debug_resource_usage()
r = readlinkat(dirfd(dir), dent->d_name, buf, sizeof(buf));
if (r < 0) {
- debug(DBG_MALLOC, "Failed to readlink %s", dent->d_name);
+ debug(DBG_MALLOC, "Failed to readlink %s",
+ dent->d_name);
continue;
}
buf[r] = '\0';
@@ -168,21 +169,19 @@ debug_resource_usage()
cqe_count, sqe_count);
}
-void
-connection_set_local(struct connection *conn, int fd)
+void connection_set_local(struct connection *conn, int fd)
{
assert_return(conn && fd >= 0);
- conn->local.addrlen = sizeof(conn->local.storage);
- if (getsockname(fd, (struct sockaddr *)&conn->local.storage,
+ conn->local.addrlen = sizeof(conn->local.st);
+ if (getsockname(fd, (struct sockaddr *)&conn->local.st,
&conn->local.addrlen) < 0)
sprintf(conn->local.addrstr, "<unknown>");
else
saddr_set_addrstr(&conn->local);
}
-void
-connection_set_remote(struct connection *conn, struct saddr *remote)
+void connection_set_remote(struct connection *conn, struct saddr *remote)
{
assert_return(conn && remote);
@@ -192,8 +191,7 @@ connection_set_remote(struct connection *conn, struct saddr *remote)
static void connect_next(struct uring_task *task, struct connection *conn);
-static void
-connect_cb(struct uring_task *task, int res)
+static void connect_cb(struct uring_task *task, int res)
{
struct connection *conn;
@@ -201,8 +199,8 @@ connect_cb(struct uring_task *task, int res)
conn = task->priv;
if (res < 0) {
- debug(DBG_SRV, "%s: connection to %s failed",
- task->name, conn->remote.addrstr);
+ debug(DBG_SRV, "%s: connection to %s failed", task->name,
+ conn->remote.addrstr);
uring_task_close_fd(task);
connect_next(task, conn);
return;
@@ -210,66 +208,63 @@ connect_cb(struct uring_task *task, int res)
connection_set_local(conn, task->fd);
- debug(DBG_SRV, "%s: connection established %s -> %s",
- task->name, conn->local.addrstr, conn->remote.addrstr);
+ debug(DBG_SRV, "%s: connection established %s -> %s", task->name,
+ conn->local.addrstr, conn->remote.addrstr);
conn->cb(conn, true);
}
-static void
-connect_next(struct uring_task *task, struct connection *conn)
+static void connect_next(struct uring_task *task, struct connection *conn)
{
- struct saddr *remote, *tmp;
- int sfd;
- unsigned i;
+ struct saddr *remote, *tmp;
+ int sfd;
+ unsigned i;
assert_return(task && conn && conn->cb);
again:
assert_task_alive_or(DBG_UR, task, goto out);
i = 0;
- remote = NULL;
- list_for_each_entry(tmp, conn->addrs, list) {
- if (i == conn->next_addr) {
- remote = tmp;
- break;
- }
- i++;
- }
-
- if (!remote) {
+ remote = NULL;
+ list_for_each_entry(tmp, conn->addrs, list) {
+ if (i == conn->next_addr) {
+ remote = tmp;
+ break;
+ }
+ i++;
+ }
+
+ if (!remote) {
debug(DBG_SRV, "%s: no more remote addresses to attempt",
task->name);
goto out;
- }
+ }
conn->next_addr++;
connection_set_remote(conn, remote);
- debug(DBG_SRV, "%s: attempting to connect to %s",
- task->name, conn->remote.addrstr);
+ debug(DBG_SRV, "%s: attempting to connect to %s", task->name,
+ conn->remote.addrstr);
- sfd = socket(conn->remote.storage.ss_family, SOCK_STREAM | SOCK_CLOEXEC, 0);
- if (sfd < 0) {
- debug(DBG_SRV, "socket: %m");
- goto again;
- }
+ sfd = socket(conn->remote.st.ss_family, SOCK_STREAM | SOCK_CLOEXEC, 0);
+ if (sfd < 0) {
+ debug(DBG_SRV, "socket: %m");
+ goto again;
+ }
- socket_set_low_latency(sfd, cfg->socket_keepalive,
- cfg->socket_iptos, cfg->socket_nodelay);
+ socket_set_low_latency(sfd, cfg->socket_keepalive, cfg->socket_iptos,
+ cfg->socket_nodelay);
task->priv = conn;
- uring_task_set_fd(task, sfd);
- uring_connect(task, &conn->remote, connect_cb);
+ uring_task_set_fd(task, sfd);
+ uring_connect(task, &conn->remote, connect_cb);
return;
out:
conn->cb(conn, false);
}
-void
-connect_any(struct uring_task *task,
- struct list_head *addrs, struct connection *conn,
- connection_cb_t cb)
+void connect_any(struct uring_task *task, struct list_head *addrs,
+ struct connection *conn, connection_cb_t cb)
{
assert_return(task && addrs && conn && cb);
@@ -278,4 +273,3 @@ connect_any(struct uring_task *task,
conn->cb = cb;
connect_next(task, conn);
}
-
diff --git a/minecproxy/misc.h b/minecproxy/misc.h
index 6627913..70b84c7 100644
--- a/minecproxy/misc.h
+++ b/minecproxy/misc.h
@@ -13,7 +13,7 @@ void debug_resource_usage();
struct connection;
-typedef void(*connection_cb_t)(struct connection *, bool);
+typedef void (*connection_cb_t)(struct connection *, bool);
struct connection {
struct saddr remote;
@@ -29,8 +29,7 @@ void connection_set_local(struct connection *conn, int fd);
void connection_set_remote(struct connection *conn, struct saddr *remote);
-void connect_any(struct uring_task *task,
- struct list_head *addrs, struct connection *conn,
- connection_cb_t cb);
+void connect_any(struct uring_task *task, struct list_head *addrs,
+ struct connection *conn, connection_cb_t cb);
#endif
diff --git a/minecproxy/ptimer.c b/minecproxy/ptimer.c
index 845fbfa..6ed405d 100644
--- a/minecproxy/ptimer.c
+++ b/minecproxy/ptimer.c
@@ -16,18 +16,11 @@ struct ptimer {
struct list_head ptasks;
};
-static void
-ptimer_set(unsigned value, unsigned interval)
+static void ptimer_set(unsigned value, unsigned interval)
{
struct itimerspec tspec = {
- .it_interval = {
- .tv_sec = interval,
- .tv_nsec = 0
- },
- .it_value = {
- .tv_sec = value,
- .tv_nsec = 0
- }
+ .it_interval = { .tv_sec = interval, .tv_nsec = 0 },
+ .it_value = { .tv_sec = value, .tv_nsec = 0 }
};
assert_return(cfg->ptimer && cfg->ptimer->task.fd >= 0);
@@ -36,16 +29,14 @@ ptimer_set(unsigned value, unsigned interval)
error("timerfd_settime: %m");
}
-static unsigned
-gcd(unsigned a, unsigned b)
+static unsigned gcd(unsigned a, unsigned b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
-static unsigned
-array_gcd(unsigned arr[], unsigned n)
+static unsigned array_gcd(unsigned arr[], unsigned n)
{
unsigned result = arr[0];
@@ -55,8 +46,7 @@ array_gcd(unsigned arr[], unsigned n)
return result;
}
-static void
-ptimer_tick(struct ptimer *ptimer)
+static void ptimer_tick(struct ptimer *ptimer)
{
time_t now = time(NULL);
unsigned diff = (unsigned)(now - ptimer->previous_time);
@@ -69,8 +59,8 @@ ptimer_tick(struct ptimer *ptimer)
continue;
}
- debug(DBG_TIMER, "triggering ptask %p (times %u)",
- ptask, ptask->times);
+ debug(DBG_TIMER, "triggering ptask %p (times %u)", ptask,
+ ptask->times);
ptask->cb(ptask);
ptask->remain = ptask->interval;
@@ -88,8 +78,7 @@ ptimer_tick(struct ptimer *ptimer)
ptimer->previous_time = now;
}
-static void
-ptimer_reconfig(struct ptimer *ptimer)
+static void ptimer_reconfig(struct ptimer *ptimer)
{
struct ptimer_task *ptask;
unsigned i = 0;
@@ -116,8 +105,7 @@ ptimer_reconfig(struct ptimer *ptimer)
ptimer_set(lowest, interval);
}
-void
-ptimer_del_task(struct ptimer_task *ptask)
+void ptimer_del_task(struct ptimer_task *ptask)
{
struct ptimer *ptimer = cfg->ptimer;
@@ -133,8 +121,7 @@ ptimer_del_task(struct ptimer_task *ptask)
uring_task_put(&ptimer->task);
}
-void
-ptimer_add_task(struct ptimer_task *ptask)
+void ptimer_add_task(struct ptimer_task *ptask)
{
struct ptimer *ptimer = cfg->ptimer;
@@ -150,16 +137,14 @@ ptimer_add_task(struct ptimer_task *ptask)
ptimer_reconfig(ptimer);
}
-void
-ptimer_refdump()
+void ptimer_refdump()
{
assert_return(cfg->ptimer);
uring_task_refdump(&cfg->ptimer->task);
}
-static void
-ptimer_free(struct uring_task *task)
+static void ptimer_free(struct uring_task *task)
{
struct ptimer *ptimer = container_of(task, struct ptimer, task);
@@ -170,8 +155,7 @@ ptimer_free(struct uring_task *task)
cfg->ptimer = NULL;
}
-void
-ptimer_delete()
+void ptimer_delete()
{
assert_return(cfg->ptimer);
@@ -179,8 +163,7 @@ ptimer_delete()
uring_task_destroy(&cfg->ptimer->task);
}
-static void
-ptimer_cb(struct uring_task *task, int res)
+static void ptimer_cb(struct uring_task *task, int res)
{
struct ptimer *ptimer = container_of(task, struct ptimer, task);
@@ -193,15 +176,15 @@ ptimer_cb(struct uring_task *task, int res)
}
ptimer_tick(ptimer);
- uring_read(&ptimer->task, &ptimer->value, sizeof(ptimer->value), ptimer_cb);
+ uring_read(&ptimer->task, &ptimer->value, sizeof(ptimer->value),
+ ptimer_cb);
}
-void
-ptimer_init()
+void ptimer_init()
{
struct ptimer *ptimer;
int tfd;
-
+
assert_return(!cfg->ptimer);
ptimer = zmalloc(sizeof(*ptimer));
@@ -218,6 +201,6 @@ ptimer_init()
uring_task_init(&ptimer->task, "ptimer", uring_parent(), ptimer_free);
uring_task_set_fd(&ptimer->task, tfd);
cfg->ptimer = ptimer;
- uring_read(&ptimer->task, &ptimer->value, sizeof(ptimer->value), ptimer_cb);
+ uring_read(&ptimer->task, &ptimer->value, sizeof(ptimer->value),
+ ptimer_cb);
}
-
diff --git a/minecproxy/ptimer.h b/minecproxy/ptimer.h
index 0b53590..3481ba4 100644
--- a/minecproxy/ptimer.h
+++ b/minecproxy/ptimer.h
@@ -10,9 +10,8 @@ struct ptimer_task {
struct list_head list;
};
-static inline void
-ptask_init(struct ptimer_task *ptask, unsigned interval,
- unsigned times, void(*cb)(struct ptimer_task *))
+static inline void ptask_init(struct ptimer_task *ptask, unsigned interval,
+ unsigned times, void (*cb)(struct ptimer_task *))
{
ptask->interval = interval;
ptask->times = times;
diff --git a/minecproxy/server-config.c b/minecproxy/server-config.c
index 92990d3..71463ee 100644
--- a/minecproxy/server-config.c
+++ b/minecproxy/server-config.c
@@ -16,8 +16,8 @@
#include "server-config.h"
#include "server-config-options.h"
-static void
-scfg_dns_cb(struct dns_async *dns, bool (*server_cb)(struct server *, struct saddr *))
+static void scfg_dns_cb(struct dns_async *dns,
+ bool (*server_cb)(struct server *, struct saddr *))
{
struct server *server;
struct sockaddr_in *in4;
@@ -29,8 +29,9 @@ scfg_dns_cb(struct dns_async *dns, bool (*server_cb)(struct server *, struct sad
assert_return(dns && dns->priv && server_cb);
server = dns->priv;
- debug(DBG_DNS, "called, dns: %p, name: %s, server: %p, server->name: %s",
- dns, dns->name, server, server->name);
+ debug(DBG_DNS,
+ "called, dns: %p, name: %s, server: %p, server->name: %s", dns,
+ dns->name, server, server->name);
r = gai_error(&dns->gcb);
if (r == EAI_INPROGRESS) {
@@ -41,8 +42,8 @@ scfg_dns_cb(struct dns_async *dns, bool (*server_cb)(struct server *, struct sad
/* The server must be in the process of going away */
goto out;
} else if (r < 0) {
- error("DNS lookup of %s:%s failed: %s",
- dns->name, dns->port, gai_strerror(r));
+ error("DNS lookup of %s:%s failed: %s", dns->name, dns->port,
+ gai_strerror(r));
goto out;
}
@@ -51,14 +52,16 @@ scfg_dns_cb(struct dns_async *dns, bool (*server_cb)(struct server *, struct sad
for (ai = results; ai; ai = ai->ai_next) {
saddr = zmalloc(sizeof(*saddr));
if (!saddr) {
- error("DNS lookup of %s:%s failed: %m", dns->name, dns->port);
+ error("DNS lookup of %s:%s failed: %m", dns->name,
+ dns->port);
goto out;
}
switch (ai->ai_family) {
case AF_INET:
in4 = (struct sockaddr_in *)ai->ai_addr;
- saddr_set_ipv4(saddr, in4->sin_addr.s_addr, in4->sin_port);
+ saddr_set_ipv4(saddr, in4->sin_addr.s_addr,
+ in4->sin_port);
server_cb(server, saddr);
break;
@@ -84,34 +87,30 @@ out:
server_commit(server);
}
-static void
-scfg_local_dns_cb(struct dns_async *dns)
+static void scfg_local_dns_cb(struct dns_async *dns)
{
assert_return(dns);
scfg_dns_cb(dns, server_add_local);
}
-static void
-scfg_remote_dns_cb(struct dns_async *dns)
+static void scfg_remote_dns_cb(struct dns_async *dns)
{
assert_return(dns);
scfg_dns_cb(dns, server_add_remote);
}
-static void
-scfg_rcon_dns_cb(struct dns_async *dns)
+static void scfg_rcon_dns_cb(struct dns_async *dns)
{
assert_return(dns);
scfg_dns_cb(dns, server_add_rcon);
}
-static bool
-handle_dns(struct server *server, const char *type,
- struct cfg_value *value, dns_cb_t *async_cb,
- bool (*sync_cb)(struct server *, struct saddr *))
+static bool handle_dns(struct server *server, const char *type,
+ struct cfg_value *value, dns_cb_t *async_cb,
+ bool (*sync_cb)(struct server *, struct saddr *))
{
struct saddr *saddr, *tmp;
struct dns_async *dns;
@@ -129,8 +128,8 @@ handle_dns(struct server *server, const char *type,
return true;
case CFG_VAL_TYPE_ASYNC_ADDRS:
- debug(DBG_DNS, "%s: doing async lookup of DNS record: %p",
- type, value->dns_async);
+ debug(DBG_DNS, "%s: doing async lookup of DNS record: %p", type,
+ value->dns_async);
dns = value->dns_async;
dns->cb = async_cb;
@@ -144,8 +143,7 @@ handle_dns(struct server *server, const char *type,
}
}
-static void
-scfg_parse(struct server *server)
+static void scfg_parse(struct server *server)
{
char *pos;
@@ -163,8 +161,8 @@ scfg_parse(struct server *server)
const char *keyname;
struct cfg_value value;
- if (!config_parse_line(server->name, &pos, scfg_key_map,
- &key, &keyname, &value, true))
+ if (!config_parse_line(server->name, &pos, scfg_key_map, &key,
+ &keyname, &value, true))
break;
if (key == SCFG_KEY_INVALID)
@@ -173,13 +171,13 @@ scfg_parse(struct server *server)
debug(DBG_CFG, "%s: key %s", server->name, keyname);
switch (key) {
-
case SCFG_KEY_TYPE:
if (streq(value.str, "proxy")) {
if (!server_set_type(server, SERVER_TYPE_PROXY))
return;
} else if (streq(value.str, "announce")) {
- if (!server_set_type(server, SERVER_TYPE_ANNOUNCE))
+ if (!server_set_type(server,
+ SERVER_TYPE_ANNOUNCE))
return;
}
break;
@@ -213,23 +211,29 @@ scfg_parse(struct server *server)
case SCFG_KEY_STOP_METHOD:
if (streq(value.str, "exec")) {
- if (server_set_stop_method(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(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(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(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(server, SERVER_START_METHOD_SYSTEMD))
+ if (server_set_start_method(
+ server,
+ SERVER_START_METHOD_SYSTEMD))
break;
}
return;
@@ -267,8 +271,7 @@ scfg_parse(struct server *server)
}
}
-static void
-scfg_read_cb(struct uring_task *task, int res)
+static void scfg_read_cb(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, task);
@@ -276,8 +279,8 @@ scfg_read_cb(struct uring_task *task, int res)
assert_task_alive(DBG_CFG, task);
if (res <= 0) {
- error("error reading config file for %s: %s",
- server->name, strerror(-res));
+ error("error reading config file for %s: %s", server->name,
+ strerror(-res));
server_delete(server);
}
@@ -287,8 +290,7 @@ scfg_read_cb(struct uring_task *task, int res)
server_commit(server);
}
-static void
-scfg_open_cb(struct uring_task *task, int res)
+static void scfg_open_cb(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, task);
@@ -311,12 +313,10 @@ struct server_cfg_monitor {
char buf[4096] _alignas_(struct inotify_event);
};
-static void
-scfgm_free(struct uring_task *task)
+static void scfgm_free(struct uring_task *task)
{
- struct server_cfg_monitor *scfgm = container_of(task,
- struct server_cfg_monitor,
- task);
+ struct server_cfg_monitor *scfgm =
+ container_of(task, struct server_cfg_monitor, task);
assert_return(task);
@@ -325,8 +325,7 @@ scfgm_free(struct uring_task *task)
cfg->server_cfg_monitor = NULL;
}
-static void
-inotify_event_dump(const struct inotify_event *event)
+static void inotify_event_dump(const struct inotify_event *event)
{
assert_return(event);
@@ -338,42 +337,40 @@ inotify_event_dump(const struct inotify_event *event)
debug(DBG_CFG, " * Mask : %" PRIu32, event->mask);
if (event->mask & IN_ACCESS)
debug(DBG_CFG, "\tIN_ACCESS");
- else if(event->mask & IN_MODIFY)
+ else if (event->mask & IN_MODIFY)
debug(DBG_CFG, "\tIN_MODIFY");
- else if(event->mask & IN_ATTRIB)
+ else if (event->mask & IN_ATTRIB)
debug(DBG_CFG, "\tIN_ATTRIB");
- else if(event->mask & IN_CLOSE_WRITE)
+ else if (event->mask & IN_CLOSE_WRITE)
debug(DBG_CFG, "\tIN_CLOSE_WRITE");
- else if(event->mask & IN_CLOSE_NOWRITE)
+ else if (event->mask & IN_CLOSE_NOWRITE)
debug(DBG_CFG, "\tIN_CLOSE_NOWRITE");
- else if(event->mask & IN_OPEN)
+ else if (event->mask & IN_OPEN)
debug(DBG_CFG, "\tIN_OPEN");
- else if(event->mask & IN_MOVED_FROM)
+ else if (event->mask & IN_MOVED_FROM)
debug(DBG_CFG, "\tIN_MOVED_FROM");
- else if(event->mask & IN_MOVED_TO)
+ else if (event->mask & IN_MOVED_TO)
debug(DBG_CFG, "\tIN_MOVED_TO");
- else if(event->mask & IN_CREATE)
+ else if (event->mask & IN_CREATE)
debug(DBG_CFG, "\tIN_CREATE");
- else if(event->mask & IN_DELETE)
+ else if (event->mask & IN_DELETE)
debug(DBG_CFG, "\tIN_DELETE");
- else if(event->mask & IN_DELETE_SELF)
+ else if (event->mask & IN_DELETE_SELF)
debug(DBG_CFG, "\tIN_DELETE_SELF");
- else if(event->mask & IN_MOVE_SELF)
+ else if (event->mask & IN_MOVE_SELF)
debug(DBG_CFG, "\tIN_MOVE_SELF");
- else if(event->mask & IN_UNMOUNT)
+ else if (event->mask & IN_UNMOUNT)
debug(DBG_CFG, "\tIN_UNMOUNT");
- else if(event->mask & IN_Q_OVERFLOW)
+ else if (event->mask & IN_Q_OVERFLOW)
debug(DBG_CFG, "\tIN_Q_OVERFLOW");
- else if(event->mask & IN_IGNORED)
+ else if (event->mask & IN_IGNORED)
debug(DBG_CFG, "\tIN_IGNORED");
}
-static void
-inotify_cb(struct uring_task *task, int res)
+static void inotify_cb(struct uring_task *task, int res)
{
- struct server_cfg_monitor *scfgm = container_of(task,
- struct server_cfg_monitor,
- task);
+ struct server_cfg_monitor *scfgm =
+ container_of(task, struct server_cfg_monitor, task);
const struct inotify_event *event;
char *ptr;
struct server *server;
@@ -386,13 +383,15 @@ inotify_cb(struct uring_task *task, int res)
return;
}
- for (ptr = scfgm->buf; ptr < scfgm->buf + res; ptr += sizeof(struct inotify_event) + event->len) {
+ for (ptr = scfgm->buf; ptr < scfgm->buf + res;
+ ptr += sizeof(struct inotify_event) + event->len) {
event = (const struct inotify_event *)ptr;
if (debug_enabled(DBG_CFG))
inotify_event_dump(event);
- if (event->mask & (IN_IGNORED | IN_MOVE_SELF | IN_DELETE_SELF | IN_UNMOUNT))
+ if (event->mask &
+ (IN_IGNORED | IN_MOVE_SELF | IN_DELETE_SELF | IN_UNMOUNT))
die("configuration directory gone, exiting");
if (event->mask & IN_Q_OVERFLOW) {
@@ -405,9 +404,11 @@ inotify_cb(struct uring_task *task, int res)
if (event->mask & (IN_MOVED_FROM | IN_DELETE))
server_delete_by_name(event->name);
- else if (event->mask & (IN_MOVED_TO | IN_CREATE | IN_CLOSE_WRITE)) {
+ else if (event->mask &
+ (IN_MOVED_TO | IN_CREATE | IN_CLOSE_WRITE)) {
server = server_new(event->name);
- verbose("New server config file detected: %s", server->name);
+ verbose("New server config file detected: %s",
+ server->name);
uring_openat(&server->task, server->name, scfg_open_cb);
} else
error("inotify: unknown event: 0x%08x", event->mask);
@@ -416,16 +417,14 @@ inotify_cb(struct uring_task *task, int res)
uring_read(&scfgm->task, scfgm->buf, sizeof(scfgm->buf), inotify_cb);
}
-void
-server_cfg_monitor_refdump()
+void server_cfg_monitor_refdump()
{
assert_return_silent(cfg->server_cfg_monitor);
uring_task_refdump(&cfg->server_cfg_monitor->task);
}
-void
-server_cfg_monitor_delete()
+void server_cfg_monitor_delete()
{
assert_return(cfg->server_cfg_monitor);
@@ -434,8 +433,7 @@ server_cfg_monitor_delete()
cfg->server_cfg_monitor = NULL;
}
-void
-server_cfg_monitor_init()
+void server_cfg_monitor_init()
{
int ifd;
int iwd;
@@ -455,15 +453,16 @@ server_cfg_monitor_init()
die("inotify_init1: %m");
/* ln = IN_CREATE, cp/vi/mv = IN_CREATE, IN_OPEN, IN_CLOSE_WRITE */
- iwd = inotify_add_watch(ifd, ".",
- IN_CLOSE_WRITE | IN_DELETE | IN_CREATE |
- IN_DELETE_SELF | IN_MOVE_SELF | IN_MOVED_TO |
- IN_MOVED_FROM | IN_DONT_FOLLOW |
- IN_EXCL_UNLINK | IN_ONLYDIR );
+ iwd = inotify_add_watch(
+ ifd, ".",
+ IN_CLOSE_WRITE | IN_DELETE | IN_CREATE | IN_DELETE_SELF |
+ IN_MOVE_SELF | IN_MOVED_TO | IN_MOVED_FROM |
+ IN_DONT_FOLLOW | IN_EXCL_UNLINK | IN_ONLYDIR);
if (iwd < 0)
die("inotify_add_watch: %m");
- uring_task_init(&scfgm->task, "server-config-monitor", uring_parent(), scfgm_free);
+ uring_task_init(&scfgm->task, "server-config-monitor", uring_parent(),
+ scfgm_free);
uring_task_set_fd(&scfgm->task, ifd);
cfg->server_cfg_monitor = scfgm;
uring_read(&scfgm->task, scfgm->buf, sizeof(scfgm->buf), inotify_cb);
@@ -483,4 +482,3 @@ server_cfg_monitor_init()
closedir(dir);
}
-
diff --git a/minecproxy/server-proxy.c b/minecproxy/server-proxy.c
index 087773d..b80a220 100644
--- a/minecproxy/server-proxy.c
+++ b/minecproxy/server-proxy.c
@@ -13,8 +13,7 @@
#include "server.h"
#include "server-proxy.h"
-static void
-format_bytes(char *buf, size_t len, uint64_t val)
+static void format_bytes(char *buf, size_t len, uint64_t val)
{
uint64_t tmp;
const char *suffix = "B";
@@ -24,11 +23,11 @@ format_bytes(char *buf, size_t len, uint64_t val)
tmp = val * 10;
if (val > 1152921504606846976ULL) {
tmp = val / 115292150460684697ULL;
- suffix= "EiB";
+ suffix = "EiB";
} else if (val > 1125899906842624ULL) {
tmp /= 1125899906842624ULL;
suffix = "PiB";
- } else if (val > 1099511627776ULL) {
+ } else if (val > 1099511627776ULL) {
tmp /= 1099511627776ULL;
suffix = "TiB";
} else if (val > 1073741824ULL) {
@@ -45,8 +44,7 @@ format_bytes(char *buf, size_t len, uint64_t val)
snprintf(buf, len, "%lu.%lu %s", tmp / 10, tmp % 10, suffix);
}
-static void
-format_time(char *buf, size_t len, time_t diff)
+static void format_time(char *buf, size_t len, time_t diff)
{
unsigned hh, mm, ss;
@@ -61,62 +59,60 @@ format_time(char *buf, size_t len, time_t diff)
snprintf(buf, len, "%02u:%02u:%02u", hh, mm, ss);
}
-static void
-proxy_free(struct uring_task *task)
+static void proxy_free(struct uring_task *task)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, task);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, task);
char cts[100];
char stc[100];
char duration[100];
assert_return(task);
- debug(DBG_PROXY, "server: %s, src: %s, dst: %s",
- proxy->server->name,
+ debug(DBG_PROXY, "server: %s, src: %s, dst: %s", proxy->server->name,
proxy->client_conn.remote.addrstr,
proxy->server_conn.remote.addrstr);
if (proxy->begin > 0) {
- format_time(duration, sizeof(duration), time(NULL) - proxy->begin);
+ format_time(duration, sizeof(duration),
+ time(NULL) - proxy->begin);
format_bytes(cts, sizeof(cts), proxy->client_bytes);
format_bytes(stc, sizeof(stc), proxy->server_bytes);
info("%s: proxy connection %s -> %s closed "
"(CtS: %s, StC: %s), duration %s",
- proxy->server->name,
- proxy->client_conn.remote.addrstr,
- proxy->server_conn.remote.addrstr,
- cts, stc, duration);
+ proxy->server->name, proxy->client_conn.remote.addrstr,
+ proxy->server_conn.remote.addrstr, cts, stc, duration);
}
list_del(&proxy->list);
xfree(proxy);
}
-static void
-proxy_client_free(struct uring_task *task)
+static void proxy_client_free(struct uring_task *task)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, clienttask);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, clienttask);
assert_return(task);
debug(DBG_PROXY, "%s: client connection closed", proxy->server->name);
}
-static void
-proxy_server_free(struct uring_task *task)
+static void proxy_server_free(struct uring_task *task)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, servertask);
assert_return(task);
debug(DBG_PROXY, "%s: server connection closed", proxy->server->name);
}
-void
-proxy_delete(struct server_proxy *proxy)
+void proxy_delete(struct server_proxy *proxy)
{
- debug(DBG_PROXY, "%s: shutting down proxy %p", proxy->server->name, proxy);
+ debug(DBG_PROXY, "%s: shutting down proxy %p", proxy->server->name,
+ proxy);
assert_return(proxy);
@@ -141,10 +137,10 @@ proxy_delete(struct server_proxy *proxy)
*/
static void proxy_client_read(struct uring_task *task, int res);
-static void
-proxy_client_written(struct uring_task *task, int res)
+static void proxy_client_written(struct uring_task *task, int res)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, clienttask);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, clienttask);
assert_return(task);
assert_task_alive(DBG_PROXY, task);
@@ -160,10 +156,10 @@ proxy_client_written(struct uring_task *task, int res)
uring_tbuf_read(task, proxy_client_read);
}
-static void
-proxy_client_read(struct uring_task *task, int res)
+static void proxy_client_read(struct uring_task *task, int res)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, clienttask);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, clienttask);
assert_return(task);
assert_task_alive(DBG_PROXY, task);
@@ -180,10 +176,10 @@ proxy_client_read(struct uring_task *task, int res)
static void proxy_server_read(struct uring_task *task, int res);
-static void
-proxy_server_written(struct uring_task *task, int res)
+static void proxy_server_written(struct uring_task *task, int res)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, servertask);
assert_return(task);
assert_task_alive(DBG_PROXY, task);
@@ -199,10 +195,10 @@ proxy_server_written(struct uring_task *task, int res)
uring_tbuf_read(&proxy->servertask, proxy_server_read);
}
-static void
-proxy_server_read(struct uring_task *task, int res)
+static void proxy_server_read(struct uring_task *task, int res)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, servertask);
assert_return(task);
assert_task_alive(DBG_PROXY, task);
@@ -222,10 +218,10 @@ proxy_server_read(struct uring_task *task, int res)
*/
static void proxy_client_spliced_in(struct uring_task *task, int res);
-static void
-proxy_client_spliced_out(struct uring_task *task, int res)
+static void proxy_client_spliced_out(struct uring_task *task, int res)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, servertask);
assert_return(task);
assert_task_alive(DBG_PROXY, task);
@@ -236,13 +232,14 @@ proxy_client_spliced_out(struct uring_task *task, int res)
return;
}
- uring_splice(task, proxy->cfd, proxy->cpipe[PIPE_WR], proxy_client_spliced_in);
+ uring_splice(task, proxy->cfd, proxy->cpipe[PIPE_WR],
+ proxy_client_spliced_in);
}
-static void
-proxy_client_spliced_in(struct uring_task *task, int res)
+static void proxy_client_spliced_in(struct uring_task *task, int res)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, servertask);
assert_return(task);
assert_task_alive(DBG_PROXY, task);
@@ -253,15 +250,16 @@ proxy_client_spliced_in(struct uring_task *task, int res)
return;
}
- uring_splice(task, proxy->cpipe[PIPE_RD], proxy->sfd, proxy_client_spliced_out);
+ uring_splice(task, proxy->cpipe[PIPE_RD], proxy->sfd,
+ proxy_client_spliced_out);
}
static void proxy_server_spliced_in(struct uring_task *task, int res);
-static void
-proxy_server_spliced_out(struct uring_task *task, int res)
+static void proxy_server_spliced_out(struct uring_task *task, int res)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, servertask);
assert_return(task);
assert_task_alive(DBG_PROXY, task);
@@ -272,13 +270,14 @@ proxy_server_spliced_out(struct uring_task *task, int res)
return;
}
- uring_splice(task, proxy->sfd, proxy->spipe[PIPE_WR], proxy_server_spliced_in);
+ uring_splice(task, proxy->sfd, proxy->spipe[PIPE_WR],
+ proxy_server_spliced_in);
}
-static void
-proxy_server_spliced_in(struct uring_task *task, int res)
+static void proxy_server_spliced_in(struct uring_task *task, int res)
{
- struct server_proxy *proxy = container_of(task, struct server_proxy, servertask);
+ struct server_proxy *proxy =
+ container_of(task, struct server_proxy, servertask);
assert_return(task);
assert_task_alive(DBG_PROXY, task);
@@ -289,13 +288,14 @@ proxy_server_spliced_in(struct uring_task *task, int res)
return;
}
- uring_splice(task, proxy->spipe[PIPE_RD], proxy->cfd, proxy_server_spliced_out);
+ uring_splice(task, proxy->spipe[PIPE_RD], proxy->cfd,
+ proxy_server_spliced_out);
}
-static void
-proxy_connected_cb(struct connection *conn, bool connected)
+static void proxy_connected_cb(struct connection *conn, bool connected)
{
- struct server_proxy *proxy = container_of(conn, struct server_proxy, server_conn);
+ struct server_proxy *proxy =
+ container_of(conn, struct server_proxy, server_conn);
assert_return(conn);
assert_task_alive(DBG_PROXY, &proxy->clienttask);
@@ -313,16 +313,17 @@ proxy_connected_cb(struct connection *conn, bool connected)
ptimer_del_task(&proxy->ptask);
proxy->sfd = proxy->servertask.fd;
- verbose("%s: proxy connection %s -> %s opened",
- proxy->server->name,
+ verbose("%s: proxy connection %s -> %s opened", proxy->server->name,
proxy->client_conn.remote.addrstr,
proxy->server_conn.remote.addrstr);
proxy->begin = time(NULL);
if (cfg->splice_supported) {
debug(DBG_PROXY, "handling proxy connection with splice");
- uring_splice(&proxy->clienttask, proxy->cfd, proxy->cpipe[PIPE_WR], proxy_client_spliced_in);
- uring_splice(&proxy->servertask, proxy->sfd, proxy->spipe[PIPE_WR], proxy_server_spliced_in);
+ uring_splice(&proxy->clienttask, proxy->cfd,
+ proxy->cpipe[PIPE_WR], proxy_client_spliced_in);
+ uring_splice(&proxy->servertask, proxy->sfd,
+ proxy->spipe[PIPE_WR], proxy_server_spliced_in);
} else {
debug(DBG_PROXY, "handling proxy connection with read-write");
uring_tbuf_read(&proxy->clienttask, proxy_client_read);
@@ -330,8 +331,7 @@ proxy_connected_cb(struct connection *conn, bool connected)
}
}
-void
-proxy_refdump(struct server_proxy *proxy)
+void proxy_refdump(struct server_proxy *proxy)
{
assert_return(proxy);
@@ -340,10 +340,10 @@ proxy_refdump(struct server_proxy *proxy)
uring_task_refdump(&proxy->servertask);
}
-static void
-proxy_connect_timer_cb(struct ptimer_task *ptask)
+static void proxy_connect_timer_cb(struct ptimer_task *ptask)
{
- struct server_proxy *proxy = container_of(ptask, struct server_proxy, ptask);
+ struct server_proxy *proxy =
+ container_of(ptask, struct server_proxy, ptask);
assert_return(ptask);
@@ -355,8 +355,8 @@ proxy_connect_timer_cb(struct ptimer_task *ptask)
&proxy->server_conn, proxy_connected_cb);
}
-struct server_proxy *
-proxy_new(struct server *server, struct saddr *client, int fd)
+struct server_proxy *proxy_new(struct server *server, struct saddr *client,
+ int fd)
{
struct server_proxy *proxy;
@@ -412,8 +412,8 @@ proxy_new(struct server *server, struct saddr *client, int fd)
}
proxy->connecting = true;
- connect_any(&proxy->servertask, &server->remotes,
- &proxy->server_conn, proxy_connected_cb);
+ connect_any(&proxy->servertask, &server->remotes, &proxy->server_conn,
+ proxy_connected_cb);
return proxy;
@@ -426,10 +426,10 @@ out:
return NULL;
}
-static void
-local_accept(struct uring_task *task, int res)
+static void local_accept(struct uring_task *task, int res)
{
- struct server_local *local = container_of(task, struct server_local, task);
+ 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;
@@ -445,8 +445,8 @@ local_accept(struct uring_task *task, int res)
saddr_set_addrstr(&local->client);
- verbose("%s: incoming proxy connection: %s -> %s",
- server->name, local->client.addrstr, local->local.addrstr);
+ verbose("%s: incoming proxy connection: %s -> %s", server->name,
+ local->client.addrstr, local->local.addrstr);
if (list_empty(&server->remotes)) {
/* This shouldn't be possible, checked before opening local */
@@ -463,8 +463,7 @@ out:
uring_accept(&local->task, &local->client, local_accept);
}
-bool
-local_open(struct server_local *local)
+bool local_open(struct server_local *local)
{
int sfd;
int option;
@@ -472,14 +471,15 @@ local_open(struct server_local *local)
assert_return(local && local->server, false);
- sfd = socket(local->local.storage.ss_family, SOCK_STREAM | SOCK_CLOEXEC, 0);
+ sfd = socket(local->local.st.ss_family, SOCK_STREAM | SOCK_CLOEXEC, 0);
if (sfd < 0) {
error("socket: %m");
goto error;
}
option = true;
- if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) < 0) {
+ if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option)) <
+ 0) {
error("setsockopt: %m");
goto error;
}
@@ -487,7 +487,8 @@ local_open(struct server_local *local)
/* The MC protocol expects the client to send data first */
if (cfg->socket_defer) {
option = true;
- if (setsockopt(sfd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &option, sizeof(option)) < 0)
+ if (setsockopt(sfd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &option,
+ sizeof(option)) < 0)
error("setsockopt: %m");
}
@@ -497,14 +498,16 @@ local_open(struct server_local *local)
*/
if (cfg->socket_freebind) {
option = true;
- if (setsockopt(sfd, IPPROTO_IP, IP_FREEBIND, &option, sizeof(option)) < 0)
+ if (setsockopt(sfd, IPPROTO_IP, IP_FREEBIND, &option,
+ sizeof(option)) < 0)
error("setsockopt: %m");
}
- socket_set_low_latency(sfd, cfg->socket_keepalive,
- cfg->socket_iptos, cfg->socket_nodelay);
+ socket_set_low_latency(sfd, cfg->socket_keepalive, cfg->socket_iptos,
+ cfg->socket_nodelay);
- r = bind(sfd, (struct sockaddr *)&local->local.storage, local->local.addrlen);
+ r = bind(sfd, (struct sockaddr *)&local->local.st,
+ local->local.addrlen);
if (r < 0) {
error("bind: %m");
goto error;
@@ -526,18 +529,17 @@ error:
return false;
}
-void
-local_refdump(struct server_local *local)
+void local_refdump(struct server_local *local)
{
assert_return(local);
uring_task_refdump(&local->task);
}
-static void
-local_free(struct uring_task *task)
+static void local_free(struct uring_task *task)
{
- struct server_local *local = container_of(task, struct server_local, task);
+ struct server_local *local =
+ container_of(task, struct server_local, task);
assert_return(task);
@@ -546,16 +548,14 @@ local_free(struct uring_task *task)
xfree(local);
}
-void
-local_delete(struct server_local *local)
+void local_delete(struct server_local *local)
{
assert_return(local);
uring_task_destroy(&local->task);
}
-struct server_local *
-local_new(struct server *server, struct saddr *saddr)
+struct server_local *local_new(struct server *server, struct saddr *saddr)
{
struct server_local *local;
@@ -574,4 +574,3 @@ local_new(struct server *server, struct saddr *saddr)
xfree(saddr);
return local;
}
-
diff --git a/minecproxy/server-proxy.h b/minecproxy/server-proxy.h
index ee3bda3..877ae9a 100644
--- a/minecproxy/server-proxy.h
+++ b/minecproxy/server-proxy.h
@@ -15,7 +15,7 @@ struct server_proxy {
uint64_t server_bytes;
int spipe[2];
int sfd;
-
+
bool connecting;
time_t begin;
struct ptimer_task ptask;
diff --git a/minecproxy/server-rcon.c b/minecproxy/server-rcon.c
index b19bdb1..9562aa9 100644
--- a/minecproxy/server-rcon.c
+++ b/minecproxy/server-rcon.c
@@ -16,8 +16,7 @@
#include "server-rcon.h"
#include "rcon-protocol.h"
-static int
-rcon_packet_complete(struct uring_task *task, _unused_ int res)
+static int rcon_packet_complete(struct uring_task *task, _unused_ int res)
{
assert_return(task, -EINVAL);
assert_task_alive_or(DBG_RCON, task, return -EINTR);
@@ -25,23 +24,22 @@ rcon_packet_complete(struct uring_task *task, _unused_ int res)
return rcon_protocol_packet_complete(task->tbuf->buf, task->tbuf->len);
}
-static bool
-rcon_check_reply(struct uring_task *task, int res, int32_t *id,
- int32_t *type, const char **msg)
+static bool rcon_check_reply(struct uring_task *task, int res, int32_t *id,
+ int32_t *type, const char **msg)
{
struct server *server = container_of(task, struct server, rcon_task);
const char *error;
if (res < 0) {
- error("rcon(%s): reading reply failed, res: %i",
- server->name, res);
+ error("rcon(%s): reading reply failed, res: %i", server->name,
+ res);
goto error;
}
- if (!rcon_protocol_read_packet(task->tbuf->buf, task->tbuf->len,
- id, type, msg, &error)) {
- error("rcon(%s): failed to parse packet: %s",
- server->name, error);
+ if (!rcon_protocol_read_packet(task->tbuf->buf, task->tbuf->len, id,
+ type, msg, &error)) {
+ error("rcon(%s): failed to parse packet: %s", server->name,
+ error);
goto error;
}
@@ -52,8 +50,7 @@ error:
return false;
}
-static void
-rcon_stop_reply(struct uring_task *task, int res)
+static void rcon_stop_reply(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, rcon_task);
int32_t id;
@@ -82,8 +79,7 @@ out:
uring_task_close_fd(task);
}
-static void
-rcon_stop_sent(struct uring_task *task, int res)
+static void rcon_stop_sent(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, rcon_task);
@@ -101,8 +97,7 @@ rcon_stop_sent(struct uring_task *task, int res)
uring_tbuf_read_until(task, rcon_packet_complete, rcon_stop_reply);
}
-static void
-rcon_login_reply(struct uring_task *task, int res)
+static void rcon_login_reply(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, rcon_task);
int32_t id;
@@ -140,8 +135,7 @@ error:
uring_task_close_fd(task);
}
-static void
-rcon_login_sent(struct uring_task *task, int res)
+static void rcon_login_sent(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, rcon_task);
@@ -149,8 +143,8 @@ rcon_login_sent(struct uring_task *task, int res)
assert_task_alive(DBG_RCON, task);
if (res != task->tbuf->len) {
- error("rcon(%s): sending login failed, res: %i",
- server->name, res);
+ error("rcon(%s): sending login failed, res: %i", server->name,
+ res);
uring_task_close_fd(task);
return;
}
@@ -159,8 +153,7 @@ rcon_login_sent(struct uring_task *task, int res)
uring_tbuf_read_until(task, rcon_packet_complete, rcon_login_reply);
}
-static void
-rcon_connected_cb(struct connection *conn, bool connected)
+static void rcon_connected_cb(struct connection *conn, bool connected)
{
struct server *server = container_of(conn, struct server, rcon_conn);
@@ -175,13 +168,11 @@ rcon_connected_cb(struct connection *conn, bool connected)
rcon_protocol_create_packet(server->rcon_tbuf.buf,
sizeof(server->rcon_tbuf.buf),
&server->rcon_tbuf.len, 1,
- RCON_PACKET_LOGIN,
- server->rcon_password);
+ RCON_PACKET_LOGIN, server->rcon_password);
uring_tbuf_write(&server->rcon_task, rcon_login_sent);
}
-static void
-rcon_free(struct uring_task *task)
+static void rcon_free(struct uring_task *task)
{
struct server *server = container_of(task, struct server, rcon_task);
@@ -190,25 +181,24 @@ rcon_free(struct uring_task *task)
debug(DBG_RCON, "task %p, server %s (%p)", task, server->name, server);
}
-void
-rcon_stop(struct server *server)
+void rcon_stop(struct server *server)
{
- assert_return(server && !list_empty(&server->rcons) && !empty_str(server->rcon_password));
+ assert_return(server && !list_empty(&server->rcons) &&
+ !empty_str(server->rcon_password));
assert_task_alive(DBG_RCON, &server->rcon_task);
- connect_any(&server->rcon_task, &server->rcons, &server->rcon_conn, rcon_connected_cb);
+ connect_any(&server->rcon_task, &server->rcons, &server->rcon_conn,
+ rcon_connected_cb);
}
-void
-rcon_refdump(struct server *server)
+void rcon_refdump(struct server *server)
{
assert_return(server);
uring_task_refdump(&server->rcon_task);
}
-void
-rcon_delete(struct server *server)
+void rcon_delete(struct server *server)
{
assert_return(server);
@@ -216,12 +206,10 @@ rcon_delete(struct server *server)
uring_task_destroy(&server->rcon_task);
}
-void
-rcon_init(struct server *server)
+void rcon_init(struct server *server)
{
assert_return(server);
uring_task_init(&server->rcon_task, "rcon", &server->task, rcon_free);
uring_task_set_buf(&server->rcon_task, &server->rcon_tbuf);
}
-
diff --git a/minecproxy/server.c b/minecproxy/server.c
index 39b4024..8c521cf 100644
--- a/minecproxy/server.c
+++ b/minecproxy/server.c
@@ -20,8 +20,8 @@
#include "idle.h"
#include "systemd.h"
-static bool
-set_property(struct server *server, char **property, const char *value)
+static bool set_property(struct server *server, char **property,
+ const char *value)
{
assert_return(server && !*property && !empty_str(value), false);
@@ -34,8 +34,7 @@ set_property(struct server *server, char **property, const char *value)
return true;
}
-void
-server_refdump(struct server *server)
+void server_refdump(struct server *server)
{
struct server_local *local;
struct server_proxy *proxy;
@@ -53,8 +52,7 @@ server_refdump(struct server *server)
rcon_refdump(server);
}
-static void
-server_free(struct uring_task *task)
+static void server_free(struct uring_task *task)
{
struct server *server = container_of(task, struct server, task);
@@ -72,8 +70,7 @@ server_free(struct uring_task *task)
xfree(server);
}
-void
-server_delete(struct server *server)
+void server_delete(struct server *server)
{
struct server_local *local, *ltmp;
struct server_proxy *proxy, *ptmp;
@@ -107,7 +104,7 @@ server_delete(struct server *server)
list_for_each_entry_safe(dns, dtmp, &server->dnslookups, list)
gai_cancel(&dns->gcb);
-
+
uring_task_destroy(&server->idle_task);
uring_poll_cancel(&server->exec_task);
uring_task_put(&server->exec_task);
@@ -115,8 +112,7 @@ server_delete(struct server *server)
uring_task_put(&server->ann_task);
}
-void
-server_delete_by_name(const char *name)
+void server_delete_by_name(const char *name)
{
struct server *server;
@@ -130,8 +126,7 @@ server_delete_by_name(const char *name)
}
}
-static void
-server_dump(struct server *server)
+static void server_dump(struct server *server)
{
struct server_local *local;
struct saddr *remote;
@@ -151,8 +146,9 @@ server_dump(struct server *server)
verbose(" * Type: unknown");
break;
}
- verbose(" * Name: %s", server->pretty_name ? server->pretty_name : "<undefined>");
- verbose(" * Announce port: %" PRIu16, server->announce_port);
+ verbose(" * Name: %s",
+ server->pretty_name ? server->pretty_name : "<undefined>");
+ verbose(" * Announce port: %" PRIu16, server->announce_port);
if (!list_empty(&server->locals)) {
verbose(" * Local:");
@@ -175,8 +171,7 @@ server_dump(struct server *server)
verbose("");
}
-static void
-server_exec_free(struct uring_task *task)
+static void server_exec_free(struct uring_task *task)
{
assert_return(task);
@@ -188,8 +183,7 @@ server_exec_free(struct uring_task *task)
#endif
/* FIXME: update states */
-static void
-server_exec_done(struct uring_task *task, int res)
+static void server_exec_done(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, exec_task);
int r;
@@ -205,10 +199,10 @@ server_exec_done(struct uring_task *task, int res)
}
r = waitid(P_PIDFD, server->exec_task.fd, &info, WEXITED);
- if (r < 0) {
- error("waitid: %m");
+ if (r < 0) {
+ error("waitid: %m");
goto out;
- }
+ }
if (info.si_status == 0)
debug(DBG_SRV, "command successfully executed");
@@ -219,8 +213,7 @@ out:
uring_task_close_fd(&server->exec_task);
}
-static int
-server_exec_child(void *ptr)
+static int server_exec_child(void *ptr)
{
const char *cmd = ptr;
@@ -234,8 +227,7 @@ server_exec_child(void *ptr)
#define CLONE_PIDFD 0x00001000
#endif
-static bool
-server_exec(struct server *server, const char *cmd)
+static bool server_exec(struct server *server, const char *cmd)
{
char stack[4096]; /* Beautiful/horrible hack :) */
int pidfd;
@@ -243,9 +235,9 @@ server_exec(struct server *server, const char *cmd)
assert_return(server && cmd && server->exec_task.fd < 1, false);
- r = clone(server_exec_child, stack + sizeof(stack),
- CLONE_VM | CLONE_VFORK | CLONE_PIDFD | SIGCHLD,
- (void *)cmd, &pidfd);
+ r = clone(server_exec_child, stack + sizeof(stack),
+ CLONE_VM | CLONE_VFORK | CLONE_PIDFD | SIGCHLD, (void *)cmd,
+ &pidfd);
if (r < 0) {
error("clone: %m: %i", r);
return false;
@@ -256,14 +248,14 @@ server_exec(struct server *server, const char *cmd)
return true;
}
-static bool
-server_check_running(struct server *server)
+static bool server_check_running(struct server *server)
{
assert_return(server, false);
/* FIXME: other methods, rcon? */
if (server->systemd_service) {
- verbose("%s: checking if systemd service is running", server->name);
+ verbose("%s: checking if systemd service is running",
+ server->name);
if (systemd_service_running(server)) {
server->state = SERVER_STATE_RUNNING;
return true;
@@ -276,21 +268,19 @@ server_check_running(struct server *server)
return false;
}
-bool
-server_start(struct server *server)
+bool server_start(struct server *server)
{
assert_return(server, false);
assert_task_alive_or(DBG_SRV, &server->task, return false);
switch (server->start_method) {
-
case SERVER_START_METHOD_EXEC:
verbose("Starting server %s via external cmd", server->name);
return server_exec(server, server->start_exec);
case SERVER_START_METHOD_SYSTEMD:
- verbose("Starting server %s via systemd (%s)",
- server->name, server->systemd_service);
+ verbose("Starting server %s via systemd (%s)", server->name,
+ server->systemd_service);
if (systemd_service_start(server)) {
server->state = SERVER_STATE_RUNNING;
@@ -306,21 +296,19 @@ server_start(struct server *server)
return false;
}
-bool
-server_stop(struct server *server)
+bool server_stop(struct server *server)
{
assert_return(server, false);
assert_task_alive_or(DBG_SRV, &server->task, return false);
switch (server->stop_method) {
-
case SERVER_STOP_METHOD_EXEC:
verbose("Stopping server %s via external cmd", server->name);
return server_exec(server, server->stop_exec);
case SERVER_STOP_METHOD_SYSTEMD:
- verbose("Stopping server %s via systemd (%s)",
- server->name, server->systemd_service);
+ verbose("Stopping server %s via systemd (%s)", server->name,
+ server->systemd_service);
if (systemd_service_stop(server)) {
server->state = SERVER_STATE_STOPPED;
return true;
@@ -340,22 +328,19 @@ server_stop(struct server *server)
return false;
}
-static void
-server_idle_free(struct uring_task *task)
+static void server_idle_free(struct uring_task *task)
{
assert_return(task);
debug(DBG_ANN, "called");
}
-void
-server_set_active_players(struct server *server, int count)
+void server_set_active_players(struct server *server, int count)
{
assert_return(server);
assert_task_alive(DBG_IDLE, &server->idle_task);
- debug(DBG_IDLE, "%s: currently %i active players",
- server->name, count);
+ debug(DBG_IDLE, "%s: currently %i active players", server->name, count);
if (count < 0)
return;
@@ -368,12 +353,11 @@ server_set_active_players(struct server *server, int count)
if (server->idle_count > server->idle_timeout) {
verbose("stopping idle server %s", server->name);
- server_stop(server);
+ server_stop(server);
}
}
-static void
-server_idle_connected_cb(struct connection *conn, bool connected)
+static void server_idle_connected_cb(struct connection *conn, bool connected)
{
struct server *server = container_of(conn, struct server, idle_conn);
@@ -393,8 +377,7 @@ server_idle_connected_cb(struct connection *conn, bool connected)
idle_check_get_player_count(server, conn);
}
-bool
-server_idle_check(struct server *server)
+bool server_idle_check(struct server *server)
{
assert_return(server, false);
@@ -413,21 +396,19 @@ server_idle_check(struct server *server)
return true;
}
- connect_any(&server->idle_task, &server->remotes,
- &server->idle_conn, server_idle_connected_cb);
+ connect_any(&server->idle_task, &server->remotes, &server->idle_conn,
+ server_idle_connected_cb);
return true;
}
-static void
-server_announce_free(struct uring_task *task)
+static void server_announce_free(struct uring_task *task)
{
assert_return(task);
debug(DBG_ANN, "called");
}
-static void
-server_announce_cb(struct uring_task *task, int res)
+static void server_announce_cb(struct uring_task *task, int res)
{
struct server *server = container_of(task, struct server, ann_task);
@@ -443,8 +424,7 @@ server_announce_cb(struct uring_task *task, int res)
uring_task_set_fd(&server->ann_task, -1);
}
-bool
-server_announce(struct server *server, int fd)
+bool server_announce(struct server *server, int fd)
{
assert_return(server && fd >= 0, false);
@@ -458,8 +438,7 @@ server_announce(struct server *server, int fd)
return true;
}
-bool
-server_commit(struct server *server)
+bool server_commit(struct server *server)
{
struct server_local *local;
uint16_t port;
@@ -486,14 +465,14 @@ server_commit(struct server *server)
if (server->stop_method == SERVER_STOP_METHOD_RCON &&
list_empty(&server->rcons)) {
error("%s: rcon stop method missing rcon address",
- server->name);
+ server->name);
return false;
}
if (server->stop_method == SERVER_STOP_METHOD_RCON &&
!server->rcon_password) {
error("%s: rcon stop method missing rcon password",
- server->name);
+ server->name);
return false;
}
@@ -501,12 +480,13 @@ server_commit(struct server *server)
server->stop_method == SERVER_STOP_METHOD_SYSTEMD) &&
!server->systemd_service) {
error("%s: systemd start/stop method missing systemd service",
- server->name);
+ server->name);
return false;
}
if (server->systemd_service && !server->systemd_obj) {
- server->systemd_obj = systemd_object_path(server->systemd_service);
+ server->systemd_obj =
+ systemd_object_path(server->systemd_service);
if (!server->systemd_obj) {
error("%s: failed to create systemd object path (%s)",
server->name, server->systemd_service);
@@ -516,29 +496,33 @@ server_commit(struct server *server)
if (server->idle_timeout > 0 &&
server->stop_method == SERVER_STOP_METHOD_UNDEFINED) {
- error("%s: idle_timeout set but missing stop method", server->name);
+ error("%s: idle_timeout set but missing stop method",
+ server->name);
return false;
}
switch (server->type) {
case SERVER_TYPE_ANNOUNCE:
if (server->announce_port < 1) {
- error("%s: missing announce port", server->name);
+ error("%s: missing announce port", server->name);
return false;
}
if (server->start_method != SERVER_START_METHOD_UNDEFINED) {
- error("%s: can't set start_method for announce server", server->name);
+ error("%s: can't set start_method for announce server",
+ server->name);
return false;
}
if (!list_empty(&server->locals)) {
- error("%s: can't set local addresses for announce server", server->name);
+ error("%s: can't set local addresses for announce server",
+ server->name);
return false;
}
if (!list_empty(&server->remotes)) {
- error("%s: can't set remote addresses for announce server", server->name);
+ error("%s: can't set remote addresses for announce server",
+ server->name);
return false;
}
@@ -546,17 +530,20 @@ server_commit(struct server *server)
case SERVER_TYPE_PROXY:
if (server->announce_port >= 1) {
- error("%s: can't set announce port for proxy server", server->name);
+ error("%s: can't set announce port for proxy server",
+ server->name);
return false;
}
if (list_empty(&server->locals)) {
- error("%s: missing local addresses for proxy server", server->name);
+ error("%s: missing local addresses for proxy server",
+ server->name);
return false;
}
if (list_empty(&server->remotes)) {
- error("%s: missing remote addresses for proxy server", server->name);
+ error("%s: missing remote addresses for proxy server",
+ server->name);
return false;
}
@@ -578,7 +565,8 @@ server_commit(struct server *server)
}
if (server->announce_port < 1) {
- error("%s: can't determine which port to announce", server->name);
+ error("%s: can't determine which port to announce",
+ server->name);
return false;
}
@@ -591,30 +579,34 @@ server_commit(struct server *server)
if (!server->pretty_name) {
char *suffix;
-
+
suffix = strrchr(server->name, '.');
if (!suffix || suffix == server->name) {
error("invalid server name: %s", server->name);
return false;
}
- server->pretty_name = xstrndup(server->name, suffix - server->name);
+ server->pretty_name =
+ xstrndup(server->name, suffix - server->name);
if (!server->pretty_name) {
- error("failed to create display name: %s", server->name);
+ error("failed to create display name: %s",
+ server->name);
return false;
}
}
r = snprintf(server->ann_buf.buf, sizeof(server->ann_buf.buf),
- "[MOTD]%s[/MOTD][AD]%" PRIu16 "[/AD]",
- server->pretty_name, server->announce_port);
+ "[MOTD]%s[/MOTD][AD]%" PRIu16 "[/AD]", server->pretty_name,
+ server->announce_port);
if (r < 1 || r >= sizeof(server->ann_buf.buf)) {
- error("%s: unable to create announce msg: %i\n", server->name, r);
+ error("%s: unable to create announce msg: %i\n", server->name,
+ r);
return false;
}
server->ann_buf.len = r;
- /* FIXME: config, dont reread config if server running, make sure fd is available before this is called */
+ /* FIXME: config, dont reread config if server running, make sure fd is
+ * available before this is called */
server_dump(server);
list_for_each_entry(local, &server->locals, list)
@@ -628,8 +620,7 @@ server_commit(struct server *server)
return true;
}
-bool
-server_add_remote(struct server *server, struct saddr *remote)
+bool server_add_remote(struct server *server, struct saddr *remote)
{
assert_return(server && remote, false);
assert_task_alive_or(DBG_SRV, &server->task, return false);
@@ -639,8 +630,7 @@ server_add_remote(struct server *server, struct saddr *remote)
return true;
}
-bool
-server_add_local(struct server *server, struct saddr *saddr)
+bool server_add_local(struct server *server, struct saddr *saddr)
{
struct server_local *local;
@@ -655,8 +645,7 @@ server_add_local(struct server *server, struct saddr *saddr)
return true;
}
-bool
-server_add_rcon(struct server *server, struct saddr *rcon)
+bool server_add_rcon(struct server *server, struct saddr *rcon)
{
assert_return(server && rcon, false);
assert_task_alive_or(DBG_SRV, &server->task, return false);
@@ -666,21 +655,20 @@ server_add_rcon(struct server *server, struct saddr *rcon)
return true;
}
-bool
-server_set_rcon_password(struct server *server, const char *password)
+bool server_set_rcon_password(struct server *server, const char *password)
{
assert_return(server && !empty_str(password), false);
return set_property(server, &server->rcon_password, password);
}
-bool
-server_set_systemd_service(struct server *server, const char *service)
+bool server_set_systemd_service(struct server *server, const char *service)
{
const char *suffix;
char *tmp;
- assert_return(server && !empty_str(service) && !server->systemd_service, false);
+ assert_return(server && !empty_str(service) && !server->systemd_service,
+ false);
suffix = strrchr(service, '.');
if (!suffix || !streq(suffix, ".service")) {
@@ -699,55 +687,52 @@ server_set_systemd_service(struct server *server, const char *service)
return true;
}
-bool
-server_set_stop_method(struct server *server,
- enum server_stop_method stop_method)
+bool server_set_stop_method(struct server *server,
+ enum server_stop_method stop_method)
{
assert_return(server->stop_method == SERVER_STOP_METHOD_UNDEFINED &&
- stop_method != SERVER_STOP_METHOD_UNDEFINED, false);
+ stop_method != SERVER_STOP_METHOD_UNDEFINED,
+ false);
server->stop_method = stop_method;
return true;
}
-bool
-server_set_start_method(struct server *server,
- enum server_start_method start_method)
+bool server_set_start_method(struct server *server,
+ enum server_start_method start_method)
{
assert_return(server->start_method == SERVER_START_METHOD_UNDEFINED &&
- start_method != SERVER_START_METHOD_UNDEFINED, false);
+ start_method != SERVER_START_METHOD_UNDEFINED,
+ false);
server->start_method = start_method;
return true;
}
-bool
-server_set_stop_exec(struct server *server, const char *cmd)
+bool server_set_stop_exec(struct server *server, const char *cmd)
{
assert_return(server && !empty_str(cmd), false);
return set_property(server, &server->stop_exec, cmd);
}
-bool
-server_set_start_exec(struct server *server, const char *cmd)
+bool server_set_start_exec(struct server *server, const char *cmd)
{
assert_return(server && !empty_str(cmd), false);
return set_property(server, &server->start_exec, cmd);
}
-bool
-server_set_idle_timeout(struct server *server, uint16_t timeout)
+bool server_set_idle_timeout(struct server *server, uint16_t timeout)
{
- assert_return(server && timeout > 0 && server->idle_timeout == 0, false);
+ assert_return(server && timeout > 0 && server->idle_timeout == 0,
+ false);
server->idle_timeout = timeout;
return true;
}
-bool
-server_set_port(struct server *server, uint16_t port)
+bool server_set_port(struct server *server, uint16_t port)
{
assert_return(server && port > 0 && server->announce_port == 0, false);
@@ -755,8 +740,7 @@ server_set_port(struct server *server, uint16_t port)
return true;
}
-bool
-server_set_type(struct server *server, enum server_type type)
+bool server_set_type(struct server *server, enum server_type type)
{
assert_return(server && type != SERVER_TYPE_UNDEFINED, false);
@@ -774,16 +758,14 @@ server_set_type(struct server *server, enum server_type type)
return true;
}
-bool
-server_set_pretty_name(struct server *server, const char *pretty_name)
+bool server_set_pretty_name(struct server *server, const char *pretty_name)
{
assert_return(server && !empty_str(pretty_name), false);
return set_property(server, &server->pretty_name, pretty_name);
}
-struct server *
-server_new(const char *name)
+struct server *server_new(const char *name)
{
struct server *server;
@@ -810,16 +792,21 @@ server_new(const char *name)
server->start_method = SERVER_START_METHOD_UNDEFINED;
server->idle_timeout = 0;
- uring_task_init(&server->task, server->name, uring_parent(), server_free);
+ uring_task_init(&server->task, server->name, uring_parent(),
+ server_free);
uring_task_set_buf(&server->task, &server->tbuf);
- uring_task_init(&server->ann_task, "announce", &server->task, server_announce_free);
+ uring_task_init(&server->ann_task, "announce", &server->task,
+ server_announce_free);
uring_task_set_buf(&server->ann_task, &server->ann_buf);
- saddr_set_ipv4(&server->ann_task.saddr, cinet_addr(224,0,2,60), htons(4445));
+ saddr_set_ipv4(&server->ann_task.saddr, cinet_addr(224,0,2,60),
+ htons(4445));
- uring_task_init(&server->exec_task, "exec", &server->task, server_exec_free);
+ uring_task_init(&server->exec_task, "exec", &server->task,
+ server_exec_free);
- uring_task_init(&server->idle_task, "idle", &server->task, server_idle_free);
+ uring_task_init(&server->idle_task, "idle", &server->task,
+ server_idle_free);
uring_task_set_buf(&server->idle_task, &server->idle_buf);
rcon_init(server);
diff --git a/minecproxy/server.h b/minecproxy/server.h
index ff4c28e..937fa67 100644
--- a/minecproxy/server.h
+++ b/minecproxy/server.h
@@ -1,6 +1,7 @@
#ifndef fooserverhfoo
#define fooserverhfoo
+/* clang-format off */
enum server_state {
SERVER_STATE_INIT = 0,
SERVER_STATE_CFG_OK = 1,
@@ -8,6 +9,7 @@ enum server_state {
SERVER_STATE_STOPPED = 3,
SERVER_STATE_DEAD = 4,
};
+/* clang-format on */
enum server_type {
SERVER_TYPE_UNDEFINED,
@@ -39,7 +41,7 @@ struct server {
struct list_head rcons;
struct list_head dnslookups;
enum server_state state;
-
+
enum server_stop_method stop_method;
enum server_start_method start_method;
@@ -125,4 +127,3 @@ bool server_set_pretty_name(struct server *server, const char *pretty_name);
struct server *server_new(const char *name);
#endif
-
diff --git a/minecproxy/signal-handler.c b/minecproxy/signal-handler.c
index 15c3816..ba92382 100644
--- a/minecproxy/signal-handler.c
+++ b/minecproxy/signal-handler.c
@@ -21,16 +21,14 @@ struct signal_ev {
int pipe[2];
};
-static void
-signal_delete()
+static void signal_delete()
{
assert_return(cfg->signal);
uring_task_destroy(&cfg->signal->task);
}
-static void
-signalfd_read(struct uring_task *task, int res)
+static void signalfd_read(struct uring_task *task, int res)
{
struct signal_ev *signal = container_of(task, struct signal_ev, task);
struct server *server, *stmp;
@@ -60,8 +58,8 @@ signalfd_read(struct uring_task *task, int res)
goto out;
}
- debug(DBG_DNS, "DNS lookup complete, dns: %p, dns->cb: %p",
- dns, dns->cb);
+ debug(DBG_DNS, "DNS lookup complete, dns: %p, dns->cb: %p", dns,
+ dns->cb);
dns->cb(dns);
break;
}
@@ -109,8 +107,8 @@ out:
uring_tbuf_read(&signal->task, signalfd_read);
}
-static void
-hack_signal_handler(int signum, siginfo_t *si, _unused_ void *ucontext)
+static void hack_signal_handler(int signum, siginfo_t *si,
+ _unused_ void *ucontext)
{
ssize_t r;
@@ -119,11 +117,9 @@ hack_signal_handler(int signum, siginfo_t *si, _unused_ void *ucontext)
r = write(cfg->signal->pipe[PIPE_WR], si, sizeof(*si));
if (r != sizeof(*si))
error("write: %zi\n", r);
-
}
-static void
-signal_free(struct uring_task *task)
+static void signal_free(struct uring_task *task)
{
struct signal_ev *signal = container_of(task, struct signal_ev, task);
@@ -135,18 +131,16 @@ signal_free(struct uring_task *task)
xfree(signal);
}
-void
-signal_refdump()
+void signal_refdump()
{
assert_return(cfg->signal);
uring_task_refdump(&cfg->signal->task);
}
-void
-signal_init()
+void signal_init()
{
- //sigset_t mask;
+ // sigset_t mask;
struct signal_ev *signal;
assert_return(!cfg->signal);
@@ -183,12 +177,11 @@ signal_init()
action.sa_flags = 0;
sigaction(SIGPIPE, &action, NULL);
- debug(DBG_SIG, "using pipe fds %i -> %i",
- signal->pipe[PIPE_WR], signal->pipe[PIPE_RD]);
+ debug(DBG_SIG, "using pipe fds %i -> %i", signal->pipe[PIPE_WR],
+ signal->pipe[PIPE_RD]);
uring_task_init(&signal->task, "signal", uring_parent(), signal_free);
uring_task_set_fd(&signal->task, signal->pipe[PIPE_RD]);
uring_task_set_buf(&signal->task, &signal->tbuf);
cfg->signal = signal;
uring_tbuf_read(&signal->task, signalfd_read);
}
-
diff --git a/minecproxy/systemd.c b/minecproxy/systemd.c
index e9ed885..a973a55 100644
--- a/minecproxy/systemd.c
+++ b/minecproxy/systemd.c
@@ -6,12 +6,11 @@
#include "server.h"
#include "systemd.h"
-#define SYSTEMD_DBUS_SERVICE "org.freedesktop.systemd1"
-#define SYSTEMD_DBUS_INTERFACE "org.freedesktop.systemd1.Unit"
-#define SYSTEMD_DBUS_PATH_PREFIX "/org/freedesktop/systemd1/unit/"
+#define SYSTEMD_DBUS_SERVICE "org.freedesktop.systemd1"
+#define SYSTEMD_DBUS_INTERFACE "org.freedesktop.systemd1.Unit"
+#define SYSTEMD_DBUS_PATH_PREFIX "/org/freedesktop/systemd1/unit/"
-static inline char
-tohex(uint8_t val)
+static inline char tohex(uint8_t val)
{
static const char hex[] = "0123456789abcdef";
@@ -29,8 +28,7 @@ tohex(uint8_t val)
*
* Example: minecraft@world1.service -> minecraft_40world1_2eservice
*/
-char *
-systemd_object_path(const char *service)
+char *systemd_object_path(const char *service)
{
char *r;
char *d;
@@ -46,8 +44,7 @@ systemd_object_path(const char *service)
d = r + STRLEN(SYSTEMD_DBUS_PATH_PREFIX);
for (s = service; *s; s++) {
- if ((*s >= 'a' && *s <= 'z') ||
- (*s >= 'A' && *s <= 'Z') ||
+ if ((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') ||
(*s >= '0' && *s <= '9')) {
*(d++) = *s;
continue;
@@ -62,17 +59,15 @@ systemd_object_path(const char *service)
return r;
}
-void
-systemd_delete()
+void systemd_delete()
{
- assert_return_silent(cfg->sd_bus);
+ assert_return_silent(cfg->sd_bus);
- sd_bus_unref(cfg->sd_bus);
+ sd_bus_unref(cfg->sd_bus);
cfg->sd_bus = NULL;
}
-static sd_bus *
-get_bus()
+static sd_bus *get_bus()
{
int r;
@@ -82,7 +77,8 @@ get_bus()
if (!cfg->sd_bus) {
r = sd_bus_open_user(&cfg->sd_bus);
if (r < 0) {
- error("failed to connect to user system bus: %s", strerror(-r));
+ error("failed to connect to user system bus: %s",
+ strerror(-r));
cfg->sd_bus_failed = true;
return NULL;
}
@@ -94,37 +90,36 @@ get_bus()
/*
* Check if a systemd service is running.
*
- * This is equivalent to (assuming service minecraft@world1):
- * gdbus call --session
- * --dest org.freedesktop.systemd1
- * --object-path /org/freedesktop/systemd1/unit/minecraft_40world1_2eservice
+ * This is equivalent to (assuming service mc@world1):
+ * gdbus call --session
+ * --dest org.freedesktop.systemd1
+ * --object-path /org/freedesktop/systemd1/unit/mc_40world1_2eservice
* --method org.freedesktop.DBus.Properties.Get
- * "org.freedesktop.systemd1.Unit"
+ * "org.freedesktop.systemd1.Unit"
* "ActiveState"
*/
-bool
-systemd_service_running(struct server *server)
+bool systemd_service_running(struct server *server)
{
sd_bus *bus = get_bus();
- sd_bus_error error = SD_BUS_ERROR_NULL;
+ sd_bus_error error = SD_BUS_ERROR_NULL;
char *status = NULL;
bool running = false;
int r;
- assert_return(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,
+ r = sd_bus_get_property_string(bus, SYSTEMD_DBUS_SERVICE,
server->systemd_obj,
- SYSTEMD_DBUS_INTERFACE,
- "ActiveState",
- &error,
- &status);
- if (r < 0) {
- error("failed to get status for service %s (%s): %s",
- server->systemd_service, server->systemd_obj, error.message);
+ SYSTEMD_DBUS_INTERFACE, "ActiveState",
+ &error, &status);
+ if (r < 0) {
+ error("failed to get status for service %s (%s): %s",
+ server->systemd_service, server->systemd_obj,
+ error.message);
goto out;
- }
+ }
if (streq(status, "active")) {
running = true;
@@ -136,64 +131,58 @@ systemd_service_running(struct server *server)
out:
free(status);
- sd_bus_error_free(&error);
+ sd_bus_error_free(&error);
return running;
}
-static bool
-systemd_service_action(struct server *server, const char *action)
+static bool systemd_service_action(struct server *server, const char *action)
{
- sd_bus_error error = SD_BUS_ERROR_NULL;
- sd_bus_message *m = NULL;
+ sd_bus_error error = SD_BUS_ERROR_NULL;
+ sd_bus_message *m = NULL;
sd_bus *bus = get_bus();
const char *path;
bool performed = false;
int r;
- assert_return(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,
- server->systemd_obj,
- SYSTEMD_DBUS_INTERFACE,
- action,
- &error,
- &m,
- "s",
+ r = sd_bus_call_method(bus, SYSTEMD_DBUS_SERVICE, server->systemd_obj,
+ SYSTEMD_DBUS_INTERFACE, action, &error, &m, "s",
"fail");
- if (r < 0) {
- error("failed to perform action %s on systemd service %s: %s",
+ if (r < 0) {
+ error("failed to perform action %s on systemd service %s: %s",
action, server->systemd_service, error.message);
goto out;
- }
+ }
- r = sd_bus_message_read(m, "o", &path);
- if (r < 0) {
- error("failed to parse response message: %s", strerror(-r));
+ r = sd_bus_message_read(m, "o", &path);
+ if (r < 0) {
+ error("failed to parse response message: %s", strerror(-r));
goto out;
- }
+ }
- verbose("action %s queued for service %s",
- action, server->systemd_service);
+ verbose("action %s queued for service %s", action,
+ server->systemd_service);
performed = true;
out:
- sd_bus_error_free(&error);
- sd_bus_message_unref(m);
+ sd_bus_error_free(&error);
+ sd_bus_message_unref(m);
return performed;
}
/*
* Stop systemd service.
*
- * This is equivalent to (assuming service minecraft@world1):
- * gdbus call --session
- * --dest org.freedesktop.systemd1
- * --object-path /org/freedesktop/systemd1/unit/minecraft_40world1_2eservice
+ * This is equivalent to (assuming service mc@world1):
+ * gdbus call --session
+ * --dest org.freedesktop.systemd1
+ * --object-path /org/freedesktop/systemd1/unit/mc_40world1_2eservice
* --method org.freedesktop.systemd1.Unit.Stop "fail"
*/
-bool
-systemd_service_stop(struct server *server)
+bool systemd_service_stop(struct server *server)
{
assert_return(server, false);
@@ -203,17 +192,15 @@ systemd_service_stop(struct server *server)
/*
* Start systemd service.
*
- * This is equivalent to (assuming service minecraft@world1):
- * gdbus call --session
- * --dest org.freedesktop.systemd1
- * --object-path /org/freedesktop/systemd1/unit/minecraft_40world1_2eservice
+ * This is equivalent to (assuming service mc@world1):
+ * gdbus call --session
+ * --dest org.freedesktop.systemd1
+ * --object-path /org/freedesktop/systemd1/unit/mc_40world1_2eservice
* --method org.freedesktop.systemd1.Unit.Start "fail"
*/
-bool
-systemd_service_start(struct server *server)
+bool systemd_service_start(struct server *server)
{
assert_return(server, false);
return systemd_service_action(server, "Start");
}
-
diff --git a/minecproxy/uring.c b/minecproxy/uring.c
index abea592..dd0d28a 100644
--- a/minecproxy/uring.c
+++ b/minecproxy/uring.c
@@ -19,23 +19,24 @@ struct uring_ev {
int tfd;
};
+/* clang-format off */
enum cqe_type {
CQE_TYPE_NORMAL = 0x0,
CQE_TYPE_CANCEL = 0x1,
CQE_TYPE_CLOSE = 0x2,
CQE_TYPE_POLL_CANCEL = 0x3
};
+/* clang-format on */
#define CQE_TYPE_PTR_MASK 0x3
uint64_t sqe_count = 0;
uint64_t cqe_count = 0;
-static struct io_uring_sqe *
-get_sqe(struct uring_task *task)
+static struct io_uring_sqe *get_sqe(struct uring_task *task)
{
struct io_uring_sqe *sqe;
-
+
assert_die(task, "invalid arguments");
sqe = io_uring_get_sqe(&cfg->uring->uring);
@@ -51,8 +52,7 @@ get_sqe(struct uring_task *task)
return sqe;
}
-void
-uring_task_refdump(struct uring_task *task)
+void uring_task_refdump(struct uring_task *task)
{
char buf[4096];
struct uring_task *tmp;
@@ -83,45 +83,43 @@ uring_task_refdump(struct uring_task *task)
memcpy(dst, tmp->name, strlen(tmp->name));
}
- info("%s (0x%p parent 0x%p free 0x%p fd %i ref %u)",
- buf, task, task->parent, task->free, task->fd,
- task->refcount);
+ info("%s (0x%p parent 0x%p free 0x%p fd %i ref %u)", buf, task,
+ task->parent, task->free, task->fd, task->refcount);
}
/*
* Similar to uring_task_put, but can be called from other tasks
* while the task is active.
*/
-void
-uring_task_destroy(struct uring_task *task)
+void uring_task_destroy(struct uring_task *task)
{
assert_return(task);
assert_return_silent(!task->dead);
- debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
- task->name, task, task->fd, task->refcount);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
if (task->fd >= 0) {
struct io_uring_sqe *sqe;
-
+
sqe = get_sqe(task);
io_uring_prep_cancel(sqe, task, 0);
- io_uring_sqe_set_data(sqe, (void *)((uintptr_t)task | CQE_TYPE_CANCEL));
+ io_uring_sqe_set_data(sqe, (void *)((uintptr_t)task |
+ CQE_TYPE_CANCEL));
}
task->dead = true;
uring_task_put(task);
}
-void
-uring_task_put(struct uring_task *task)
+void uring_task_put(struct uring_task *task)
{
struct uring_task *parent;
assert_return(task);
- debug(DBG_REF, "task %s (%p), refcount %u -> %u",
- task->name, task, task->refcount, task->refcount - 1);
+ debug(DBG_REF, "task %s (%p), refcount %u -> %u", task->name, task,
+ task->refcount, task->refcount - 1);
task->refcount--;
@@ -147,13 +145,12 @@ uring_task_put(struct uring_task *task)
}
}
-void
-uring_task_get(struct uring_task *task)
+void uring_task_get(struct uring_task *task)
{
assert_return(task);
- debug(DBG_REF, "task %s (%p), refcount %u -> %u",
- task->name, task, task->refcount, task->refcount + 1);
+ debug(DBG_REF, "task %s (%p), refcount %u -> %u", task->name, task,
+ task->refcount, task->refcount + 1);
if (task->refcount < 0)
error("Negative refcount!");
@@ -161,17 +158,16 @@ uring_task_get(struct uring_task *task)
task->refcount++;
}
-void
-uring_task_set_buf(struct uring_task *task, struct uring_task_buf *tbuf)
+void uring_task_set_buf(struct uring_task *task, struct uring_task_buf *tbuf)
{
assert_return(task && tbuf);
- debug(DBG_UR, "task %s (%p), buf %p, refcount %u",
- task->name, task, tbuf, task->refcount);
+ debug(DBG_UR, "task %s (%p), buf %p, refcount %u", task->name, task,
+ tbuf, task->refcount);
/* iov_len and msg_namelen are set at send/receive time */
tbuf->iov.iov_base = tbuf->buf;
- tbuf->msg.msg_name = &task->saddr.storage;
+ tbuf->msg.msg_name = &task->saddr.st;
tbuf->msg.msg_iov = &tbuf->iov;
tbuf->msg.msg_iovlen = 1;
tbuf->msg.msg_control = NULL;
@@ -180,24 +176,22 @@ uring_task_set_buf(struct uring_task *task, struct uring_task_buf *tbuf)
task->tbuf = tbuf;
}
-void
-uring_task_set_fd(struct uring_task *task, int fd)
+void uring_task_set_fd(struct uring_task *task, int fd)
{
assert_return(task);
- debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
- task->name, task, fd, task->refcount);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task, fd,
+ task->refcount);
task->fd = fd;
}
-void
-uring_task_close_fd(struct uring_task *task)
+void uring_task_close_fd(struct uring_task *task)
{
assert_return(task);
- debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
- task->name, task, task->fd, task->refcount);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
if (task->fd < 0)
return;
@@ -206,17 +200,16 @@ uring_task_close_fd(struct uring_task *task)
task->fd = -1;
}
-struct uring_task *
-uring_parent()
+struct uring_task *uring_parent()
{
assert_die(cfg->uring, "invalid arguments");
return &cfg->uring->task;
}
-void
-uring_task_init(struct uring_task *task, const char *name,
- struct uring_task *parent, void (*free)(struct uring_task *))
+void uring_task_init(struct uring_task *task, const char *name,
+ struct uring_task *parent,
+ void (*free)(struct uring_task *))
{
static bool first = true;
@@ -236,38 +229,37 @@ uring_task_init(struct uring_task *task, const char *name,
task->tbuf = NULL;
if (task->parent) {
- debug(DBG_REF, "task %s (%p), refcount %u, "
+ debug(DBG_REF,
+ "task %s (%p), refcount %u, "
"getting parent %s (%p), refcount %u",
- task->name, task, task->refcount,
- task->parent->name, task->parent, task->parent->refcount);
+ task->name, task, task->refcount, task->parent->name,
+ task->parent, task->parent->refcount);
uring_task_get(task->parent);
}
}
-void
-uring_close(struct uring_task *task, int fd)
+void uring_close(struct uring_task *task, int fd)
{
struct io_uring_sqe *sqe;
assert_return(task && fd >= 0);
- debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
- task->name, task, task->fd, task->refcount);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
- sqe = get_sqe(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 uring_task *task, int res)
+static void uring_tbuf_write_cb(struct uring_task *task, int res)
{
int r;
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);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
if (res < 0) {
r = res;
@@ -282,52 +274,51 @@ uring_tbuf_write_cb(struct uring_task *task, int res)
}
uring_write(task, task->tbuf->buf + task->tbuf->done,
- task->tbuf->len - task->tbuf->done,
- uring_tbuf_write_cb);
+ task->tbuf->len - task->tbuf->done, uring_tbuf_write_cb);
return;
finished:
task->final_cb(task, r);
}
-void
-uring_tbuf_write(struct uring_task *task, utask_cb_t final_cb)
+void uring_tbuf_write(struct uring_task *task, utask_cb_t final_cb)
{
- assert_return(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);
+ 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(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 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)
{
struct io_uring_sqe *sqe;
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);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
- sqe = get_sqe(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 uring_task *task, int res)
+static void uring_tbuf_read_until_cb(struct uring_task *task, int res)
{
int r;
- assert_return(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);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
if (res < 0) {
r = res;
@@ -359,14 +350,14 @@ finished:
task->final_cb(task, r);
}
-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(struct uring_task *task, rutask_cb_t is_complete_cb,
+ utask_cb_t final_cb)
{
- assert_return(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);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
task->tbuf->len = 0;
task->is_complete_cb = is_complete_cb;
@@ -375,8 +366,7 @@ uring_tbuf_read_until(struct uring_task *task,
uring_tbuf_read_until_cb);
}
-static int
-uring_tbuf_eof(struct uring_task *task, int res)
+static int uring_tbuf_eof(struct uring_task *task, int res)
{
assert_return(task && task->tbuf, -EINVAL);
assert_task_alive_or(DBG_UR, task, return -EINTR);
@@ -392,17 +382,14 @@ uring_tbuf_eof(struct uring_task *task, int res)
return 1;
}
-void
-uring_tbuf_read_until_eof(struct uring_task *task,
- utask_cb_t final_cb)
+void uring_tbuf_read_until_eof(struct uring_task *task, utask_cb_t final_cb)
{
assert_return(task && task->tbuf && final_cb);
uring_tbuf_read_until(task, uring_tbuf_eof, final_cb);
}
-static int
-uring_tbuf_have_data(struct uring_task *task, int res)
+static int uring_tbuf_have_data(struct uring_task *task, int res)
{
assert_return(task, -EINVAL);
@@ -412,23 +399,22 @@ uring_tbuf_have_data(struct uring_task *task, int res)
return 1;
}
-void
-uring_tbuf_read(struct uring_task *task, utask_cb_t final_cb)
+void uring_tbuf_read(struct uring_task *task, utask_cb_t final_cb)
{
assert_return(task && final_cb);
uring_tbuf_read_until(task, uring_tbuf_have_data, final_cb);
}
-void
-uring_read_offset(struct uring_task *task, void *buf, size_t len, off_t offset, utask_cb_t cb)
+void 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(task && buf && len > 0 && task->fd >= 0);
- debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
- task->name, task, task->fd, task->refcount);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
sqe = get_sqe(task);
task->cb = cb;
@@ -436,15 +422,14 @@ uring_read_offset(struct uring_task *task, void *buf, size_t len, off_t offset,
io_uring_sqe_set_data(sqe, task);
}
-void
-uring_openat(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)
{
struct io_uring_sqe *sqe;
-
+
assert_return(task && !empty_str(path) && cb);
- debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
- task->name, task, task->fd, task->refcount);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
sqe = get_sqe(task);
task->cb = cb;
@@ -452,15 +437,14 @@ uring_openat(struct uring_task *task, const char *path, utask_cb_t cb)
io_uring_sqe_set_data(sqe, task);
}
-void
-uring_tbuf_recvmsg(struct uring_task *task, utask_cb_t cb)
+void uring_tbuf_recvmsg(struct uring_task *task, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
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);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
sqe = get_sqe(task);
task->tbuf->done = 0;
@@ -472,15 +456,14 @@ uring_tbuf_recvmsg(struct uring_task *task, utask_cb_t cb)
io_uring_sqe_set_data(sqe, task);
}
-void
-uring_tbuf_sendmsg(struct uring_task *task, utask_cb_t cb)
+void uring_tbuf_sendmsg(struct uring_task *task, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
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);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
sqe = get_sqe(task);
task->tbuf->done = 0;
@@ -491,44 +474,43 @@ uring_tbuf_sendmsg(struct uring_task *task, utask_cb_t cb)
io_uring_sqe_set_data(sqe, task);
}
-void
-uring_connect(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)
{
struct io_uring_sqe *sqe;
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);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
sqe = get_sqe(task);
task->cb = cb;
- io_uring_prep_connect(sqe, task->fd, (struct sockaddr *)&saddr->storage, saddr->addrlen);
+ io_uring_prep_connect(sqe, task->fd, (struct sockaddr *)&saddr->st,
+ saddr->addrlen);
io_uring_sqe_set_data(sqe, task);
}
-void
-uring_accept(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)
{
struct io_uring_sqe *sqe;
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);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
sqe = get_sqe(task);
- saddr->addrlen = sizeof(saddr->storage);
+ saddr->addrlen = sizeof(saddr->st);
task->cb = cb;
- io_uring_prep_accept(sqe, task->fd, (struct sockaddr *)&saddr->storage, &saddr->addrlen, SOCK_CLOEXEC);
+ io_uring_prep_accept(sqe, task->fd, (struct sockaddr *)&saddr->st,
+ &saddr->addrlen, SOCK_CLOEXEC);
io_uring_sqe_set_data(sqe, task);
}
-void
-uring_splice(struct uring_task *task, int fd_in, int fd_out, utask_cb_t cb)
+void uring_splice(struct uring_task *task, int fd_in, int fd_out, utask_cb_t cb)
{
struct io_uring_sqe *sqe;
-
+
assert_return(task && fd_in >= 0 && fd_out >= 0 && cb);
debug(DBG_UR, "task %s (%p), fd_in %i, fd_out %i, refcount %u",
@@ -540,15 +522,14 @@ uring_splice(struct uring_task *task, int fd_in, int fd_out, utask_cb_t cb)
io_uring_sqe_set_data(sqe, task);
}
-void
-uring_poll(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)
{
struct io_uring_sqe *sqe;
-
+
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);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
sqe = get_sqe(task);
task->cb = cb;
@@ -556,11 +537,10 @@ uring_poll(struct uring_task *task, short poll_mask, utask_cb_t cb)
io_uring_sqe_set_data(sqe, task);
}
-void
-uring_poll_cancel(struct uring_task *task)
+void uring_poll_cancel(struct uring_task *task)
{
struct io_uring_sqe *sqe;
-
+
assert_return(task);
if (task->fd < 0) {
@@ -568,54 +548,51 @@ uring_poll_cancel(struct uring_task *task)
return;
}
- debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
- task->name, task, task->fd, task->refcount);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
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));
+ io_uring_sqe_set_data(sqe,
+ (void *)((uintptr_t)task | CQE_TYPE_POLL_CANCEL));
}
-static void
-uring_free(struct uring_task *task)
+static void uring_free(struct uring_task *task)
{
struct uring_ev *uring = container_of(task, struct uring_ev, task);
assert_return(task);
- debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
- task->name, task, task->fd, task->refcount);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
io_uring_queue_exit(&uring->uring);
cfg->uring = NULL;
xfree(uring);
}
-void
-uring_refdump()
+void uring_refdump()
{
assert_return(cfg->uring);
uring_task_refdump(&cfg->uring->task);
}
-void
-uring_delete()
+void uring_delete()
{
struct uring_task *task;
assert_return(cfg->uring);
task = &cfg->uring->task;
- debug(DBG_UR, "task %s (%p), fd %i, refcount %u",
- task->name, task, task->fd, task->refcount);
+ debug(DBG_UR, "task %s (%p), fd %i, refcount %u", task->name, task,
+ task->fd, task->refcount);
uring_task_put(task);
}
-static void
-uring_splice_test_cb(struct uring_task *task, int res)
+static void uring_splice_test_cb(struct uring_task *task, int res)
{
struct uring_ev *uring = container_of(task, struct uring_ev, task);
@@ -634,12 +611,11 @@ uring_splice_test_cb(struct uring_task *task, int res)
debug(DBG_UR, "splice supported");
} else if (res == -EINVAL)
debug(DBG_UR, "splice not supported");
- else
+ else
error("splice check failed: %i\n", res);
}
-void
-uring_init()
+void uring_init()
{
struct uring_ev *uring;
@@ -649,7 +625,8 @@ uring_init()
if (!uring)
die("malloc: %m");
- if (io_uring_queue_init_params(4096, &uring->uring, &uring->uring_params) < 0)
+ if (io_uring_queue_init_params(4096, &uring->uring,
+ &uring->uring_params) < 0)
die("io_uring_queue_init_params");
debug(DBG_UR, "uring initialized, features: 0x%08x",
@@ -665,28 +642,23 @@ uring_init()
uring->tfd = open("/dev/null", O_RDONLY | O_CLOEXEC | O_NOCTTY);
if (uring->tfd < 0)
die("open(\"/dev/null\"): %m");
- uring_splice(&uring->task, uring->tfd, uring->pipe[PIPE_WR], uring_splice_test_cb);
+ uring_splice(&uring->task, uring->tfd, uring->pipe[PIPE_WR],
+ uring_splice_test_cb);
}
-static inline void
-uring_print_cqe(const char *type, struct uring_task *task,
- struct io_uring_cqe *cqe)
+static inline void uring_print_cqe(const char *type, struct uring_task *task,
+ struct io_uring_cqe *cqe)
{
assert_return(!empty_str(type) && task && cqe);
- debug(DBG_UR, "got CQE "
+ debug(DBG_UR,
+ "got CQE "
"(type: %s, res: %i (%s), task: %s (%p), fd: %i, cb: %p)",
- type,
- cqe->res,
- cqe->res < 0 ? strerror(-cqe->res) : "ok",
- task->name ? task->name : "<none>",
- task,
- task->fd,
- task->cb);
+ type, cqe->res, cqe->res < 0 ? strerror(-cqe->res) : "ok",
+ task->name ? task->name : "<none>", task, task->fd, task->cb);
}
-void
-uring_event_loop()
+void uring_event_loop()
{
while (true) {
struct io_uring_cqe *cqe;
@@ -703,7 +675,8 @@ uring_event_loop()
}
nr = 0;
- io_uring_for_each_cqe(&cfg->uring->uring, head, cqe) {
+ io_uring_for_each_cqe(&cfg->uring->uring, head, cqe)
+ {
struct uring_task *task = io_uring_cqe_get_data(cqe);
bool do_cb;
enum cqe_type cqe_type;
@@ -755,4 +728,3 @@ uring_event_loop()
io_uring_cq_advance(&cfg->uring->uring, nr);
}
}
-
diff --git a/minecproxy/uring.h b/minecproxy/uring.h
index 9c33104..c465904 100644
--- a/minecproxy/uring.h
+++ b/minecproxy/uring.h
@@ -30,18 +30,18 @@ void uring_tbuf_write(struct uring_task *task, utask_cb_t final_cb);
void uring_write(struct uring_task *task, void *buf, size_t len, utask_cb_t cb);
-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(struct uring_task *task, rutask_cb_t is_complete_cb,
+ 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 uring_task *task, utask_cb_t final_cb);
-void uring_read_offset(struct uring_task *task, void *buf,
- size_t len, off_t offset, utask_cb_t cb);
+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 uring_task *task, void *buf, size_t len, utask_cb_t cb)
+static inline void uring_read(struct uring_task *task, void *buf, size_t len,
+ utask_cb_t cb)
{
uring_read_offset(task, buf, len, 0, cb);
}
@@ -56,7 +56,8 @@ void uring_connect(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_splice(struct uring_task *task, int fd_in, int fd_out, utask_cb_t cb);
+void uring_splice(struct uring_task *task, int fd_in, int fd_out,
+ utask_cb_t cb);
void uring_poll(struct uring_task *task, short poll_mask, utask_cb_t cb);
generated by cgit v1.2.3 (git 2.39.1) at 2025-11-04 07:46:01 +0000