diff --git a/distro/pkg/deb/libknot11.symbols b/distro/pkg/deb/libknot11.symbols
index 00b15d07a11f6c9421b836b50674c55efb3e70ff..bd64c18b0926c480dbb8c07b57ea880aaf02cc55 100644
--- a/distro/pkg/deb/libknot11.symbols
+++ b/distro/pkg/deb/libknot11.symbols
@@ -188,8 +188,8 @@ libknot.so.11 libknot11 #MINVER#
knot_xdp_send_free@Base 3.1.0
knot_xdp_send_prepare@Base 3.0.0
knot_xdp_socket_fd@Base 3.0.0
- knot_xdp_tcp_relay@Base 3.1.0
- knot_xdp_tcp_send@Base 3.1.0
+ knot_tcp_relay@Base 3.1.0
+ knot_tcp_send@Base 3.1.0
yp_addr@Base 3.0.0
yp_addr_noport@Base 3.0.0
yp_addr_noport_to_bin@Base 3.0.0
diff --git a/src/knot/server/xdp-handler.c b/src/knot/server/xdp-handler.c
index bd2ff092a0d1a1c48dff9e950b53e51f9def2d8e..1837edd54e75c59426bf657742d856b386b3a3df 100644
--- a/src/knot/server/xdp-handler.c
+++ b/src/knot/server/xdp-handler.c
@@ -175,7 +175,7 @@ int xdp_handle_msgs(xdp_handle_ctx_t *ctx, knot_xdp_socket_t *sock,
}
// handle TCP messages
- int ret = knot_xdp_tcp_relay(sock, ctx->msg_recv, ctx->msg_recv_count, ctx->tcp_table, NULL, &ctx->tcp_relays);
+ int ret = knot_tcp_relay(sock, ctx->msg_recv, ctx->msg_recv_count, ctx->tcp_table, NULL, &ctx->tcp_relays);
if (ret == KNOT_EOK && ctx->tcp_relays.size > 0) {
uint8_t ans_buf[KNOT_WIRE_MAX_PKTSIZE];
@@ -191,7 +191,7 @@ int xdp_handle_msgs(xdp_handle_ctx_t *ctx, knot_xdp_socket_t *sock,
continue;
}
- ret = knot_xdp_tcp_send_data(&ctx->tcp_relays, rl, ans->wire, ans->size);
+ ret = knot_tcp_send_data(&ctx->tcp_relays, rl, ans->wire, ans->size);
if (ret != KNOT_EOK) {
layer->state = KNOT_STATE_FAIL;
}
@@ -220,13 +220,13 @@ int xdp_handle_send(xdp_handle_ctx_t *ctx, knot_xdp_socket_t *xdp_sock)
int ret = knot_xdp_send(xdp_sock, ctx->msg_send_udp, ctx->msg_udp_count, &unused);
if (ret == KNOT_EOK) {
if (ctx->tcp_relays.size > 0) {
- ret = knot_xdp_tcp_send(xdp_sock, knot_tcp_relay_dynarray_arr(&ctx->tcp_relays), ctx->tcp_relays.size);
+ ret = knot_tcp_send(xdp_sock, knot_tcp_relay_dynarray_arr(&ctx->tcp_relays), ctx->tcp_relays.size);
} else {
ret = knot_xdp_send_finish(xdp_sock);
}
}
- knot_xdp_tcp_relay_free(&ctx->tcp_relays);
+ knot_tcp_relay_free(&ctx->tcp_relays);
if (ret == KNOT_EOK) {
ret = xdp_handle_timeout(ctx, xdp_sock);
@@ -240,10 +240,10 @@ int xdp_handle_timeout(xdp_handle_ctx_t *ctx, knot_xdp_socket_t *xdp_sock)
uint32_t last_reset = 0, last_close = 0;
int ret = KNOT_EOK;
do {
- ret = knot_xdp_tcp_timeout(ctx->tcp_table, xdp_sock, 20, ctx->tcp_idle_close, ctx->tcp_idle_reset,
- overweight(ctx->tcp_table->usage, ctx->tcp_max_conns),
- overweight(ctx->tcp_table->inbufs_total, ctx->tcp_max_inbufs),
- &last_close, &last_reset);
+ ret = knot_tcp_sweep(ctx->tcp_table, xdp_sock, 20, ctx->tcp_idle_close, ctx->tcp_idle_reset,
+ overweight(ctx->tcp_table->usage, ctx->tcp_max_conns),
+ overweight(ctx->tcp_table->inbufs_total, ctx->tcp_max_inbufs),
+ &last_close, &last_reset);
} while (last_reset > 0 && ret == KNOT_EOK);
if (last_close > 0 || last_reset > 0) {
diff --git a/src/libknot/xdp/tcp.c b/src/libknot/xdp/tcp.c
index 49c7081a32946fdaa7f12da0e93b5a40ff6d47b4..7f4f0f0fa0c9941ccdfcf33206b6ada884eb7687 100644
--- a/src/libknot/xdp/tcp.c
+++ b/src/libknot/xdp/tcp.c
@@ -198,9 +198,9 @@ static bool check_seq_ack(const knot_xdp_msg_t *msg, const knot_tcp_conn_t *conn
}
_public_
-int knot_xdp_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_t msg_count,
- knot_tcp_table_t *tcp_table, knot_tcp_table_t *syn_table,
- knot_tcp_relay_dynarray_t *relays)
+int knot_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_t msg_count,
+ knot_tcp_table_t *tcp_table, knot_tcp_table_t *syn_table,
+ knot_tcp_relay_dynarray_t *relays)
{
if (msg_count == 0) {
return KNOT_EOK;
@@ -371,8 +371,8 @@ int knot_xdp_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_
}
_public_
-int knot_xdp_tcp_send_data(knot_tcp_relay_dynarray_t *relays, const knot_tcp_relay_t *relay,
- void *data, size_t data_len)
+int knot_tcp_send_data(knot_tcp_relay_dynarray_t *relays, const knot_tcp_relay_t *relay,
+ void *data, size_t data_len)
{
if (relays == NULL || relay == NULL || data == NULL) {
return KNOT_EINVAL;
@@ -412,7 +412,7 @@ int knot_xdp_tcp_send_data(knot_tcp_relay_dynarray_t *relays, const knot_tcp_rel
}
_public_
-void knot_xdp_tcp_relay_free(knot_tcp_relay_dynarray_t *relays)
+void knot_tcp_relay_free(knot_tcp_relay_dynarray_t *relays)
{
if (relays == NULL) {
return;
@@ -428,8 +428,7 @@ void knot_xdp_tcp_relay_free(knot_tcp_relay_dynarray_t *relays)
}
_public_
-int knot_xdp_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[],
- uint32_t relay_count)
+int knot_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[], uint32_t relay_count)
{
if (relay_count == 0) {
return KNOT_EOK;
@@ -520,11 +519,10 @@ int knot_xdp_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[],
}
_public_
-int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
- uint32_t max_at_once,
- uint32_t close_timeout, uint32_t reset_timeout,
- uint32_t reset_at_least, size_t reset_inbufs,
- uint32_t *close_count, uint32_t *reset_count)
+int knot_tcp_sweep(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
+ uint32_t max_at_once, uint32_t close_timeout, uint32_t reset_timeout,
+ uint32_t reset_at_least, size_t reset_buf_size,
+ uint32_t *close_count, uint32_t *reset_count)
{
if (tcp_table == NULL) {
return KNOT_EINVAL;
@@ -541,14 +539,14 @@ int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
WALK_LIST_DELSAFE(conn, next, *tcp_table_timeout(tcp_table)) {
if (i++ < reset_at_least ||
now - conn->last_active >= reset_timeout ||
- (reset_inbufs > 0 && conn->inbuf.iov_len > 0)) {
+ (reset_buf_size > 0 && conn->inbuf.iov_len > 0)) {
rl.answer = XDP_TCP_RESET;
// move this conn into to-remove list
rem_node((node_t *)conn);
add_tail(&to_remove, (node_t *)conn);
- reset_inbufs -= MIN(reset_inbufs, conn->inbuf.iov_len);
+ reset_buf_size -= MIN(reset_buf_size, conn->inbuf.iov_len);
} else if (now - conn->last_active >= close_timeout) {
if (conn->state != XDP_TCP_CLOSING) {
rl.answer = XDP_TCP_CLOSE;
@@ -556,7 +554,7 @@ int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
(*close_count)++;
}
}
- } else if (reset_inbufs == 0) {
+ } else if (reset_buf_size == 0) {
break;
}
@@ -568,7 +566,7 @@ int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
}
if (ret == KNOT_EOK) {
- ret = knot_xdp_tcp_send(socket, knot_tcp_relay_dynarray_arr(&relays), relays.size);
+ ret = knot_tcp_send(socket, knot_tcp_relay_dynarray_arr(&relays), relays.size);
}
// immediately remove resetted connections
@@ -581,6 +579,6 @@ int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
}
}
- knot_xdp_tcp_relay_free(&relays);
+ knot_tcp_relay_free(&relays);
return ret;
}
diff --git a/src/libknot/xdp/tcp.h b/src/libknot/xdp/tcp.h
index 48c77160fb63dfffaaffdc3b0a60b2dddcd56649..2540e73d431af58520b515dbb0de7cbabd30edb6 100644
--- a/src/libknot/xdp/tcp.h
+++ b/src/libknot/xdp/tcp.h
@@ -51,7 +51,7 @@ typedef enum {
XDP_TCP_FREE_PREFIX,
} knot_tcp_relay_free_t;
-typedef struct knot_xdp_tcp_conn {
+typedef struct knot_tcp_conn {
struct {
void *list_node_placeholder1;
void *list_node_placeholder2;
@@ -67,7 +67,7 @@ typedef struct knot_xdp_tcp_conn {
uint32_t last_active;
knot_tcp_state_t state;
struct iovec inbuf;
- struct knot_xdp_tcp_conn *next;
+ struct knot_tcp_conn *next;
} knot_tcp_conn_t;
typedef struct {
@@ -134,9 +134,9 @@ void knot_tcp_table_free(knot_tcp_table_t *table);
*
* \return KNOT_E*
*/
-int knot_xdp_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_t msg_count,
- knot_tcp_table_t *tcp_table, knot_tcp_table_t *syn_table,
- knot_tcp_relay_dynarray_t *relays);
+int knot_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_t msg_count,
+ knot_tcp_table_t *tcp_table, knot_tcp_table_t *syn_table,
+ knot_tcp_relay_dynarray_t *relays);
/*!
* \brief Answer one relay with one or more relays with data payload.
@@ -148,13 +148,13 @@ int knot_xdp_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_
*
* \return KNOT_EOK, KNOT_ENOMEM
*/
-int knot_xdp_tcp_send_data(knot_tcp_relay_dynarray_t *relays, const knot_tcp_relay_t *relay,
- void *data, size_t data_len);
+int knot_tcp_send_data(knot_tcp_relay_dynarray_t *relays, const knot_tcp_relay_t *relay,
+ void *data, size_t data_len);
/*!
* \brief Free resources in 'relays'.
*/
-void knot_xdp_tcp_relay_free(knot_tcp_relay_dynarray_t *relays);
+void knot_tcp_relay_free(knot_tcp_relay_dynarray_t *relays);
/*!
* \brief Send TCP packets.
@@ -165,8 +165,7 @@ void knot_xdp_tcp_relay_free(knot_tcp_relay_dynarray_t *relays);
*
* \return KNOT_E*
*/
-int knot_xdp_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[],
- uint32_t relay_count);
+int knot_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[], uint32_t relay_count);
/*!
* \brief Cleanup old TCP connections, perform timeout checks.
@@ -178,17 +177,16 @@ int knot_xdp_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[],
* \param reset_timeout Reset connections older than this (usecs).
* \param reset_at_least Reset at least this number of oldest conecctions, even
* when not yet timeouted.
- * \param reset_inbufs Reset oldest connection with buffered partial DNS messages
+ * \param reset_buf_size Reset oldest connection with buffered partial DNS messages
* to free up this amount of space.
* \param close_count Optional: Out: number of closed connections.
* \param reset_count Optional: Out: number of reset connections.
*
* \return KNOT_E*
*/
-int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
- uint32_t max_at_once,
- uint32_t close_timeout, uint32_t reset_timeout,
- uint32_t reset_at_least, size_t reset_inbufs,
- uint32_t *close_count, uint32_t *reset_count);
+int knot_tcp_sweep(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
+ uint32_t max_at_once, uint32_t close_timeout, uint32_t reset_timeout,
+ uint32_t reset_at_least, size_t reset_buf_size,
+ uint32_t *close_count, uint32_t *reset_count);
/*! @} */
diff --git a/src/utils/kxdpgun/main.c b/src/utils/kxdpgun/main.c
index f90cbf4973d8b2cbc71078c7f86bcf732065acd5..a9de6f31a3f96d09de4481cf600ac77bb55f5681 100644
--- a/src/utils/kxdpgun/main.c
+++ b/src/utils/kxdpgun/main.c
@@ -425,7 +425,7 @@ void *xdp_gun_thread(void *_ctx)
}
if (ctx->tcp) {
knot_tcp_relay_dynarray_t relays = { 0 };
- ret = knot_xdp_tcp_relay(xsk, pkts, recvd, tcp_table, NULL, &relays);
+ ret = knot_tcp_relay(xsk, pkts, recvd, tcp_table, NULL, &relays);
if (ret != KNOT_EOK) {
errors++;
break;
@@ -440,7 +440,7 @@ void *xdp_gun_thread(void *_ctx)
local_stats.synack_recv++;
rl->answer = XDP_TCP_ANSWER | XDP_TCP_DATA;
put_dns_payload(&payl, true, ctx, &payload_ptr);
- (void)knot_xdp_tcp_send_data(&relays, rl, payl.iov_base, payl.iov_len);
+ (void)knot_tcp_send_data(&relays, rl, payl.iov_base, payl.iov_len);
break;
case XDP_TCP_DATA:
if (check_dns_payload(&rl->data, ctx, &local_stats)) {
@@ -458,12 +458,12 @@ void *xdp_gun_thread(void *_ctx)
}
}
- ret = knot_xdp_tcp_send(xsk, knot_tcp_relay_dynarray_arr(&relays), relays.size);
+ ret = knot_tcp_send(xsk, knot_tcp_relay_dynarray_arr(&relays), relays.size);
if (ret != KNOT_EOK) {
errors++;
}
- knot_xdp_tcp_relay_free(&relays);
+ knot_tcp_relay_free(&relays);
} else {
for (int i = 0; i < recvd; i++) {
(void)check_dns_payload(&pkts[i].payload, ctx, &local_stats);
diff --git a/tests/libknot/test_xdp_tcp.c b/tests/libknot/test_xdp_tcp.c
index b43170e987b79bc0b0b402ce650332adc50efe47..784337eb571e7c60a730403051e70ee7e9cda1fd 100644
--- a/tests/libknot/test_xdp_tcp.c
+++ b/tests/libknot/test_xdp_tcp.c
@@ -197,7 +197,7 @@ void test_syn(void)
knot_xdp_msg_t msg;
knot_tcp_relay_dynarray_t relays = { 0 };
prepare_msg(&msg, KNOT_XDP_MSG_SYN, 1, 2);
- int ret = knot_xdp_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
+ int ret = knot_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
is_int(KNOT_EOK, ret, "SYN: relay OK");
is_int(msg.seqno + 1, sent_ackno, "SYN: ackno");
check_sent(0, 0, 1, 0);
@@ -214,7 +214,7 @@ void test_syn(void)
ok(memcmp(&conn->ip_rem, &msg.ip_from, sizeof(msg.ip_from)) == 0, "SYN: conn IP from");
ok(memcmp(&conn->ip_loc, &msg.ip_to, sizeof(msg.ip_to)) == 0, "SYN: conn IP to");
- knot_xdp_tcp_relay_free(&relays);
+ knot_tcp_relay_free(&relays);
test_conn = conn;
}
@@ -224,7 +224,7 @@ void test_establish(void)
knot_tcp_relay_dynarray_t relays = { 0 };
prepare_msg(&msg, KNOT_XDP_MSG_ACK, 1, 2);
prepare_seqack(&msg, 0, 1);
- int ret = knot_xdp_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
+ int ret = knot_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
is_int(KNOT_EOK, ret, "establish: relay OK");
check_sent(0, 0, 0, 0);
is_int(0, relays.size, "establish: no relay");
@@ -234,7 +234,7 @@ void test_establish(void)
ok(rl->conn == test_conn, "establish: same connection");
is_int(XDP_TCP_NORMAL, rl->conn->state, "establish: connection state");*/
- knot_xdp_tcp_relay_free(&relays);
+ knot_tcp_relay_free(&relays);
clean_table();
}
@@ -243,7 +243,7 @@ void test_syn_ack(void)
knot_xdp_msg_t msg;
knot_tcp_relay_dynarray_t relays = { 0 };
prepare_msg(&msg, KNOT_XDP_MSG_SYN | KNOT_XDP_MSG_ACK, 1000, 2000);
- int ret = knot_xdp_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
+ int ret = knot_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
is_int(KNOT_EOK, ret, "SYN+ACK: relay OK");
is_int(msg.seqno + 1, sent_ackno, "SYN+ACK: ackno");
check_sent(1, 0, 0, 0);
@@ -253,7 +253,7 @@ void test_syn_ack(void)
ok(rl->conn != NULL, "SYN+ACK: connection present");
test_conn = rl->conn;
- knot_xdp_tcp_relay_free(&relays);
+ knot_tcp_relay_free(&relays);
}
void test_data_fragments(void)
@@ -281,7 +281,7 @@ void test_data_fragments(void)
prepare_seqack(&msgs[3], 15, 0);
prepare_data(&msgs[3], "\x02""AB""\xff\xff""abcdefghijklmnopqrstuvwxyz...", 34);
- int ret = knot_xdp_tcp_relay(test_sock, msgs, sizeof(msgs) / sizeof(msgs[0]), test_table, NULL, &relays);
+ int ret = knot_tcp_relay(test_sock, msgs, sizeof(msgs) / sizeof(msgs[0]), test_table, NULL, &relays);
is_int(KNOT_EOK, ret, "fragments: relay OK");
is_int(msgs[3].ackno, sent_seqno, "fragments: seqno");
is_int(msgs[3].seqno + msgs[3].payload.iov_len, sent_ackno, "fragments: ackno");
@@ -310,7 +310,7 @@ void test_data_fragments(void)
ok(memcmp("AB", rls[3].data.iov_base, rls[3].data.iov_len) == 0, "fragments3: data");
ok(rls[3].conn == test_conn, "fragments3: same connection");
- knot_xdp_tcp_relay_free(&relays);
+ knot_tcp_relay_free(&relays);
}
void test_close(void)
@@ -321,7 +321,7 @@ void test_close(void)
knot_tcp_relay_dynarray_t relays = { 0 };
prepare_msg(&msg, KNOT_XDP_MSG_FIN | KNOT_XDP_MSG_ACK, be16toh(test_conn->ip_rem.sin6_port), be16toh(test_conn->ip_loc.sin6_port));
prepare_seqack(&msg, 0, 0);
- int ret = knot_xdp_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
+ int ret = knot_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
is_int(KNOT_EOK, ret, "close: relay 1 OK");
check_sent(0, 0, 0, 1);
is_int(1, relays.size, "close: one relay");
@@ -329,11 +329,11 @@ void test_close(void)
is_int(XDP_TCP_CLOSE, rl->action, "close: relay action");
ok(rl->conn == test_conn, "close: same connection");
is_int(XDP_TCP_CLOSING, rl->conn->state, "close: conn state");
- knot_xdp_tcp_relay_free(&relays);
+ knot_tcp_relay_free(&relays);
msg.flags &= ~KNOT_XDP_MSG_FIN;
prepare_seqack(&msg, 0, 0);
- ret = knot_xdp_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
+ ret = knot_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
is_int(KNOT_EOK, ret, "close: relay 2 OK");
check_sent(0, 0, 0, 0);
is_int(conns_pre - 1, test_table->usage, "close: connection removed");
@@ -353,33 +353,33 @@ void test_many(void)
}
knot_tcp_relay_dynarray_t relays = { 0 };
- int ret = knot_xdp_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
+ int ret = knot_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
is_int(KNOT_EOK, ret, "many: relay OK");
check_sent(0, 0, CONNS, 0);
is_int(CONNS, relays.size, "many: relays count");
is_int(CONNS, test_table->usage, "many: table usage");
- knot_xdp_tcp_relay_free(&relays);
+ knot_tcp_relay_free(&relays);
usleep(timeout_time);
knot_xdp_msg_t *survive = &msgs[i_survive];
survive->flags = (KNOT_XDP_MSG_TCP | KNOT_XDP_MSG_ACK);
knot_tcp_conn_t *surv_conn = tcp_table_find(test_table, survive);
fix_seqack(survive);
prepare_data(survive, "\x00\x00", 2);
- (void)knot_xdp_tcp_relay(test_sock, survive, 1, test_table, NULL, &relays);
+ (void)knot_tcp_relay(test_sock, survive, 1, test_table, NULL, &relays);
is_int(1, relays.size, "many/survivor: one relay");
knot_tcp_relay_t *rl = &knot_tcp_relay_dynarray_arr(&relays)[0];
clean_sent();
uint32_t reset_count = 0, close_count = 0;
- ret = knot_xdp_tcp_timeout(test_table, test_sock, UINT32_MAX, timeout_time, UINT32_MAX, 0, 0, &close_count, &reset_count);
+ ret = knot_tcp_sweep(test_table, test_sock, UINT32_MAX, timeout_time, UINT32_MAX, 0, 0, &close_count, &reset_count);
is_int(KNOT_EOK, ret, "many/timeout1: OK");
is_int(CONNS - 1, close_count, "many/timeout1: close count");
is_int(0, reset_count, "may/timeout1: reset count");
check_sent(0, 0, 0, CONNS - 1);
close_count = 0;
- ret = knot_xdp_tcp_timeout(test_table, test_sock, UINT32_MAX, UINT32_MAX, timeout_time, 0, 0, &close_count, &reset_count);
+ ret = knot_tcp_sweep(test_table, test_sock, UINT32_MAX, UINT32_MAX, timeout_time, 0, 0, &close_count, &reset_count);
is_int(KNOT_EOK, ret, "many/timeout2: OK");
is_int(0, close_count, "many/timeout2: close count");
is_int(CONNS - 1, reset_count, "may/timeout2: reset count");
@@ -402,7 +402,7 @@ void test_ibufs_size(void)
for (int i = 0; i < CONNS; i++) {
prepare_msg(&msgs[i], KNOT_XDP_MSG_SYN, i + 2000, 1);
}
- int ret = knot_xdp_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
+ int ret = knot_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
is_int(KNOT_EOK, ret, "ibufs: open OK");
check_sent(0, 0, CONNS, 0);
for (int i = 0; i < CONNS; i++) {
@@ -414,11 +414,11 @@ void test_ibufs_size(void)
// first connection will start a fragment buf then finish it
fix_seqack(&msgs[0]);
prepare_data(&msgs[0], "\x00\x0a""lorem", 7);
- ret = knot_xdp_tcp_relay(test_sock, &msgs[0], 1, test_table, NULL, &relays);
+ ret = knot_tcp_relay(test_sock, &msgs[0], 1, test_table, NULL, &relays);
is_int(KNOT_EOK, ret, "ibufs: must be OK");
check_sent(1, 0, 0, 0);
is_int(7, test_table->inbufs_total, "inbufs: first inbuf");
- knot_xdp_tcp_relay_free(&relays);
+ knot_tcp_relay_free(&relays);
// other connection will just store fragments
fix_seqacks(msgs, CONNS);
@@ -426,17 +426,17 @@ void test_ibufs_size(void)
prepare_data(&msgs[1], "\x00\xff""12345", 7);
prepare_data(&msgs[2], "\xff\xff""abcde", 7);
prepare_data(&msgs[3], "\xff\xff""abcde", 7);
- ret = knot_xdp_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
+ ret = knot_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
is_int(KNOT_EOK, ret, "inbufs: relay OK");
check_sent(CONNS, 0, 0, 0);
is_int(21, test_table->inbufs_total, "inbufs: after change");
is_int(1, relays.size, "inbufs: one relay");
is_int(10, knot_tcp_relay_dynarray_arr(&relays)[0].data.iov_len, "inbufs: data length");
- knot_xdp_tcp_relay_free(&relays);
+ knot_tcp_relay_free(&relays);
// now free some
uint32_t reset_count = 0, close_count = 0;
- ret = knot_xdp_tcp_timeout(test_table, test_sock, UINT32_MAX, UINT32_MAX, UINT32_MAX, 0, 8, &close_count, &reset_count);
+ ret = knot_tcp_sweep(test_table, test_sock, UINT32_MAX, UINT32_MAX, UINT32_MAX, 0, 8, &close_count, &reset_count);
is_int(KNOT_EOK, ret, "inbufs: timeout OK");
check_sent(0, 2, 0, 0);
is_int(0, close_count, "inbufs: close count");