From d3352b997ca59a336a40fe6660c6e5b7079864aa Mon Sep 17 00:00:00 2001 From: David Härdeman Date: Sun, 28 Jun 2020 14:58:32 +0200 Subject: Run clang-format on source tree (excl igmp.c) --- minecproxy/announce.c | 31 ++--- minecproxy/idle.c | 42 +++---- minecproxy/igmp.c | 115 +++++++++++------- minecproxy/main.c | 105 ++++++++-------- minecproxy/main.h | 2 +- minecproxy/misc.c | 124 +++++++++---------- minecproxy/misc.h | 7 +- minecproxy/ptimer.c | 59 ++++----- minecproxy/ptimer.h | 5 +- minecproxy/server-config.c | 158 ++++++++++++------------ minecproxy/server-proxy.c | 185 ++++++++++++++-------------- minecproxy/server-proxy.h | 2 +- minecproxy/server-rcon.c | 64 ++++------ minecproxy/server.c | 231 +++++++++++++++++------------------ minecproxy/server.h | 5 +- minecproxy/signal-handler.c | 31 ++--- minecproxy/systemd.c | 133 +++++++++----------- minecproxy/uring.c | 290 ++++++++++++++++++++------------------------ minecproxy/uring.h | 15 +-- 19 files changed, 759 insertions(+), 845 deletions(-) (limited to 'minecproxy') 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 )"); 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, ""); 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 : ""); - verbose(" * Announce port: %" PRIu16, server->announce_port); + verbose(" * Name: %s", + server->pretty_name ? server->pretty_name : ""); + 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 : "", - task, - task->fd, - task->cb); + type, cqe->res, cqe->res < 0 ? strerror(-cqe->res) : "ok", + task->name ? task->name : "", 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); -- cgit v1.2.3