From d56cda3d9aadff2bb98529467452d7097bd167cc Mon Sep 17 00:00:00 2001 From: luwenpeng Date: Wed, 30 Oct 2024 17:00:20 +0800 Subject: [PATCH] session manager support output fieldstat --- infra/packet_io/pcap_io.c | 4 +- infra/packet_manager/packet_manager.c | 4 + infra/session_manager/CMakeLists.txt | 6 +- infra/session_manager/session_filter.c | 1 - infra/session_manager/session_filter.h | 5 +- infra/session_manager/session_internal.h | 7 +- infra/session_manager/session_manager.c | 879 +++++----- infra/session_manager/session_manager_cfg.c | 128 ++ infra/session_manager/session_manager_cfg.h | 72 + infra/session_manager/session_manager_log.h | 17 + infra/session_manager/session_manager_rte.c | 1244 ++++++++++++++ infra/session_manager/session_manager_rte.h | 67 + .../session_manager/session_manager_runtime.c | 1464 ----------------- .../session_manager/session_manager_runtime.h | 184 --- infra/session_manager/session_manager_stat.c | 39 + infra/session_manager/session_manager_stat.h | 166 ++ infra/session_manager/session_table.h | 2 + infra/session_manager/session_utils.c | 2 +- infra/session_manager/test/default_config.h | 68 - .../test/gtest_case_tcp_fast_open.cpp | 32 +- .../test/gtest_filter_tcp_dupkt.cpp | 202 ++- .../test/gtest_overload_evict_tcp_sess.cpp | 90 +- .../test/gtest_overload_evict_udp_sess.cpp | 113 +- .../test/gtest_sess_mgr_scan.cpp | 204 ++- .../test/gtest_sess_mgr_tcp_reassembly.cpp | 125 +- .../test/gtest_session_filter.cpp | 5 +- .../test/gtest_session_pool.cpp | 4 +- .../test/gtest_session_table.cpp | 7 +- .../test/gtest_session_timer.cpp | 5 +- .../test/gtest_session_transition.cpp | 4 +- .../gtest_state_tcp_active_to_closing.cpp | 167 +- .../test/gtest_state_tcp_init_to_opening.cpp | 236 +-- ...opening_to_active_to_closing_to_closed.cpp | 81 +- .../gtest_state_tcp_opening_to_active.cpp | 67 +- .../gtest_state_tcp_opening_to_closing.cpp | 236 +-- ...p_init_to_opening_to_active_to_closing.cpp | 39 +- ...t_state_udp_init_to_opening_to_closing.cpp | 56 +- .../test/gtest_timeout_tcp_data.cpp | 36 +- .../test/gtest_timeout_tcp_handshake.cpp | 31 +- .../test/gtest_timeout_tcp_init.cpp | 31 +- .../test/gtest_timeout_udp_data.cpp | 58 +- .../test/{test_packets.h => test_utils.h} | 87 + scripts/CMakeLists.txt | 3 +- scripts/python_stat.sh | 3 - scripts/shell_stat.sh | 59 - scripts/stat_format.sh | 9 + 46 files changed, 3208 insertions(+), 3141 deletions(-) create mode 100644 infra/session_manager/session_manager_cfg.c create mode 100644 infra/session_manager/session_manager_cfg.h create mode 100644 infra/session_manager/session_manager_log.h create mode 100644 infra/session_manager/session_manager_rte.c create mode 100644 infra/session_manager/session_manager_rte.h delete mode 100644 infra/session_manager/session_manager_runtime.c delete mode 100644 infra/session_manager/session_manager_runtime.h create mode 100644 infra/session_manager/session_manager_stat.c create mode 100644 infra/session_manager/session_manager_stat.h delete mode 100644 infra/session_manager/test/default_config.h rename infra/session_manager/test/{test_packets.h => test_utils.h} (98%) delete mode 100644 scripts/python_stat.sh delete mode 100644 scripts/shell_stat.sh create mode 100644 scripts/stat_format.sh diff --git a/infra/packet_io/pcap_io.c b/infra/packet_io/pcap_io.c index ba294f9..3a3cf4e 100644 --- a/infra/packet_io/pcap_io.c +++ b/infra/packet_io/pcap_io.c @@ -333,7 +333,7 @@ static void *pcap_io_thread(void *arg) fclose(fp); } } - PCAP_IO_LOG_FATAL("pcap io thread read all pcap files"); + PACKET_IO_LOG_FATAL("pcap io thread read all pcap files (files: %lu, pkts: %lu)", pcap_io->read_pcap_files, ATOMIC_READ(&pcap_io->read_pcap_pkts)); erro_out: while (ATOMIC_READ(&pcap_io->io_thread_need_exit) == 0) @@ -346,7 +346,7 @@ erro_out: usleep(1000); // 1ms } - PCAP_IO_LOG_FATAL("pcap io thread exit (read_pcap_files: %lu, read_pcap_pkts: %lu)", pcap_io->read_pcap_files, ATOMIC_READ(&pcap_io->read_pcap_pkts)); + PACKET_IO_LOG_FATAL("pcap io thread exit"); ATOMIC_SET(&pcap_io->io_thread_is_runing, 0); return NULL; diff --git a/infra/packet_manager/packet_manager.c b/infra/packet_manager/packet_manager.c index 5623107..be36103 100644 --- a/infra/packet_manager/packet_manager.c +++ b/infra/packet_manager/packet_manager.c @@ -36,6 +36,10 @@ struct packet_manager struct packet_manager_runtime *runtime[MAX_THREAD_NUM]; }; +/****************************************************************************** + * packet manager runtime + ******************************************************************************/ + const char *packet_stage_to_str(enum packet_stage stage) { switch (stage) diff --git a/infra/session_manager/CMakeLists.txt b/infra/session_manager/CMakeLists.txt index a045740..0fa2260 100644 --- a/infra/session_manager/CMakeLists.txt +++ b/infra/session_manager/CMakeLists.txt @@ -5,12 +5,14 @@ add_library(session_manager session_timer.c session_filter.c session_transition.c - session_manager_runtime.c session_manager.c + session_manager_cfg.c + session_manager_rte.c + session_manager_stat.c ) target_include_directories(session_manager PUBLIC ${CMAKE_CURRENT_LIST_DIR}) target_include_directories(session_manager PUBLIC ${CMAKE_SOURCE_DIR}/infra/) target_include_directories(session_manager PUBLIC ${CMAKE_SOURCE_DIR}/include) -target_link_libraries(session_manager timeout packet_manager tcp_reassembly mq exdata) +target_link_libraries(session_manager timeout packet_manager tcp_reassembly mq exdata fieldstat4) add_subdirectory(test) \ No newline at end of file diff --git a/infra/session_manager/session_filter.c b/infra/session_manager/session_filter.c index 6fe0ef1..8a3c40f 100644 --- a/infra/session_manager/session_filter.c +++ b/infra/session_manager/session_filter.c @@ -1,4 +1,3 @@ -#include "tuple.h" #include "dablooms.h" #include "session_filter.h" diff --git a/infra/session_manager/session_filter.h b/infra/session_manager/session_filter.h index 13f5236..f8be6a2 100644 --- a/infra/session_manager/session_filter.h +++ b/infra/session_manager/session_filter.h @@ -5,11 +5,10 @@ extern "C" { #endif +#include "tuple.h" + struct session_filter *session_filter_new(uint32_t capacity, uint32_t timeout, double error_rate, uint64_t now); void session_filter_free(struct session_filter *filter); - -// return 1: found -// reutrn 0: no found int session_filter_lookup(struct session_filter *filter, const struct tuple6 *key, uint64_t now); void session_filter_add(struct session_filter *filter, const struct tuple6 *key, uint64_t now); diff --git a/infra/session_manager/session_internal.h b/infra/session_manager/session_internal.h index 51413dc..34cba4a 100644 --- a/infra/session_manager/session_internal.h +++ b/infra/session_manager/session_internal.h @@ -10,9 +10,10 @@ extern "C" #include "tuple.h" #include "uthash.h" #include "timeout.h" +#include "tcp_reassembly.h" #include "packet_internal.h" #include "stellar/session.h" -#include "tcp_reassembly.h" +#include "session_manager_stat.h" // output format: "${src_addr}:${src_port}-${dst_addr}:${dst_port}-${ip_proto}-${domain}" // output max len: (46 + 1 + 5) + 1 + (46 + 1 + 5) + 1 + 1 + 1 + 20 = 129 @@ -50,7 +51,7 @@ struct session struct tcp_segment empty_seg; TAILQ_ENTRY(session) lru_tqe; TAILQ_ENTRY(session) free_tqe; - TAILQ_ENTRY(session) evicte_tqe; + TAILQ_ENTRY(session) evc_tqe; UT_hash_handle hh1; UT_hash_handle hh2; UT_hash_handle hh3; @@ -68,7 +69,7 @@ struct session enum session_type sess_type; enum session_state state; enum closing_reason reason; - struct session_manager_runtime *sess_mgr_rt; + struct session_manager_rte *sess_mgr_rte; struct session_manager_stat *sess_mgr_stat; }; diff --git a/infra/session_manager/session_manager.c b/infra/session_manager/session_manager.c index 7fd0805..83f84c0 100644 --- a/infra/session_manager/session_manager.c +++ b/infra/session_manager/session_manager.c @@ -1,365 +1,376 @@ #include -#include - -#include "stellar/packet.h" -#include "stellar/session.h" #include "utils_internal.h" #include "session_internal.h" -#include "session_manager_runtime.h" +#include "session_manager_log.h" +#include "session_manager_cfg.h" +#include "session_manager_rte.h" +#include "session_manager_stat.h" +#include "fieldstat/fieldstat_easy.h" -#define MAX_CLEANED_SESS 1024 +#define SYNC_STAT_INTERVAL_MS 1000 +#define CLEAN_SESSION_BURST 1024 #define SESSION_MANAGER_MODULE_NAME "session_manager_module" #pragma GCC diagnostic ignored "-Wunused-parameter" -#pragma GCC diagnostic ignored "-Wunused-function" -struct session_manager_schema +struct session_manager_sche { - struct exdata_schema *exdata; - struct mq_schema *mq; + int pkt_ex_id; + int sess_msg_id_tcp; + int sess_msg_id_udp; + int sess_msg_id_ctrl; + int sess_msg_id_stream; - int pkt_exdata_idx; - - int topic_id_tcp; - int topic_id_udp; - int topic_id_ctrl_pkt; - int topic_id_tcp_stream; + struct mq_schema *mq_sche; + struct exdata_schema *ex_sche; }; struct session_manager { - struct session_manager_config *cfg; - struct session_manager_schema *schema; - struct session_manager_runtime *runtime[MAX_THREAD_NUM]; - struct stellar_module_manager *mod_mgr; + int stat_idx[SESS_MGR_STAT_MAX]; + struct fieldstat_easy *fs; + struct session_manager_cfg *cfg; + struct session_manager_sche *sche; + struct session_manager_rte *rte[MAX_THREAD_NUM]; + struct mq_runtime *mq[MAX_THREAD_NUM]; + struct stellar_module_manager *mod_mgr; }; /****************************************************************************** - * callback + * session manager sche ******************************************************************************/ -static void on_session_message_dispatch(int topic_id, void *msg, on_msg_cb_func *cb, void *cb_args, void *dispatch_args) +static void clean_closed_session(struct session_manager *sess_mgr, uint16_t thread_id, uint64_t now_ms) { - struct session *sess = (struct session *)msg; - struct packet *pkt = (struct packet *)session_get0_current_packet(sess); - enum session_state state = session_get_current_state(sess); + struct session *sess = NULL; + struct session *cleaned[CLEAN_SESSION_BURST] = {NULL}; + struct mq_runtime *mq_rte = sess_mgr->mq[thread_id]; + struct session_manager_rte *sess_mgr_rte = sess_mgr->rte[thread_id]; - ((on_session_message_callback *)(void *)cb)(sess, state, pkt, cb_args); + uint64_t used = session_manager_rte_clean_session(sess_mgr_rte, now_ms, cleaned, CLEAN_SESSION_BURST); + for (uint64_t i = 0; i < used; i++) + { + sess = cleaned[i]; + assert(session_get_current_state(sess) == SESSION_STATE_CLOSED); + session_set_current_packet(sess, NULL); + session_set_flow_type(sess, FLOW_TYPE_NONE); + + if (session_get_type(sess) == SESSION_TYPE_TCP) + { + mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_stream, &sess->empty_seg); + mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_ctrl, sess); + mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_tcp, sess); + } + else + { + mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_ctrl, sess); + mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_udp, sess); + } + } } -static void on_tcp_payload_message_dispatch(int topic_id, void *msg, on_msg_cb_func *cb, void *cb_args, void *dispatch_args) +static void on_sess_msg_dispatch(int sess_msg_id, void *msg, on_msg_cb_func *msg_cb, void *msg_cb_args, void *dispatch_args) { - struct tcp_segment *seg = (struct tcp_segment *)msg; - struct session *sess = (struct session *)seg->user_data; - enum session_state state = session_get_current_state(sess); + struct session *sess = (struct session *)msg; + struct packet *pkt = (struct packet *)session_get0_current_packet(sess); + enum session_state state = session_get_current_state(sess); - ((on_tcp_payload_callback *)(void *)cb)(sess, state, seg->data, seg->len, cb_args); + ((on_session_message_callback *)(void *)msg_cb)(sess, state, pkt, msg_cb_args); } -static void on_tcp_payload_message_free(void *msg, void *args) +static void on_tcp_payload_msg_dispatch(int sess_msg_id, void *msg, on_msg_cb_func *msg_cb, void *msg_cb_args, void *dispatch_args) { - struct tcp_segment *seg = (struct tcp_segment *)msg; - struct session *sess = (struct session *)seg->user_data; + struct tcp_segment *seg = (struct tcp_segment *)msg; + struct session *sess = (struct session *)seg->user_data; + enum session_state state = session_get_current_state(sess); - session_free_tcp_segment(sess, seg); + ((on_tcp_payload_callback *)(void *)msg_cb)(sess, state, seg->data, seg->len, msg_cb_args); } -static void on_session_message_free(void *msg, void *args) +static void on_sess_msg_free(void *msg, void *args) { - struct session *sess = (struct session *)msg; + struct session *sess = (struct session *)msg; - if (session_get_current_state(sess) == SESSION_STATE_CLOSED) - { - struct session_manager *sess_mgr = (struct session_manager *)args; - int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr); - struct session_manager_runtime *sess_mgr_rt = sess_mgr->runtime[thread_id]; + if (session_get_current_state(sess) == SESSION_STATE_CLOSED) + { + struct session_manager *sess_mgr = (struct session_manager *)args; + int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr); + struct session_manager_rte *sess_mgr_rte = sess_mgr->rte[thread_id]; - char buffer[4096] = {0}; - session_to_str(sess, 0, buffer, sizeof(buffer)); - SESSION_MANAGER_LOG_INFO("session free: %s", buffer); + char buffer[4096] = {0}; + session_to_str(sess, 0, buffer, sizeof(buffer)); + SESSION_MANAGER_LOG_INFO("session free: %s", buffer); - struct exdata_runtime *exdata_rt = (struct exdata_runtime *)session_get_user_data(sess); - exdata_runtime_free(exdata_rt); - session_manager_runtime_free_session(sess_mgr_rt, sess); - } + struct exdata_runtime *exdata_rt = (struct exdata_runtime *)session_get_user_data(sess); + exdata_runtime_free(exdata_rt); + session_manager_rte_free_session(sess_mgr_rte, sess); + } +} + +static void on_tcp_payload_msg_free(void *msg, void *args) +{ + struct tcp_segment *seg = (struct tcp_segment *)msg; + struct session *sess = (struct session *)seg->user_data; + + session_free_tcp_segment(sess, seg); } static void on_packet_forward(struct packet *pkt, enum packet_stage stage, void *args) { - struct session_manager *sess_mgr = (struct session_manager *)args; - int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr); - struct mq_runtime *mq_rt = stellar_module_manager_get_mq_runtime(sess_mgr->mod_mgr); - struct session_manager_runtime *sess_mgr_rt = sess_mgr->runtime[thread_id]; + struct session_manager *sess_mgr = (struct session_manager *)args; + int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr); + struct mq_runtime *mq_rte = sess_mgr->mq[thread_id]; + struct session_manager_rte *sess_mgr_rte = sess_mgr->rte[thread_id]; - /* - * We use the system's real time instead of monotonic time for the following reasons: - * -> Session creation/closure times require real time (e.g., for logging session activities). - * -> Session ID generation relies on real time (e.g., for reverse calculating session creation time from the session ID). - * - * Note: Modifying the system time will affect the timing wheel, impacting session expiration, and TCP reassembly expiration. - * Suggestion: After modifying the system time, restart the service to ensure consistent timing. - */ - uint64_t now_ms = clock_get_real_time_ms(); + /* + * We use the system's real time instead of monotonic time for the following reasons: + * -> Session creation/closure times require real time (e.g., for logging session activities). + * -> Session ID generation relies on real time (e.g., for reverse calculating session creation time from the session ID). + * + * Note: Modifying the system time will affect the timing wheel, impacting session expiration, and TCP reassembly expiration. + * Suggestion: After modifying the system time, restart the service to ensure consistent timing. + */ + uint64_t now_ms = clock_get_real_time_ms(); - struct tuple6 key; - struct tcp_segment *seg = NULL; - struct session *sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, pkt); - if (sess == NULL) - { - if (packet_is_ctrl(pkt)) - { - goto fast_path; - } + struct tuple6 key; + struct tcp_segment *seg = NULL; + struct session *sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, pkt); + if (sess == NULL) + { + if (packet_is_ctrl(pkt)) + { + goto fast_path; + } - sess = session_manager_runtime_new_session(sess_mgr_rt, pkt, now_ms); - if (sess == NULL) - { - goto fast_path; - } - else - { - session_set_user_data(sess, exdata_runtime_new(sess_mgr->schema->exdata)); - goto slow_path; - } - } - else - { - if (packet_is_ctrl(pkt)) - { - goto ctrl_path; - } + sess = session_manager_rte_new_session(sess_mgr_rte, pkt, now_ms); + if (sess == NULL) + { + goto fast_path; + } + else + { + session_set_user_data(sess, exdata_runtime_new(sess_mgr->sche->ex_sche)); + goto slow_path; + } + } + else + { + if (packet_is_ctrl(pkt)) + { + goto ctrl_path; + } - if (session_manager_runtime_update_session(sess_mgr_rt, sess, pkt, now_ms) == -1) - { - goto fast_path; - } - else - { - goto slow_path; - } - } + if (session_manager_rte_update_session(sess_mgr_rte, sess, pkt, now_ms) == -1) + { + goto fast_path; + } + else + { + goto slow_path; + } + } ctrl_path: - session_set_current_packet(sess, pkt); - packet_get_innermost_tuple6(pkt, &key); - if (tuple6_cmp(session_get_tuple6(sess), &key) == 0) - { - session_set_flow_type(sess, FLOW_TYPE_C2S); - } - else - { - session_set_flow_type(sess, FLOW_TYPE_S2C); - } - packet_set_exdata(pkt, sess_mgr->schema->pkt_exdata_idx, sess); - mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_ctrl_pkt, sess); - return; + session_set_current_packet(sess, pkt); + packet_get_innermost_tuple6(pkt, &key); + if (tuple6_cmp(session_get_tuple6(sess), &key) == 0) + { + session_set_flow_type(sess, FLOW_TYPE_C2S); + } + else + { + session_set_flow_type(sess, FLOW_TYPE_S2C); + } + packet_set_exdata(pkt, sess_mgr->sche->pkt_ex_id, sess); + mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_ctrl, sess); + return; slow_path: - if (session_get_type(sess) == SESSION_TYPE_TCP) - { - mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_tcp, sess); - while ((seg = session_get_tcp_segment(sess))) - { - mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_tcp_stream, seg); - } - } - else - { - mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_udp, sess); - } - packet_set_exdata(pkt, sess_mgr->schema->pkt_exdata_idx, sess); - return; + if (session_get_type(sess) == SESSION_TYPE_TCP) + { + mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_tcp, sess); + while ((seg = session_get_tcp_segment(sess))) + { + mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_stream, seg); + } + } + else + { + mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_udp, sess); + } + packet_set_exdata(pkt, sess_mgr->sche->pkt_ex_id, sess); + return; fast_path: - packet_set_exdata(pkt, sess_mgr->schema->pkt_exdata_idx, NULL); - return; + packet_set_exdata(pkt, sess_mgr->sche->pkt_ex_id, NULL); + return; } static void on_packet_output(struct packet *pkt, enum packet_stage stage, void *args) { - struct session_manager *sess_mgr = (struct session_manager *)args; - int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr); - struct session_manager_runtime *sess_mgr_rt = sess_mgr->runtime[thread_id]; + struct session_manager *sess_mgr = (struct session_manager *)args; + int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr); + struct session_manager_rte *sess_mgr_rte = sess_mgr->rte[thread_id]; - struct session *sess = (struct session *)packet_get_exdata(pkt, sess_mgr->schema->pkt_exdata_idx); - if (sess) - { - struct tuple6 key; - enum flow_type flow = FLOW_TYPE_NONE; - packet_get_innermost_tuple6(pkt, &key); - if (tuple6_cmp(session_get_tuple6(sess), &key) == 0) - { - flow = FLOW_TYPE_C2S; - } - else - { - flow = FLOW_TYPE_S2C; - } + struct session *sess = (struct session *)packet_get_exdata(pkt, sess_mgr->sche->pkt_ex_id); + if (sess) + { + struct tuple6 key; + enum flow_type flow = FLOW_TYPE_NONE; + packet_get_innermost_tuple6(pkt, &key); + if (tuple6_cmp(session_get_tuple6(sess), &key) == 0) + { + flow = FLOW_TYPE_C2S; + } + else + { + flow = FLOW_TYPE_S2C; + } - int is_ctrl = packet_is_ctrl(pkt); - uint16_t len = packet_get_raw_len(pkt); - switch (packet_get_action(pkt)) - { - case PACKET_ACTION_DROP: - session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1); - session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len); - break; - case PACKET_ACTION_FORWARD: - session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1); - session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len); - break; - default: - assert(0); - break; - } + int is_ctrl = packet_is_ctrl(pkt); + uint16_t len = packet_get_raw_len(pkt); + switch (packet_get_action(pkt)) + { + case PACKET_ACTION_DROP: + session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1); + session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len); + break; + case PACKET_ACTION_FORWARD: + session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1); + session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len); + break; + default: + assert(0); + break; + } - session_set_current_packet(sess, NULL); - session_set_flow_type(sess, FLOW_TYPE_NONE); - } + session_set_current_packet(sess, NULL); + session_set_flow_type(sess, FLOW_TYPE_NONE); + } - if (packet_get_origin(pkt) == NULL) - { - session_manager_runtime_record_duplicated_packet(sess_mgr_rt, pkt); - } -} - -static void publish_session_closed_message_batch(struct session_manager *sess_mgr, uint16_t thread_id, uint64_t now_ms) -{ - struct session *sess = NULL; - struct session *cleaned[MAX_CLEANED_SESS] = {NULL}; - struct session_manager_runtime *sess_mgr_rt = sess_mgr->runtime[thread_id]; - struct mq_runtime *mq_rt = stellar_module_manager_get_mq_runtime(sess_mgr->mod_mgr); - - uint64_t used = session_manager_runtime_clean_session(sess_mgr_rt, now_ms, cleaned, MAX_CLEANED_SESS); - for (uint64_t i = 0; i < used; i++) - { - sess = cleaned[i]; - assert(session_get_current_state(sess) == SESSION_STATE_CLOSED); - session_set_current_packet(sess, NULL); - session_set_flow_type(sess, FLOW_TYPE_NONE); - - if (session_get_type(sess) == SESSION_TYPE_TCP) - { - mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_tcp_stream, &sess->empty_seg); - mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_ctrl_pkt, sess); - mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_tcp, sess); - } - else - { - mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_ctrl_pkt, sess); - mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_udp, sess); - } - } + if (packet_get_origin(pkt) == NULL) + { + session_manager_rte_record_duplicated_packet(sess_mgr_rte, pkt); + } } static void on_polling(struct stellar_module_manager *mod_mgr, void *args) { - uint64_t now_ms = clock_get_real_time_ms(); - struct session_manager *sess_mgr = (struct session_manager *)args; - int thread_id = stellar_module_manager_get_thread_id(mod_mgr); + uint64_t now_ms = clock_get_real_time_ms(); + struct session_manager *sess_mgr = (struct session_manager *)args; + int thread_id = stellar_module_manager_get_thread_id(mod_mgr); + struct session_manager_rte *sess_mgr_rte = sess_mgr->rte[thread_id]; + struct session_manager_stat *sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); - publish_session_closed_message_batch(sess_mgr, thread_id, now_ms); - // TODO - // ouput stat to fs4 + clean_closed_session(sess_mgr, thread_id, now_ms); + + static __thread uint64_t last_sync_stat_ms = 0; + static __thread struct session_manager_stat last_stat = {0}; + if (now_ms - last_sync_stat_ms >= SYNC_STAT_INTERVAL_MS) + { + for (int i = 0; i < SESS_MGR_STAT_MAX; i++) + { + uint64_t val = session_manager_stat_get(sess_mgr_stat, i) - session_manager_stat_get(&last_stat, i); + fieldstat_easy_counter_incrby(sess_mgr->fs, thread_id, sess_mgr->stat_idx[i], NULL, 0, val); + } + last_stat = *sess_mgr_stat; + last_sync_stat_ms = now_ms; + } } -/****************************************************************************** - * session manager schema - ******************************************************************************/ - -void session_manager_schema_free(struct session_manager_schema *sess_mgr_schema) +static void session_manager_sche_free(struct session_manager_sche *sess_mgr_schema) { - if (sess_mgr_schema) - { - if (sess_mgr_schema->mq) - { - mq_schema_destroy_topic(sess_mgr_schema->mq, sess_mgr_schema->topic_id_tcp); - mq_schema_destroy_topic(sess_mgr_schema->mq, sess_mgr_schema->topic_id_udp); - mq_schema_destroy_topic(sess_mgr_schema->mq, sess_mgr_schema->topic_id_ctrl_pkt); - mq_schema_destroy_topic(sess_mgr_schema->mq, sess_mgr_schema->topic_id_tcp_stream); - } - exdata_schema_free(sess_mgr_schema->exdata); + if (sess_mgr_schema) + { + if (sess_mgr_schema->mq_sche) + { + mq_schema_destroy_topic(sess_mgr_schema->mq_sche, sess_mgr_schema->sess_msg_id_tcp); + mq_schema_destroy_topic(sess_mgr_schema->mq_sche, sess_mgr_schema->sess_msg_id_udp); + mq_schema_destroy_topic(sess_mgr_schema->mq_sche, sess_mgr_schema->sess_msg_id_ctrl); + mq_schema_destroy_topic(sess_mgr_schema->mq_sche, sess_mgr_schema->sess_msg_id_stream); + } + exdata_schema_free(sess_mgr_schema->ex_sche); - free(sess_mgr_schema); - sess_mgr_schema = NULL; - } + free(sess_mgr_schema); + sess_mgr_schema = NULL; + } } -struct session_manager_schema *session_manager_schema_new(struct packet_manager *pkt_mgr, struct mq_schema *mq, void *sess_mgr) +static struct session_manager_sche *session_manager_sche_new(struct packet_manager *pkt_mgr, struct mq_schema *mq_sche, void *sess_mgr) { - if (packet_manager_subscribe(pkt_mgr, PACKET_STAGE_FORWARD, on_packet_forward, sess_mgr)) - { - SESSION_MANAGER_LOG_ERROR("failed to subscribe PACKET_STAGE_FORWARD"); - return NULL; - } - if (packet_manager_subscribe(pkt_mgr, PACKET_STAGE_OUTPUT, on_packet_output, sess_mgr)) - { - SESSION_MANAGER_LOG_ERROR("failed to subscribe PACKET_STAGE_OUTPUT"); - return NULL; - } + if (packet_manager_subscribe(pkt_mgr, PACKET_STAGE_FORWARD, on_packet_forward, sess_mgr)) + { + SESSION_MANAGER_LOG_ERROR("failed to subscribe PACKET_STAGE_FORWARD"); + return NULL; + } + if (packet_manager_subscribe(pkt_mgr, PACKET_STAGE_OUTPUT, on_packet_output, sess_mgr)) + { + SESSION_MANAGER_LOG_ERROR("failed to subscribe PACKET_STAGE_OUTPUT"); + return NULL; + } - struct session_manager_schema *sess_mgr_schema = calloc(1, sizeof(struct session_manager_schema)); - if (sess_mgr_schema == NULL) - { - SESSION_MANAGER_LOG_ERROR("failed to allocate memory for session_manager_schema"); - return NULL; - } + struct session_manager_sche *sess_mgr_schema = calloc(1, sizeof(struct session_manager_sche)); + if (sess_mgr_schema == NULL) + { + SESSION_MANAGER_LOG_ERROR("failed to allocate memory for session_manager_sche"); + return NULL; + } - sess_mgr_schema->exdata = exdata_schema_new(); - if (sess_mgr_schema->exdata == NULL) - { - SESSION_MANAGER_LOG_ERROR("failed to create exdata_schema"); - goto error_out; - } + sess_mgr_schema->ex_sche = exdata_schema_new(); + if (sess_mgr_schema->ex_sche == NULL) + { + SESSION_MANAGER_LOG_ERROR("failed to create exdata_schema"); + goto error_out; + } - sess_mgr_schema->mq = mq; - sess_mgr_schema->pkt_exdata_idx = packet_manager_new_packet_exdata_index(pkt_mgr, "session_manager", NULL, NULL); - if (sess_mgr_schema->pkt_exdata_idx == -1) - { - SESSION_MANAGER_LOG_ERROR("failed to create packet exdata index"); - goto error_out; - } + sess_mgr_schema->mq_sche = mq_sche; + sess_mgr_schema->pkt_ex_id = packet_manager_new_packet_exdata_index(pkt_mgr, "session_manager", NULL, NULL); + if (sess_mgr_schema->pkt_ex_id == -1) + { + SESSION_MANAGER_LOG_ERROR("failed to create packet exdata index"); + goto error_out; + } - /* - * Publish session closed messages to multiple topics. - * Each topic has its own session message free callback. - * To prevent the same session from being freeed multiple times, - * only TCP/UDP topics register session message free callbacks, - * and other topics do not register session message callbacks; - * - * Restriction: MQ ensures that the session message free order is consistent with the publishing order - */ - sess_mgr_schema->topic_id_tcp = mq_schema_create_topic(sess_mgr_schema->mq, "SESSIOM_MANAGER_TOPIC_TCP", &on_session_message_dispatch, NULL, &on_session_message_free, sess_mgr); - if (sess_mgr_schema->topic_id_tcp == -1) - { - SESSION_MANAGER_LOG_ERROR("failed to create topic SESSIOM_MANAGER_TOPIC_FREE"); - goto error_out; - } - sess_mgr_schema->topic_id_udp = mq_schema_create_topic(sess_mgr_schema->mq, "SESSIOM_MANAGER_TOPIC_UDP", &on_session_message_dispatch, NULL, &on_session_message_free, sess_mgr); - if (sess_mgr_schema->topic_id_udp == -1) - { - SESSION_MANAGER_LOG_ERROR("failed to create topic SESSIOM_MANAGER_TOPIC_UDP"); - goto error_out; - } - sess_mgr_schema->topic_id_ctrl_pkt = mq_schema_create_topic(sess_mgr_schema->mq, "SESSIOM_MANAGER_TOPIC_CTRL_PKT", &on_session_message_dispatch, NULL, NULL, NULL); - if (sess_mgr_schema->topic_id_ctrl_pkt == -1) - { - SESSION_MANAGER_LOG_ERROR("failed to create topic SESSIOM_MANAGER_TOPIC_CTRL_PKT"); - goto error_out; - } - sess_mgr_schema->topic_id_tcp_stream = mq_schema_create_topic(sess_mgr_schema->mq, "SESSIOM_MANAGER_TOPIC_TCP_STREAM", &on_tcp_payload_message_dispatch, NULL, &on_tcp_payload_message_free, sess_mgr); - if (sess_mgr_schema->topic_id_tcp_stream == -1) - { - SESSION_MANAGER_LOG_ERROR("failed to create topic SESSIOM_MANAGER_TOPIC_TCP_STREAM"); - goto error_out; - } + /* + * Publish session closed messages to multiple topics. + * Each topic has its own session message free callback. + * To prevent the same session from being freeed multiple times, + * only TCP/UDP topics register session message free callbacks, + * and other topics do not register session message callbacks; + * + * Restriction: MQ ensures that the session message free order is consistent with the publishing order + */ + sess_mgr_schema->sess_msg_id_tcp = mq_schema_create_topic(sess_mgr_schema->mq_sche, "SESSION_MESSAGE_TCP", &on_sess_msg_dispatch, NULL, &on_sess_msg_free, sess_mgr); + if (sess_mgr_schema->sess_msg_id_tcp == -1) + { + SESSION_MANAGER_LOG_ERROR("failed to create topic SESSION_MESSAGE_FREE"); + goto error_out; + } + sess_mgr_schema->sess_msg_id_udp = mq_schema_create_topic(sess_mgr_schema->mq_sche, "SESSION_MESSAGE_UDP", &on_sess_msg_dispatch, NULL, &on_sess_msg_free, sess_mgr); + if (sess_mgr_schema->sess_msg_id_udp == -1) + { + SESSION_MANAGER_LOG_ERROR("failed to create topic SESSION_MESSAGE_UDP"); + goto error_out; + } + sess_mgr_schema->sess_msg_id_ctrl = mq_schema_create_topic(sess_mgr_schema->mq_sche, "SESSION_MESSAGE_CTRL_PKT", &on_sess_msg_dispatch, NULL, NULL, NULL); + if (sess_mgr_schema->sess_msg_id_ctrl == -1) + { + SESSION_MANAGER_LOG_ERROR("failed to create topic SESSION_MESSAGE_CTRL_PKT"); + goto error_out; + } + sess_mgr_schema->sess_msg_id_stream = mq_schema_create_topic(sess_mgr_schema->mq_sche, "SESSION_MESSAGE_TCP_STREAM", &on_tcp_payload_msg_dispatch, NULL, &on_tcp_payload_msg_free, sess_mgr); + if (sess_mgr_schema->sess_msg_id_stream == -1) + { + SESSION_MANAGER_LOG_ERROR("failed to create topic SESSION_MESSAGE_TCP_STREAM"); + goto error_out; + } - return sess_mgr_schema; + return sess_mgr_schema; error_out: - session_manager_schema_free(sess_mgr_schema); - return NULL; + session_manager_sche_free(sess_mgr_schema); + return NULL; } /****************************************************************************** @@ -368,130 +379,145 @@ error_out: void session_manager_free(struct session_manager *sess_mgr) { - if (sess_mgr) - { - session_manager_schema_free(sess_mgr->schema); - session_manager_config_free(sess_mgr->cfg); - free(sess_mgr); - } + if (sess_mgr) + { + if (sess_mgr->sche) + { + session_manager_sche_free(sess_mgr->sche); + } + if (sess_mgr->fs) + { + fieldstat_easy_free(sess_mgr->fs); + } + if (sess_mgr->cfg) + { + session_manager_cfg_free(sess_mgr->cfg); + } + free(sess_mgr); + } } -struct session_manager *session_manager_new(struct stellar_module_manager *mod_mgr, struct packet_manager *pkt_mgr, struct mq_schema *mq_schema, const char *toml_file) +static struct session_manager *session_manager_new(struct packet_manager *pkt_mgr, struct mq_schema *mq_schema, const char *toml_file) { - struct session_manager *sess_mgr = calloc(1, sizeof(struct session_manager)); - if (sess_mgr == NULL) - { - SESSION_MANAGER_LOG_ERROR("failed to allocate memory for session_manager"); - return NULL; - } + struct session_manager *sess_mgr = calloc(1, sizeof(struct session_manager)); + if (sess_mgr == NULL) + { + SESSION_MANAGER_LOG_ERROR("failed to allocate memory for session_manager"); + return NULL; + } - sess_mgr->cfg = session_manager_config_new(toml_file); - if (sess_mgr->cfg == NULL) - { - SESSION_MANAGER_LOG_ERROR("failed to create session_manager_config"); - goto error_out; - } - session_manager_config_print(sess_mgr->cfg); + sess_mgr->cfg = session_manager_cfg_new(toml_file); + if (sess_mgr->cfg == NULL) + { + SESSION_MANAGER_LOG_ERROR("failed to create session_manager_cfg"); + goto error_out; + } + session_manager_cfg_print(sess_mgr->cfg); - sess_mgr->schema = session_manager_schema_new(pkt_mgr, mq_schema, sess_mgr); - if (sess_mgr->schema == NULL) - { - goto error_out; - } + sess_mgr->fs = fieldstat_easy_new(sess_mgr->cfg->thread_num, "session_manager", NULL, 0); + if (sess_mgr->fs == NULL) + { + SESSION_MANAGER_LOG_ERROR("failed to create fieldstat_easy"); + goto error_out; + } + for (int i = 0; i < SESS_MGR_STAT_MAX; i++) + { + sess_mgr->stat_idx[i] = fieldstat_easy_register_counter(sess_mgr->fs, sess_mgr_stat_str[i]); + } + if (fieldstat_easy_enable_auto_output(sess_mgr->fs, "session_manager.fs4", 2) != 0) + { + SESSION_MANAGER_LOG_ERROR("failed to enable auto output"); + goto error_out; + } - stellar_module_manager_polling_subscribe(mod_mgr, on_polling, sess_mgr); + sess_mgr->sche = session_manager_sche_new(pkt_mgr, mq_schema, sess_mgr); + if (sess_mgr->sche == NULL) + { + goto error_out; + } - return sess_mgr; + return sess_mgr; error_out: - session_manager_free(sess_mgr); - return NULL; + session_manager_free(sess_mgr); + return NULL; } int session_manager_new_session_exdata_index(struct session_manager *sess_mgr, const char *name, exdata_free *func, void *arg) { - assert(sess_mgr); - assert(name); - - return exdata_schema_new_index(sess_mgr->schema->exdata, name, func, arg); + assert(sess_mgr); + assert(name); + assert(func); + return exdata_schema_new_index(sess_mgr->sche->ex_sche, name, func, arg); } int session_manager_subscribe_tcp(struct session_manager *sess_mgr, on_session_message_callback *cb, void *args) { - assert(sess_mgr); - assert(cb); - - return mq_schema_subscribe(sess_mgr->schema->mq, sess_mgr->schema->topic_id_tcp, (on_msg_cb_func *)(void *)cb, args); + assert(sess_mgr); + assert(cb); + return mq_schema_subscribe(sess_mgr->sche->mq_sche, sess_mgr->sche->sess_msg_id_tcp, (on_msg_cb_func *)(void *)cb, args); } int session_manager_subscribe_udp(struct session_manager *sess_mgr, on_session_message_callback *cb, void *args) { - assert(sess_mgr); - assert(cb); - - return mq_schema_subscribe(sess_mgr->schema->mq, sess_mgr->schema->topic_id_udp, (on_msg_cb_func *)(void *)cb, args); + assert(sess_mgr); + assert(cb); + return mq_schema_subscribe(sess_mgr->sche->mq_sche, sess_mgr->sche->sess_msg_id_udp, (on_msg_cb_func *)(void *)cb, args); } int session_manager_subscribe_control_packet(struct session_manager *sess_mgr, on_session_message_callback *cb, void *args) { - assert(sess_mgr); - assert(cb); - - return mq_schema_subscribe(sess_mgr->schema->mq, sess_mgr->schema->topic_id_ctrl_pkt, (on_msg_cb_func *)(void *)cb, args); + assert(sess_mgr); + assert(cb); + return mq_schema_subscribe(sess_mgr->sche->mq_sche, sess_mgr->sche->sess_msg_id_ctrl, (on_msg_cb_func *)(void *)cb, args); } int session_manager_subscribe_tcp_stream(struct session_manager *sess_mgr, on_tcp_payload_callback *cb, void *args) { - assert(sess_mgr); - assert(cb); - - return mq_schema_subscribe(sess_mgr->schema->mq, sess_mgr->schema->topic_id_tcp_stream, (on_msg_cb_func *)(void *)cb, args); + assert(sess_mgr); + assert(cb); + return mq_schema_subscribe(sess_mgr->sche->mq_sche, sess_mgr->sche->sess_msg_id_stream, (on_msg_cb_func *)(void *)cb, args); } -int session_manager_init(struct session_manager *sess_mgr, uint16_t thread_id) +int session_manager_init(struct session_manager *sess_mgr, uint16_t thread_id, struct mq_runtime *mq_rte) { - assert(sess_mgr); - assert(thread_id < sess_mgr->cfg->thread_num); - uint64_t now_ms = clock_get_real_time_ms(); + assert(sess_mgr); + uint64_t now_ms = clock_get_real_time_ms(); - sess_mgr->cfg->session_id_seed = sess_mgr->cfg->instance_id << 8 | thread_id; - struct session_manager_runtime *sess_mgr_rt = session_manager_runtime_new(sess_mgr->cfg, now_ms); - if (sess_mgr_rt == NULL) - { - SESSION_MANAGER_LOG_ERROR("failed to create session_manager_runtime"); - return -1; - } - else - { - sess_mgr->runtime[thread_id] = sess_mgr_rt; - return 0; - } + sess_mgr->cfg->session_id_seed = sess_mgr->cfg->instance_id << 8 | thread_id; + sess_mgr->mq[thread_id] = mq_rte; + sess_mgr->rte[thread_id] = session_manager_rte_new(sess_mgr->cfg, now_ms); + if (sess_mgr->rte[thread_id] == NULL) + { + SESSION_MANAGER_LOG_ERROR("failed to create session_manager_rte"); + return -1; + } + else + { + return 0; + } } void session_manager_clean(struct session_manager *sess_mgr, uint16_t thread_id) { - assert(sess_mgr); - assert(thread_id < sess_mgr->cfg->thread_num); + assert(sess_mgr); - struct mq_runtime *mq_rt = stellar_module_manager_get_mq_runtime(sess_mgr->mod_mgr); - struct session_manager_runtime *sess_mgr_rt = sess_mgr->runtime[thread_id]; - if (sess_mgr_rt == NULL) - { - return; - } + struct mq_runtime *mq_rte = sess_mgr->mq[thread_id]; + if (sess_mgr->rte[thread_id] == NULL) + { + return; + } - struct session_manager_stat *stat = session_manager_runtime_get_stat(sess_mgr_rt); - while (stat->tcp_sess_used || stat->udp_sess_used) - { - publish_session_closed_message_batch(sess_mgr, thread_id, UINT64_MAX); - // here we need to dispatch the message to ensure that the session is cleaned up - mq_runtime_dispatch(mq_rt); - } + struct session_manager_stat *stat = session_manager_rte_get_stat(sess_mgr->rte[thread_id]); + while (stat->tcp_sess_used || stat->udp_sess_used) + { + clean_closed_session(sess_mgr, thread_id, UINT64_MAX); + // here we need to dispatch the message to ensure that the session is cleaned up + mq_runtime_dispatch(mq_rte); + } - SESSION_MANAGER_LOG_INFO("runtime: %p, idx: %d, will be cleaned", sess_mgr_rt, thread_id); - session_manager_runtime_print_stat(sess_mgr_rt); - session_manager_runtime_free(sess_mgr_rt); - sess_mgr_rt = NULL; + session_manager_rte_free(sess_mgr->rte[thread_id]); + sess_mgr->rte[thread_id] = NULL; } /****************************************************************************** @@ -500,78 +526,81 @@ void session_manager_clean(struct session_manager *sess_mgr, uint16_t thread_id) struct session_manager *stellar_module_get_session_manager(struct stellar_module_manager *mod_mgr) { - assert(mod_mgr); - struct stellar_module *sess_mgr_mod = stellar_module_manager_get_module(mod_mgr, SESSION_MANAGER_MODULE_NAME); - if (sess_mgr_mod == NULL) - { - return NULL; - } - return stellar_module_get_ctx(sess_mgr_mod); + assert(mod_mgr); + struct stellar_module *sess_mgr_mod = stellar_module_manager_get_module(mod_mgr, SESSION_MANAGER_MODULE_NAME); + if (sess_mgr_mod == NULL) + { + return NULL; + } + return stellar_module_get_ctx(sess_mgr_mod); } struct stellar_module *session_manager_on_init(struct stellar_module_manager *mod_mgr) { - assert(mod_mgr); - struct packet_manager *pkt_mgr = stellar_module_get_packet_manager(mod_mgr); - assert(pkt_mgr); - struct mq_schema *mq_schema = stellar_module_manager_get_mq_schema(mod_mgr); - assert(mq_schema); - const char *toml_file = stellar_module_manager_get_toml_path(mod_mgr); - assert(toml_file); + assert(mod_mgr); + struct packet_manager *pkt_mgr = stellar_module_get_packet_manager(mod_mgr); + assert(pkt_mgr); + struct mq_schema *mq_schema = stellar_module_manager_get_mq_schema(mod_mgr); + assert(mq_schema); + const char *toml_file = stellar_module_manager_get_toml_path(mod_mgr); + assert(toml_file); - struct session_manager *sess_mgr = session_manager_new(mod_mgr, pkt_mgr, mq_schema, toml_file); - if (sess_mgr == NULL) - { - return NULL; - } +<<<<<<< HEAD + struct session_manager *sess_mgr = session_manager_new(mod_mgr, pkt_mgr, mq_schema, toml_file); +======= + struct session_manager *sess_mgr = session_manager_new(pkt_mgr, mq_sche, toml_file); +>>>>>>> 6e4d813 (bugfix sess) + if (sess_mgr == NULL) + { + return NULL; + } + stellar_module_manager_polling_subscribe(mod_mgr, on_polling, sess_mgr); - struct stellar_module *sess_mgr_mod = stellar_module_new(SESSION_MANAGER_MODULE_NAME, NULL); - if (sess_mgr_mod == NULL) - { - SESSION_MANAGER_LOG_ERROR("failed to create session_manager"); - session_manager_free(sess_mgr); - return NULL; - } - stellar_module_set_ctx(sess_mgr_mod, sess_mgr); + struct stellar_module *sess_mgr_mod = stellar_module_new(SESSION_MANAGER_MODULE_NAME, NULL); + if (sess_mgr_mod == NULL) + { + SESSION_MANAGER_LOG_ERROR("failed to create session_manager"); + session_manager_free(sess_mgr); + return NULL; + } + stellar_module_set_ctx(sess_mgr_mod, sess_mgr); - SESSION_MANAGER_LOG_FATAL("session_manager init"); - return sess_mgr_mod; + SESSION_MANAGER_LOG_FATAL("session_manager init"); + return sess_mgr_mod; } -void session_manager_on_exit(struct stellar_module_manager *mod_mgr __attribute__((unused)), struct stellar_module *mod) +void session_manager_on_exit(struct stellar_module_manager *mod_mgr, struct stellar_module *mod) { - if (mod) - { - struct session_manager *sess_mgr = stellar_module_get_ctx(mod); - - session_manager_free(sess_mgr); - stellar_module_free(mod); - SESSION_MANAGER_LOG_FATAL("session_manager exit"); - } + if (mod) + { + struct session_manager *sess_mgr = stellar_module_get_ctx(mod); + session_manager_free(sess_mgr); + stellar_module_free(mod); + SESSION_MANAGER_LOG_FATAL("session_manager exit"); + } } struct stellar_module *session_manager_on_thread_init(struct stellar_module_manager *mod_mgr, int thread_id, struct stellar_module *mod) { - struct session_manager *sess_mgr = stellar_module_get_ctx(mod); - assert(sess_mgr); - assert(thread_id < sess_mgr->cfg->thread_num); + struct session_manager *sess_mgr = stellar_module_get_ctx(mod); + assert(sess_mgr); + struct mq_runtime *mq_rte = stellar_module_manager_get_mq_runtime(mod_mgr); + assert(mq_rte); - if (session_manager_init(sess_mgr, thread_id) != 0) - { - SESSION_MANAGER_LOG_ERROR("failed to int session_manager_init"); - return NULL; - } - else - { - return mod; - } + if (session_manager_init(sess_mgr, thread_id, mq_rte) != 0) + { + SESSION_MANAGER_LOG_ERROR("failed to int session_manager_init"); + return NULL; + } + else + { + return mod; + } } -void session_manager_on_thread_exit(struct stellar_module_manager *mod_mgr __attribute__((unused)), int thread_id, struct stellar_module *mod) +void session_manager_on_thread_exit(struct stellar_module_manager *mod_mgr, int thread_id, struct stellar_module *mod) { - struct session_manager *sess_mgr = stellar_module_get_ctx(mod); - assert(sess_mgr); - assert(thread_id < sess_mgr->cfg->thread_num); - - session_manager_clean(sess_mgr, thread_id); + struct session_manager *sess_mgr = stellar_module_get_ctx(mod); + assert(sess_mgr); + session_manager_clean(sess_mgr, thread_id); } \ No newline at end of file diff --git a/infra/session_manager/session_manager_cfg.c b/infra/session_manager/session_manager_cfg.c new file mode 100644 index 0000000..5542831 --- /dev/null +++ b/infra/session_manager/session_manager_cfg.c @@ -0,0 +1,128 @@ +#include "utils_internal.h" +#include "session_manager_log.h" +#include "session_manager_cfg.h" + +struct session_manager_cfg *session_manager_cfg_new(const char *toml_file) +{ + if (toml_file == NULL) + { + return NULL; + } + + struct session_manager_cfg *sess_mgr_cfg = (struct session_manager_cfg *)calloc(1, sizeof(struct session_manager_cfg)); + if (sess_mgr_cfg == NULL) + { + return NULL; + } + + int ret = 0; + ret += load_toml_integer_config(toml_file, "instance.id", &sess_mgr_cfg->instance_id, 0, 4095); + ret += load_toml_integer_config(toml_file, "packet_io.thread_num", &sess_mgr_cfg->thread_num, 0, MAX_THREAD_NUM); + + // max session number + ret += load_toml_integer_config(toml_file, "session_manager.tcp_session_max", &sess_mgr_cfg->tcp_session_max, RX_BURST_MAX * 2, UINT64_MAX); + ret += load_toml_integer_config(toml_file, "session_manager.udp_session_max", &sess_mgr_cfg->udp_session_max, RX_BURST_MAX * 2, UINT64_MAX); + + // session overload + ret += load_toml_integer_config(toml_file, "session_manager.evict_old_on_tcp_table_limit", &sess_mgr_cfg->evict_old_on_tcp_table_limit, 0, 1); + ret += load_toml_integer_config(toml_file, "session_manager.evict_old_on_udp_table_limit", &sess_mgr_cfg->evict_old_on_udp_table_limit, 0, 1); + + // limit + ret += load_toml_integer_config(toml_file, "session_manager.expire_period_ms", &sess_mgr_cfg->expire_period_ms, 0, 60000); + ret += load_toml_integer_config(toml_file, "session_manager.expire_batch_max", &sess_mgr_cfg->expire_batch_max, 1, 1024); + + // TCP timeout + ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.init", &sess_mgr_cfg->tcp_timeout_ms.init, 1, 60000); + ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.handshake", &sess_mgr_cfg->tcp_timeout_ms.handshake, 1, 60000); + ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.data", &sess_mgr_cfg->tcp_timeout_ms.data, 1, 15999999000); + ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.half_closed", &sess_mgr_cfg->tcp_timeout_ms.half_closed, 1, 604800000); + ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.time_wait", &sess_mgr_cfg->tcp_timeout_ms.time_wait, 1, 60000); + ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.discard_default", &sess_mgr_cfg->tcp_timeout_ms.discard_default, 1, 15999999000); + ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.unverified_rst", &sess_mgr_cfg->tcp_timeout_ms.unverified_rst, 1, 60000); + + // UDP timeout + ret += load_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.data", &sess_mgr_cfg->udp_timeout_ms.data, 1, 15999999000); + ret += load_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.discard_default", &sess_mgr_cfg->udp_timeout_ms.discard_default, 1, 15999999000); + + // duplicated packet filter + ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.enable", &sess_mgr_cfg->duplicated_packet_bloom_filter.enable, 0, 1); + ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.capacity", &sess_mgr_cfg->duplicated_packet_bloom_filter.capacity, 1, 4294967295); + ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.time_window_ms", &sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms, 1, 60000); + ret += load_toml_double_config(toml_file, "session_manager.duplicated_packet_bloom_filter.error_rate", (double *)&sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate, 0.0, 1.0); + + // eviction session filter + ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.enable", &sess_mgr_cfg->evicted_session_bloom_filter.enable, 0, 1); + ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.capacity", &sess_mgr_cfg->evicted_session_bloom_filter.capacity, 1, 4294967295); + ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.time_window_ms", &sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms, 1, 60000); + ret += load_toml_double_config(toml_file, "session_manager.evicted_session_bloom_filter.error_rate", (double *)&sess_mgr_cfg->evicted_session_bloom_filter.error_rate, 0.0, 1.0); + + // TCP reassembly + ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.enable", &sess_mgr_cfg->tcp_reassembly.enable, 0, 1); + ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.timeout_ms", &sess_mgr_cfg->tcp_reassembly.timeout_ms, 1, 60000); + ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.buffered_segments_max", &sess_mgr_cfg->tcp_reassembly.buffered_segments_max, 2, 4096); + + if (ret != 0) + { + session_manager_cfg_free(sess_mgr_cfg); + return NULL; + } + + return sess_mgr_cfg; +} + +void session_manager_cfg_free(struct session_manager_cfg *sess_mgr_cfg) +{ + if (sess_mgr_cfg) + { + free(sess_mgr_cfg); + sess_mgr_cfg = NULL; + } +} + +void session_manager_cfg_print(struct session_manager_cfg *sess_mgr_cfg) +{ + if (sess_mgr_cfg) + { + // max session number + SESSION_MANAGER_LOG_INFO("session_manager.tcp_session_max : %lu", sess_mgr_cfg->tcp_session_max); + SESSION_MANAGER_LOG_INFO("session_manager.udp_session_max : %lu", sess_mgr_cfg->udp_session_max); + + // session overload + SESSION_MANAGER_LOG_INFO("session_manager.evict_old_on_tcp_table_limit : %d", sess_mgr_cfg->evict_old_on_tcp_table_limit); + SESSION_MANAGER_LOG_INFO("session_manager.evict_old_on_udp_table_limit : %d", sess_mgr_cfg->evict_old_on_udp_table_limit); + + // limit + SESSION_MANAGER_LOG_INFO("session_manager.expire_period_ms : %lu", sess_mgr_cfg->expire_period_ms); + SESSION_MANAGER_LOG_INFO("session_manager.expire_batch_max : %lu", sess_mgr_cfg->expire_batch_max); + + // TCP timeout + SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.init : %lu", sess_mgr_cfg->tcp_timeout_ms.init); + SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.handshake : %lu", sess_mgr_cfg->tcp_timeout_ms.handshake); + SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.data : %lu", sess_mgr_cfg->tcp_timeout_ms.data); + SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.half_closed : %lu", sess_mgr_cfg->tcp_timeout_ms.half_closed); + SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.time_wait : %lu", sess_mgr_cfg->tcp_timeout_ms.time_wait); + SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.discard_default : %lu", sess_mgr_cfg->tcp_timeout_ms.discard_default); + SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.unverified_rst : %lu", sess_mgr_cfg->tcp_timeout_ms.unverified_rst); + + // UDP timeout + SESSION_MANAGER_LOG_INFO("session_manager.udp_timeout_ms.data : %lu", sess_mgr_cfg->udp_timeout_ms.data); + SESSION_MANAGER_LOG_INFO("session_manager.udp_timeout_ms.discard_default : %lu", sess_mgr_cfg->udp_timeout_ms.discard_default); + + // duplicated packet filter + SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.enable : %d", sess_mgr_cfg->duplicated_packet_bloom_filter.enable); + SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.capacity : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.capacity); + SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.time_window_ms : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms); + SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.error_rate : %f", sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate); + + // eviction session filter + SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.enable : %d", sess_mgr_cfg->evicted_session_bloom_filter.enable); + SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.capacity : %lu", sess_mgr_cfg->evicted_session_bloom_filter.capacity); + SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.time_window_ms : %lu", sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms); + SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.error_rate : %f", sess_mgr_cfg->evicted_session_bloom_filter.error_rate); + + // TCP reassembly + SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.enable : %d", sess_mgr_cfg->tcp_reassembly.enable); + SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.timeout_ms : %lu", sess_mgr_cfg->tcp_reassembly.timeout_ms); + SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.buffered_segments_max : %lu", sess_mgr_cfg->tcp_reassembly.buffered_segments_max); + } +} \ No newline at end of file diff --git a/infra/session_manager/session_manager_cfg.h b/infra/session_manager/session_manager_cfg.h new file mode 100644 index 0000000..5e28162 --- /dev/null +++ b/infra/session_manager/session_manager_cfg.h @@ -0,0 +1,72 @@ +#pragma once + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include + +struct session_manager_cfg +{ + uint64_t instance_id; + uint64_t thread_num; + uint64_t session_id_seed; + + uint64_t tcp_session_max; + uint64_t udp_session_max; + + uint64_t evict_old_on_tcp_table_limit; // range: [0, 1] + uint64_t evict_old_on_udp_table_limit; // range: [0, 1] + + uint64_t expire_period_ms; // range: [0, 60000] (ms) + uint64_t expire_batch_max; // range: [1, 1024] + + struct + { + uint64_t init; // range: [1, 60000] (ms) + uint64_t handshake; // range: [1, 60000] (ms) + uint64_t data; // range: [1, 15999999000] (ms) + uint64_t half_closed; // range: [1, 604800000] (ms) + uint64_t time_wait; // range: [1, 600000] (ms) + uint64_t discard_default; // range: [1, 15999999000] (ms) + uint64_t unverified_rst; // range: [1, 600000] (ms) + } tcp_timeout_ms; + + struct + { + uint64_t data; // range: [1, 15999999000] (ms) + uint64_t discard_default; // range: [1, 15999999000] (ms) + } udp_timeout_ms; + + struct + { + uint64_t enable; // range: [0, 1] + uint64_t capacity; // range: [1, 4294967295] + uint64_t time_window_ms; // range: [1, 60000] (ms) + double error_rate; // range: [0.0, 1.0] + } duplicated_packet_bloom_filter; + + struct + { + uint64_t enable; // range: [0, 1] + uint64_t capacity; // range: [1, 4294967295] + uint64_t time_window_ms; // range: [1, 60000] (ms) + double error_rate; // range: [0.0, 1.0] + } evicted_session_bloom_filter; + + struct + { + uint64_t enable; // range: [0, 1] + uint64_t timeout_ms; // range: [1, 60000] (ms) + uint64_t buffered_segments_max; // range: [2, 4096] + } tcp_reassembly; +}; + +struct session_manager_cfg *session_manager_cfg_new(const char *toml_file); +void session_manager_cfg_free(struct session_manager_cfg *sess_mgr_cfg); +void session_manager_cfg_print(struct session_manager_cfg *sess_mgr_cfg); + +#ifdef __cplusplus +} +#endif diff --git a/infra/session_manager/session_manager_log.h b/infra/session_manager/session_manager_log.h new file mode 100644 index 0000000..68d0ac3 --- /dev/null +++ b/infra/session_manager/session_manager_log.h @@ -0,0 +1,17 @@ +#pragma once + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "log_internal.h" + +#define SESSION_MANAGER_LOG_FATAL(format, ...) STELLAR_LOG_FATAL(__thread_local_logger, "session manager", format, ##__VA_ARGS__) +#define SESSION_MANAGER_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "session manager", format, ##__VA_ARGS__) +#define SESSION_MANAGER_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "session manager", format, ##__VA_ARGS__) +#define SESSION_MANAGER_LOG_INFO(format, ...) STELLAR_LOG_INFO(__thread_local_logger, "session manager", format, ##__VA_ARGS__) + +#ifdef __cplusplus +} +#endif diff --git a/infra/session_manager/session_manager_rte.c b/infra/session_manager/session_manager_rte.c new file mode 100644 index 0000000..40beac2 --- /dev/null +++ b/infra/session_manager/session_manager_rte.c @@ -0,0 +1,1244 @@ +#include + +#include "packet_helper.h" +#include "packet_filter.h" +#include "session_pool.h" +#include "session_table.h" +#include "session_timer.h" +#include "session_filter.h" +#include "session_internal.h" +#include "session_transition.h" +#include "session_manager_log.h" +#include "session_manager_cfg.h" +#include "session_manager_rte.h" + +struct snowflake +{ + uint64_t seed; + uint64_t sequence; +}; + +struct session_manager_rte +{ + struct session_queue evc_list; + struct session_pool *sess_pool; + struct session_table *tcp_table; + struct session_table *udp_table; + struct session_timer *sess_timer; + + struct packet_filter *dup_pkt_filter; + struct session_filter *evc_sess_filter; + + struct session_manager_cfg cfg; + struct session_manager_stat stat; + + // only used for session_set_discard() or session_manager_rte_record_duplicated_packet(), because the function is called by plugin and has no time input. + uint64_t now_ms; + uint64_t last_clean_expired_sess_ts; + struct snowflake *sf; +}; + +/****************************************************************************** + * snowflake + ******************************************************************************/ + +static struct snowflake *snowflake_new(uint64_t seed) +{ + struct snowflake *sf = (struct snowflake *)calloc(1, sizeof(struct snowflake)); + if (sf == NULL) + { + return NULL; + } + + sf->seed = seed & 0xFFFFF; + sf->sequence = 0; + + return sf; +} + +static void snowflake_free(struct snowflake *sf) +{ + if (sf != NULL) + { + free(sf); + sf = NULL; + } +} + +static uint64_t snowflake_generate(struct snowflake *sf, uint64_t now_sec) +{ + /* + * high -> low + * +------+------------------+----------------+------------------------+---------------------------+ + * | 1bit | 12bit device_id | 8bit thread_id | 28bit timestamp in sec | 15bit sequence per thread | + * +------+------------------+----------------+------------------------+---------------------------+ + */ +#define MAX_ID_PER_THREAD (32768) +#define MAX_ID_BASE_TIME (268435456L) + uint64_t id = 0; + uint64_t id_per_thread = (sf->sequence++) % MAX_ID_PER_THREAD; + uint64_t id_base_time = now_sec % MAX_ID_BASE_TIME; + + id = (sf->seed << 43) | (id_base_time << 15) | (id_per_thread); + + return id; +} + +/****************************************************************************** + * address range + ******************************************************************************/ + +static int ipv4_in_range(const struct in_addr *addr, const struct in_addr *start, const struct in_addr *end) +{ + return (memcmp(addr, start, sizeof(struct in_addr)) >= 0 && memcmp(addr, end, sizeof(struct in_addr)) <= 0); +} + +static int ipv6_in_range(const struct in6_addr *addr, const struct in6_addr *start, const struct in6_addr *end) +{ + return (memcmp(addr, start, sizeof(struct in6_addr)) >= 0 && memcmp(addr, end, sizeof(struct in6_addr)) <= 0); +} + +/****************************************************************************** + * TCP reassembly + ******************************************************************************/ + +static void tcp_clean(struct session_manager_rte *sess_mgr_rte, struct session *sess) +{ + struct tcp_reassembly *c2s_tcp_reass = sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass; + struct tcp_reassembly *s2c_tcp_reass = sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass; + struct tcp_segment *seg; + if (c2s_tcp_reass) + { + while ((seg = tcp_reassembly_expire(c2s_tcp_reass, UINT64_MAX))) + { + session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RELEASED, 1); + session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RELEASED, seg->len); + sess_mgr_rte->stat.tcp_segs_freed++; + tcp_segment_free(seg); + } + tcp_reassembly_free(c2s_tcp_reass); + } + if (s2c_tcp_reass) + { + while ((seg = tcp_reassembly_expire(s2c_tcp_reass, UINT64_MAX))) + { + session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RELEASED, 1); + session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RELEASED, seg->len); + sess_mgr_rte->stat.tcp_segs_freed++; + tcp_segment_free(seg); + } + tcp_reassembly_free(s2c_tcp_reass); + } +} + +static int tcp_init(struct session_manager_rte *sess_mgr_rte, struct session *sess) +{ + if (!sess_mgr_rte->cfg.tcp_reassembly.enable) + { + return 0; + } + + sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass = tcp_reassembly_new(sess_mgr_rte->cfg.tcp_reassembly.timeout_ms, sess_mgr_rte->cfg.tcp_reassembly.buffered_segments_max); + sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass = tcp_reassembly_new(sess_mgr_rte->cfg.tcp_reassembly.timeout_ms, sess_mgr_rte->cfg.tcp_reassembly.buffered_segments_max); + if (sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass == NULL || sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass == NULL) + { + tcp_clean(sess_mgr_rte, sess); + return -1; + } + + SESSION_MANAGER_LOG_DEBUG("session %lu %s new c2s tcp tcp_reass %p, s2c tcp tcp_reass %p", session_get_id(sess), session_get0_readable_addr(sess), + sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass, sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass); + return 0; +} + +static void tcp_update(struct session_manager_rte *sess_mgr_rte, struct session *sess, enum flow_type type, const struct layer_private *tcp_layer) +{ + struct tcp_segment *seg; + struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr; + struct tcp_half *half = &sess->tcp_halfs[type]; + uint8_t flags = tcp_hdr_get_flags(hdr); + uint16_t len = tcp_layer->pld_len; + + if ((flags & TH_SYN) && half->isn == 0) + { + half->isn = tcp_hdr_get_seq(hdr); + } + half->flags = flags; + half->history |= flags; + half->seq = tcp_hdr_get_seq(hdr); + half->ack = tcp_hdr_get_ack(hdr); + half->len = tcp_layer->pld_len; + + if (!sess_mgr_rte->cfg.tcp_reassembly.enable) + { + if (len) + { + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len); + sess_mgr_rte->stat.tcp_segs_input++; + + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len); + sess_mgr_rte->stat.tcp_segs_inorder++; + + half->inorder_seg.data = tcp_layer->pld_ptr; + half->inorder_seg.len = len; + half->inorder_seg_consumed = 0; + } + return; + } + + if (unlikely(flags & TH_SYN)) + { + // len > 0 is SYN with data (TCP Fast Open) + tcp_reassembly_set_recv_next(half->tcp_reass, len ? half->seq : half->seq + 1); + } + + seg = tcp_reassembly_expire(half->tcp_reass, sess_mgr_rte->now_ms); + if (seg) + { + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_EXPIRED, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_EXPIRED, seg->len); + sess_mgr_rte->stat.tcp_segs_timeout++; + + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len); + sess_mgr_rte->stat.tcp_segs_freed++; + + tcp_segment_free(seg); + } + + if (len) + { + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len); + sess_mgr_rte->stat.tcp_segs_input++; + + uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->tcp_reass); + // in order + if (half->seq == rcv_nxt) + { + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len); + sess_mgr_rte->stat.tcp_segs_inorder++; + + half->inorder_seg.data = tcp_layer->pld_ptr; + half->inorder_seg.len = len; + half->inorder_seg_consumed = 0; + tcp_reassembly_inc_recv_next(half->tcp_reass, len); + } + // retransmission + else if (uint32_before(uint32_add(half->seq, len), rcv_nxt)) + { + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len); + sess_mgr_rte->stat.tcp_segs_retransmited++; + } + else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len))) + { + switch (tcp_reassembly_push(half->tcp_reass, seg, sess_mgr_rte->now_ms)) + { + case -2: + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len); + sess_mgr_rte->stat.tcp_segs_retransmited++; + tcp_segment_free(seg); + break; + case -1: + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len); + sess_mgr_rte->stat.tcp_segs_omitted_too_many++; + tcp_segment_free(seg); + break; + case 0: + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len); + sess_mgr_rte->stat.tcp_segs_buffered++; + break; + case 1: + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_OVERLAP, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_OVERLAP, len); + sess_mgr_rte->stat.tcp_segs_overlapped++; + + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len); + sess_mgr_rte->stat.tcp_segs_buffered++; + break; + default: + assert(0); + break; + } + } + else + { + session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1); + session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len); + sess_mgr_rte->stat.tcp_segs_omitted_too_many++; + } + } +} + +/****************************************************************************** + * flow type + ******************************************************************************/ + +// TODO +static enum flow_type identify_flow_type_by_port(uint16_t src_port, uint16_t dst_port) +{ + // big port is client + if (src_port > dst_port) + { + return FLOW_TYPE_C2S; + } + else if (src_port < dst_port) + { + return FLOW_TYPE_S2C; + } + else + { + // if port is equal, first packet is C2S + return FLOW_TYPE_C2S; + } +} + +static enum flow_type identify_flow_type_by_history(const struct session *sess, const struct tuple6 *key) +{ + if (tuple6_cmp(session_get_tuple6(sess), key) == 0) + { + return FLOW_TYPE_C2S; + } + else + { + return FLOW_TYPE_S2C; + } +} + +/****************************************************************************** + * session manager rte -- session update + ******************************************************************************/ + +static void session_update(struct session_manager_rte *sess_mgr_rte, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_type type) +{ + if (session_get_current_state(sess) == SESSION_STATE_INIT) + { + uint64_t sess_id = snowflake_generate(sess_mgr_rte->sf, sess_mgr_rte->now_ms / 1000); + session_set_id(sess, sess_id); + enum packet_direction pkt_dir = packet_get_direction(pkt); + if (type == FLOW_TYPE_C2S) + { + session_set_tuple6(sess, key); + if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External + { + session_set_direction(sess, SESSION_DIRECTION_OUTBOUND); + } + else + { + session_set_direction(sess, SESSION_DIRECTION_INBOUND); + } + tuple6_to_str(key, sess->tuple_str, sizeof(sess->tuple_str)); + } + else + { + struct tuple6 out; + tuple6_reverse(key, &out); + session_set_tuple6(sess, &out); + if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External + { + session_set_direction(sess, SESSION_DIRECTION_INBOUND); + } + else + { + session_set_direction(sess, SESSION_DIRECTION_OUTBOUND); + } + tuple6_to_str(&out, sess->tuple_str, sizeof(sess->tuple_str)); + } + + session_set_timestamp(sess, SESSION_TIMESTAMP_START, sess_mgr_rte->now_ms); + switch (key->ip_proto) + { + case IPPROTO_TCP: + session_set_type(sess, SESSION_TYPE_TCP); + break; + case IPPROTO_UDP: + session_set_type(sess, SESSION_TYPE_UDP); + break; + default: + assert(0); + break; + } + } + + session_inc_stat(sess, type, STAT_RAW_PACKETS_RECEIVED, 1); + session_inc_stat(sess, type, STAT_RAW_BYTES_RECEIVED, packet_get_raw_len(pkt)); + + if (!session_get_first_packet(sess, type)) + { + session_set_first_packet(sess, type, packet_dup(pkt)); + session_set_route_ctx(sess, type, packet_get_route_ctx(pkt)); + session_set_sids(sess, type, packet_get_sids(pkt)); + } + + session_set_current_packet(sess, pkt); + session_set_flow_type(sess, type); + session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, sess_mgr_rte->now_ms); + session_set_current_state(sess, next_state); +} + +/****************************************************************************** + * session manager rte -- bypass packet + ******************************************************************************/ + +static int session_manager_rte_bypass_packet_on_tcp_table_limit(struct session_manager_rte *sess_mgr_rte, const struct tuple6 *key) +{ + if (key->ip_proto == IPPROTO_TCP && sess_mgr_rte->stat.tcp_sess_used >= sess_mgr_rte->cfg.tcp_session_max) + { + sess_mgr_rte->stat.tcp_pkts_bypass_table_full++; + return 1; + } + return 0; +} + +static int session_manager_rte_bypass_packet_on_udp_table_limit(struct session_manager_rte *sess_mgr_rte, const struct tuple6 *key) +{ + if (key->ip_proto == IPPROTO_UDP && sess_mgr_rte->stat.udp_sess_used >= sess_mgr_rte->cfg.udp_session_max) + { + sess_mgr_rte->stat.udp_pkts_bypass_table_full++; + return 1; + } + return 0; +} + +static int session_manager_rte_bypass_packet_on_session_evicted(struct session_manager_rte *sess_mgr_rte, const struct tuple6 *key) +{ + if (sess_mgr_rte->cfg.evicted_session_bloom_filter.enable && session_filter_lookup(sess_mgr_rte->evc_sess_filter, key, sess_mgr_rte->now_ms)) + { + sess_mgr_rte->stat.udp_pkts_bypass_session_evicted++; + return 1; + } + + return 0; +} + +static int session_manager_rte_bypass_duplicated_packet(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, const struct tuple6 *key) +{ + if (sess_mgr_rte->cfg.duplicated_packet_bloom_filter.enable == 0) + { + return 0; + } + + enum flow_type type = identify_flow_type_by_history(sess, key); + if (session_get_stat(sess, type, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess)) + { + if (packet_filter_lookup(sess_mgr_rte->dup_pkt_filter, pkt, sess_mgr_rte->now_ms)) + { + session_inc_stat(sess, type, STAT_DUPLICATE_PACKETS_BYPASS, 1); + session_inc_stat(sess, type, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt)); + switch (session_get_type(sess)) + { + case SESSION_TYPE_TCP: + sess_mgr_rte->stat.tcp_pkts_bypass_duplicated++; + break; + case SESSION_TYPE_UDP: + sess_mgr_rte->stat.udp_pkts_bypass_duplicated++; + break; + default: + assert(0); + break; + } + session_set_duplicate_traffic(sess); + + session_set_current_packet(sess, pkt); + session_set_flow_type(sess, type); + return 1; + } + else + { + packet_filter_add(sess_mgr_rte->dup_pkt_filter, pkt, sess_mgr_rte->now_ms); + return 0; + } + } + + return 0; +} + +/****************************************************************************** + * session manager rte -- lookup/new/update/evicte session + ******************************************************************************/ + +static void session_manager_rte_evicte_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, int reason) +{ + if (sess == NULL) + { + return; + } + + // when session add to evicted queue, session lifetime is over + enum session_state curr_state = session_get_current_state(sess); + enum session_state next_state = session_transition_run(curr_state, reason); + session_transition_log(sess, curr_state, next_state, reason); + session_set_current_state(sess, next_state); + if (!session_get_closing_reason(sess)) + { + if (reason == PORT_REUSE_EVICT) + { + session_set_closing_reason(sess, CLOSING_BY_PORT_REUSE_EVICTED); + } + if (reason == LRU_EVICT) + { + session_set_closing_reason(sess, CLOSING_BY_LRU_EVICTED); + } + } + session_timer_del(sess_mgr_rte->sess_timer, sess); + TAILQ_INSERT_TAIL(&sess_mgr_rte->evc_list, sess, evc_tqe); + + switch (session_get_type(sess)) + { + case SESSION_TYPE_TCP: + SESSION_MANAGER_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess)); + session_table_del(sess_mgr_rte->tcp_table, sess); + SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, tcp); + sess_mgr_rte->stat.tcp_sess_evicted++; + break; + case SESSION_TYPE_UDP: + SESSION_MANAGER_LOG_DEBUG("evicte udp old session: %lu", session_get_id(sess)); + session_table_del(sess_mgr_rte->udp_table, sess); + if (sess_mgr_rte->cfg.evicted_session_bloom_filter.enable) + { + session_filter_add(sess_mgr_rte->evc_sess_filter, session_get_tuple6(sess), sess_mgr_rte->now_ms); + } + SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, udp); + sess_mgr_rte->stat.udp_sess_evicted++; + break; + default: + assert(0); + break; + } +} + +static struct session *session_manager_rte_lookup_tcp_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, const struct tuple6 *key) +{ + struct session *sess = session_table_find_tuple6(sess_mgr_rte->tcp_table, key, 0); + if (sess == NULL) + { + return NULL; + } + + const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP); + const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr; + uint8_t flags = tcp_hdr_get_flags(hdr); + if ((flags & TH_SYN) == 0) + { + return sess; + } + + enum flow_type type = identify_flow_type_by_history(sess, key); + struct tcp_half *half = &sess->tcp_halfs[type]; + if ((half->isn && half->isn != tcp_hdr_get_seq(hdr)) || // recv SYN with different ISN + ((half->history & TH_FIN) || (half->history & TH_RST))) // recv SYN after FIN or RST + { + // TCP port reuse, evict old session + session_manager_rte_evicte_session(sess_mgr_rte, sess, PORT_REUSE_EVICT); + return NULL; + } + else + { + // TCP SYN retransmission + return sess; + } +} + +static struct session *session_manager_rte_lookup_udp_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt __attribute__((unused)), const struct tuple6 *key) +{ + return session_table_find_tuple6(sess_mgr_rte->udp_table, key, 0); +} + +static struct session *session_manager_rte_new_tcp_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, const struct tuple6 *key) +{ + const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP); + const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr; + uint8_t flags = tcp_hdr_get_flags(hdr); + if (!(flags & TH_SYN)) + { + sess_mgr_rte->stat.tcp_pkts_bypass_session_not_found++; + return NULL; + } + + // tcp table full evict old session + if (sess_mgr_rte->cfg.evict_old_on_tcp_table_limit && sess_mgr_rte->stat.tcp_sess_used >= sess_mgr_rte->cfg.tcp_session_max - RX_BURST_MAX) + { + struct session *evic_sess = session_table_find_lru(sess_mgr_rte->tcp_table); + session_manager_rte_evicte_session(sess_mgr_rte, evic_sess, LRU_EVICT); + } + + enum flow_type type = (flags & TH_ACK) ? FLOW_TYPE_S2C : FLOW_TYPE_C2S; + struct session *sess = session_pool_pop(sess_mgr_rte->sess_pool); + if (sess == NULL) + { + assert(0); + return NULL; + } + session_init(sess); + sess->sess_mgr_rte = sess_mgr_rte; + sess->sess_mgr_stat = &sess_mgr_rte->stat; + + enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN); + session_update(sess_mgr_rte, sess, next_state, pkt, key, type); + session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN); + + if (tcp_init(sess_mgr_rte, sess) == -1) + { + assert(0); + session_pool_push(sess_mgr_rte->sess_pool, sess); + return NULL; + } + tcp_update(sess_mgr_rte, sess, type, tcp_layer); + + uint64_t timeout = (flags & TH_ACK) ? sess_mgr_rte->cfg.tcp_timeout_ms.handshake : sess_mgr_rte->cfg.tcp_timeout_ms.init; + session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + timeout); + session_table_add(sess_mgr_rte->tcp_table, sess); + + if (sess_mgr_rte->cfg.duplicated_packet_bloom_filter.enable) + { + packet_filter_add(sess_mgr_rte->dup_pkt_filter, pkt, sess_mgr_rte->now_ms); + } + + SESS_MGR_STAT_INC(&sess_mgr_rte->stat, next_state, tcp); + sess_mgr_rte->stat.tcp_sess_used++; + sess_mgr_rte->stat.history_tcp_sessions++; + + return sess; +} + +static struct session *session_manager_rte_new_udp_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, const struct tuple6 *key) +{ + // udp table full evict old session + if (sess_mgr_rte->cfg.evict_old_on_udp_table_limit && sess_mgr_rte->stat.udp_sess_used >= sess_mgr_rte->cfg.udp_session_max - RX_BURST_MAX) + { + struct session *evic_sess = session_table_find_lru(sess_mgr_rte->udp_table); + session_manager_rte_evicte_session(sess_mgr_rte, evic_sess, LRU_EVICT); + } + + struct session *sess = session_pool_pop(sess_mgr_rte->sess_pool); + if (sess == NULL) + { + assert(sess); + return NULL; + } + session_init(sess); + sess->sess_mgr_rte = sess_mgr_rte; + sess->sess_mgr_stat = &sess_mgr_rte->stat; + + enum flow_type type = identify_flow_type_by_port(ntohs(key->src_port), ntohs(key->dst_port)); + enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA); + session_update(sess_mgr_rte, sess, next_state, pkt, key, type); + session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA); + + session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + sess_mgr_rte->cfg.udp_timeout_ms.data); + session_table_add(sess_mgr_rte->udp_table, sess); + + SESS_MGR_STAT_INC(&sess_mgr_rte->stat, next_state, udp); + sess_mgr_rte->stat.udp_sess_used++; + sess_mgr_rte->stat.history_udp_sessions++; + + return sess; +} + +static int session_manager_rte_update_tcp_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, const struct tuple6 *key) +{ + const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP); + const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr; + enum flow_type type = identify_flow_type_by_history(sess, key); + uint8_t flags = tcp_hdr_get_flags(hdr); + int inputs = 0; + inputs |= (flags & TH_SYN) ? TCP_SYN : NONE; + inputs |= (flags & TH_FIN) ? TCP_FIN : NONE; + inputs |= (flags & TH_RST) ? TCP_RST : NONE; + inputs |= tcp_layer->pld_len ? TCP_DATA : NONE; + + // update state + enum session_state curr_state = session_get_current_state(sess); + enum session_state next_state = session_transition_run(curr_state, inputs); + + // update session + session_update(sess_mgr_rte, sess, next_state, pkt, key, type); + session_transition_log(sess, curr_state, next_state, inputs); + + // update tcp + tcp_update(sess_mgr_rte, sess, type, tcp_layer); + + // set closing reason + if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess)) + { + if (flags & TH_FIN) + { + session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_FIN : CLOSING_BY_SERVER_FIN)); + } + if (flags & TH_RST) + { + session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_RST : CLOSING_BY_SERVER_RST)); + } + } + + // update timeout + struct tcp_half *curr = &sess->tcp_halfs[type]; + struct tcp_half *peer = &sess->tcp_halfs[(type == FLOW_TYPE_C2S ? FLOW_TYPE_S2C : FLOW_TYPE_C2S)]; + uint64_t timeout = 0; + switch (next_state) + { + case SESSION_STATE_OPENING: + if (flags & TH_SYN) + { + timeout = (flags & TH_ACK) ? sess_mgr_rte->cfg.tcp_timeout_ms.handshake : sess_mgr_rte->cfg.tcp_timeout_ms.init; + } + else + { + timeout = sess_mgr_rte->cfg.tcp_timeout_ms.data; + } + break; + case SESSION_STATE_ACTIVE: + timeout = sess_mgr_rte->cfg.tcp_timeout_ms.data; + break; + case SESSION_STATE_CLOSING: + if (flags & TH_FIN) + { + timeout = (peer->history & TH_FIN) ? sess_mgr_rte->cfg.tcp_timeout_ms.time_wait : sess_mgr_rte->cfg.tcp_timeout_ms.half_closed; + } + else if (flags & TH_RST) + { + // if fin is received, the expected sequence number should be increased by 1 + uint32_t expected = (peer->history & TH_FIN) ? peer->ack + 1 : peer->ack; + timeout = (expected == curr->seq) ? sess_mgr_rte->cfg.tcp_timeout_ms.time_wait : sess_mgr_rte->cfg.tcp_timeout_ms.unverified_rst; + } + else + { + timeout = sess_mgr_rte->cfg.tcp_timeout_ms.data; + } + break; + case SESSION_STATE_DISCARD: + timeout = sess_mgr_rte->cfg.tcp_timeout_ms.discard_default; + break; + default: + assert(0); + break; + } + session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + timeout); + + SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, tcp); + + return 0; +} + +static int session_manager_rte_update_udp_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, const struct tuple6 *key) +{ + enum flow_type type = identify_flow_type_by_history(sess, key); + enum session_state curr_state = session_get_current_state(sess); + enum session_state next_state = session_transition_run(curr_state, UDP_DATA); + session_update(sess_mgr_rte, sess, next_state, pkt, key, type); + session_transition_log(sess, curr_state, next_state, UDP_DATA); + + if (session_get_current_state(sess) == SESSION_STATE_DISCARD) + { + session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + sess_mgr_rte->cfg.udp_timeout_ms.discard_default); + } + else + { + session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + sess_mgr_rte->cfg.udp_timeout_ms.data); + } + + SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, udp); + + return 0; +} + +/****************************************************************************** + * session manager rte -- public + ******************************************************************************/ + +struct session_manager_rte *session_manager_rte_new(const struct session_manager_cfg *sess_mgr_cfg, uint64_t now_ms) +{ + struct session_manager_rte *sess_mgr_rte = (struct session_manager_rte *)calloc(1, sizeof(struct session_manager_rte)); + if (sess_mgr_rte == NULL) + { + return NULL; + } + memcpy(&sess_mgr_rte->cfg, sess_mgr_cfg, sizeof(struct session_manager_cfg)); + + sess_mgr_rte->sess_pool = session_pool_new(sess_mgr_rte->cfg.tcp_session_max + sess_mgr_rte->cfg.udp_session_max); + sess_mgr_rte->tcp_table = session_table_new(); + sess_mgr_rte->udp_table = session_table_new(); + sess_mgr_rte->sess_timer = session_timer_new(now_ms); + if (sess_mgr_rte->sess_pool == NULL || sess_mgr_rte->tcp_table == NULL || sess_mgr_rte->udp_table == NULL || sess_mgr_rte->sess_timer == NULL) + { + goto error; + } + if (sess_mgr_rte->cfg.evicted_session_bloom_filter.enable) + { + sess_mgr_rte->evc_sess_filter = session_filter_new(sess_mgr_rte->cfg.evicted_session_bloom_filter.capacity, + sess_mgr_rte->cfg.evicted_session_bloom_filter.time_window_ms, + sess_mgr_rte->cfg.evicted_session_bloom_filter.error_rate, now_ms); + if (sess_mgr_rte->evc_sess_filter == NULL) + { + goto error; + } + } + if (sess_mgr_rte->cfg.duplicated_packet_bloom_filter.enable) + { + sess_mgr_rte->dup_pkt_filter = packet_filter_new(sess_mgr_rte->cfg.duplicated_packet_bloom_filter.capacity, + sess_mgr_rte->cfg.duplicated_packet_bloom_filter.time_window_ms, + sess_mgr_rte->cfg.duplicated_packet_bloom_filter.error_rate, now_ms); + if (sess_mgr_rte->dup_pkt_filter == NULL) + { + goto error; + } + } + sess_mgr_rte->sf = snowflake_new(sess_mgr_rte->cfg.session_id_seed); + if (sess_mgr_rte->sf == NULL) + { + goto error; + } + + TAILQ_INIT(&sess_mgr_rte->evc_list); + session_transition_init(); + sess_mgr_rte->now_ms = now_ms; + sess_mgr_rte->last_clean_expired_sess_ts = now_ms; + + return sess_mgr_rte; + +error: + session_manager_rte_free(sess_mgr_rte); + return NULL; +} + +void session_manager_rte_free(struct session_manager_rte *sess_mgr_rte) +{ + struct session *sess; + if (sess_mgr_rte) + { + // free all evicted session + while ((sess = TAILQ_FIRST(&sess_mgr_rte->evc_list))) + { + TAILQ_REMOVE(&sess_mgr_rte->evc_list, sess, evc_tqe); + session_manager_rte_free_session(sess_mgr_rte, sess); + } + // free all udp session + while (sess_mgr_rte->udp_table && (sess = session_table_find_lru(sess_mgr_rte->udp_table))) + { + session_manager_rte_free_session(sess_mgr_rte, sess); + } + // free all tcp session + while (sess_mgr_rte->tcp_table && (sess = session_table_find_lru(sess_mgr_rte->tcp_table))) + { + session_manager_rte_free_session(sess_mgr_rte, sess); + } + if (sess_mgr_rte->cfg.evicted_session_bloom_filter.enable) + { + session_filter_free(sess_mgr_rte->evc_sess_filter); + } + if (sess_mgr_rte->cfg.duplicated_packet_bloom_filter.enable) + { + packet_filter_free(sess_mgr_rte->dup_pkt_filter); + } + snowflake_free(sess_mgr_rte->sf); + session_timer_free(sess_mgr_rte->sess_timer); + session_table_free(sess_mgr_rte->udp_table); + session_table_free(sess_mgr_rte->tcp_table); + session_pool_free(sess_mgr_rte->sess_pool); + free(sess_mgr_rte); + sess_mgr_rte = NULL; + } +} + +struct session *session_manager_rte_new_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, uint64_t now_ms) +{ + sess_mgr_rte->now_ms = now_ms; + + struct tuple6 key; + if (packet_get_innermost_tuple6(pkt, &key)) + { + return NULL; + } + switch (key.ip_proto) + { + case IPPROTO_TCP: + if (session_manager_rte_bypass_packet_on_tcp_table_limit(sess_mgr_rte, &key)) + { + return NULL; + } + return session_manager_rte_new_tcp_session(sess_mgr_rte, pkt, &key); + case IPPROTO_UDP: + if (session_manager_rte_bypass_packet_on_session_evicted(sess_mgr_rte, &key)) + { + return NULL; + } + if (session_manager_rte_bypass_packet_on_udp_table_limit(sess_mgr_rte, &key)) + { + return NULL; + } + return session_manager_rte_new_udp_session(sess_mgr_rte, pkt, &key); + default: + return NULL; + } +} + +void session_manager_rte_free_session(struct session_manager_rte *sess_mgr_rte, struct session *sess) +{ + if (sess) + { + SESSION_MANAGER_LOG_DEBUG("session %lu closed (%s)", session_get_id(sess), closing_reason_to_str(session_get_closing_reason(sess))); + + session_timer_del(sess_mgr_rte->sess_timer, sess); + switch (session_get_type(sess)) + { + case SESSION_TYPE_TCP: + tcp_clean(sess_mgr_rte, sess); + if (session_table_find_sessid(sess_mgr_rte->tcp_table, session_get_id(sess), 0) == sess) + { + session_table_del(sess_mgr_rte->tcp_table, sess); + } + SESS_MGR_STAT_DEC(&sess_mgr_rte->stat, session_get_current_state(sess), tcp); + sess_mgr_rte->stat.tcp_sess_used--; + break; + case SESSION_TYPE_UDP: + if (session_table_find_sessid(sess_mgr_rte->udp_table, session_get_id(sess), 0) == sess) + { + session_table_del(sess_mgr_rte->udp_table, sess); + } + SESS_MGR_STAT_DEC(&sess_mgr_rte->stat, session_get_current_state(sess), udp); + sess_mgr_rte->stat.udp_sess_used--; + break; + default: + assert(0); + break; + } + + packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_C2S)); + packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_S2C)); + session_set_first_packet(sess, FLOW_TYPE_C2S, NULL); + session_set_first_packet(sess, FLOW_TYPE_S2C, NULL); + session_clear_route_ctx(sess, FLOW_TYPE_C2S); + session_clear_route_ctx(sess, FLOW_TYPE_S2C); + session_clear_sids(sess, FLOW_TYPE_C2S); + session_clear_sids(sess, FLOW_TYPE_S2C); + session_set_current_state(sess, SESSION_STATE_INIT); + session_set_current_packet(sess, NULL); + session_set_flow_type(sess, FLOW_TYPE_NONE); + session_init(sess); + session_pool_push(sess_mgr_rte->sess_pool, sess); + sess = NULL; + } +} + +struct session *session_manager_rte_lookup_session_by_packet(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt) +{ + struct tuple6 key; + if (packet_get_innermost_tuple6(pkt, &key)) + { + return NULL; + } + switch (key.ip_proto) + { + case IPPROTO_UDP: + return session_manager_rte_lookup_udp_session(sess_mgr_rte, pkt, &key); + case IPPROTO_TCP: + return session_manager_rte_lookup_tcp_session(sess_mgr_rte, pkt, &key); + default: + return NULL; + } +} + +struct session *session_manager_rte_lookup_session_by_id(struct session_manager_rte *sess_mgr_rte, uint64_t sess_id) +{ + struct session *sess = NULL; + sess = session_table_find_sessid(sess_mgr_rte->tcp_table, sess_id, 1); + if (sess) + { + return sess; + } + + sess = session_table_find_sessid(sess_mgr_rte->udp_table, sess_id, 1); + if (sess) + { + return sess; + } + + return NULL; +} + +int session_manager_rte_update_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, uint64_t now_ms) +{ + sess_mgr_rte->now_ms = now_ms; + + struct tuple6 key; + if (packet_get_innermost_tuple6(pkt, &key)) + { + return -1; + } + if (session_manager_rte_bypass_duplicated_packet(sess_mgr_rte, sess, pkt, &key)) + { + return -1; + } + switch (session_get_type(sess)) + { + case SESSION_TYPE_TCP: + return session_manager_rte_update_tcp_session(sess_mgr_rte, sess, pkt, &key); + case SESSION_TYPE_UDP: + return session_manager_rte_update_udp_session(sess_mgr_rte, sess, pkt, &key); + default: + return -1; + } +} + +struct session *session_manager_rte_get_expired_session(struct session_manager_rte *sess_mgr_rte, uint64_t now_ms) +{ + sess_mgr_rte->now_ms = now_ms; + + struct session *sess = session_timer_expire(sess_mgr_rte->sess_timer, now_ms); + if (sess) + { + enum session_state curr_state = session_get_current_state(sess); + enum session_state next_state = session_transition_run(curr_state, TIMEOUT); + session_transition_log(sess, curr_state, next_state, TIMEOUT); + session_set_current_state(sess, next_state); + + switch (session_get_type(sess)) + { + case SESSION_TYPE_TCP: + SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, tcp); + break; + case SESSION_TYPE_UDP: + SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, udp); + break; + default: + assert(0); + break; + } + + // next state is closed, need to free session + if (next_state == SESSION_STATE_CLOSED) + { + if (!session_get_closing_reason(sess)) + { + session_set_closing_reason(sess, CLOSING_BY_TIMEOUT); + } + return sess; + } + // next state is closing, only update timeout + else + { + switch (session_get_type(sess)) + { + case SESSION_TYPE_TCP: + session_timer_update(sess_mgr_rte->sess_timer, sess, now_ms + sess_mgr_rte->cfg.tcp_timeout_ms.data); + break; + case SESSION_TYPE_UDP: + session_timer_update(sess_mgr_rte->sess_timer, sess, now_ms + sess_mgr_rte->cfg.udp_timeout_ms.data); + break; + default: + assert(0); + break; + } + return NULL; + } + } + + return NULL; +} + +struct session *session_manager_rte_get_evicted_session(struct session_manager_rte *sess_mgr_rte) +{ + struct session *sess = TAILQ_FIRST(&sess_mgr_rte->evc_list); + if (sess) + { + TAILQ_REMOVE(&sess_mgr_rte->evc_list, sess, evc_tqe); + } + return sess; +} + +uint64_t session_manager_rte_clean_session(struct session_manager_rte *sess_mgr_rte, uint64_t now_ms, struct session *cleaned_sess_ptr[], uint64_t array_size) +{ + sess_mgr_rte->now_ms = now_ms; + struct session *sess = NULL; + uint64_t cleaned_sess_num = 0; + uint64_t expired_sess_num = 0; + + uint8_t expired_sess_canbe_clean = 0; + if (now_ms - sess_mgr_rte->last_clean_expired_sess_ts >= sess_mgr_rte->cfg.expire_period_ms || + now_ms == UINT64_MAX) + { + expired_sess_canbe_clean = 1; + } + + for (uint64_t i = 0; i < array_size; i++) + { + // frist clean evicted session + sess = session_manager_rte_get_evicted_session(sess_mgr_rte); + if (sess) + { + cleaned_sess_ptr[cleaned_sess_num++] = sess; + } + // then clean expired session + else + { + if (expired_sess_canbe_clean && expired_sess_num < sess_mgr_rte->cfg.expire_batch_max) + { + sess_mgr_rte->last_clean_expired_sess_ts = now_ms; + sess = session_manager_rte_get_expired_session(sess_mgr_rte, now_ms); + if (sess) + { + cleaned_sess_ptr[cleaned_sess_num++] = sess; + expired_sess_num++; + } + else + { + break; + } + } + else + { + break; + } + } + } + + return cleaned_sess_num; +} + +uint64_t session_manager_rte_scan_session(struct session_manager_rte *sess_mgr_rte, const struct session_scan_opts *opts, uint64_t mached_sess_id[], uint64_t array_size) +{ + uint64_t capacity = 0; + uint64_t max_loop = 0; + uint64_t mached_sess_num = 0; + const struct session *sess = NULL; + const struct tuple6 *tuple = NULL; + + if (sess_mgr_rte == NULL || opts == NULL || mached_sess_id == NULL || array_size == 0) + { + return mached_sess_num; + } + if (opts->count == 0) + { + return mached_sess_num; + } + capacity = sess_mgr_rte->cfg.tcp_session_max + sess_mgr_rte->cfg.udp_session_max; + if (opts->cursor >= capacity) + { + return mached_sess_num; + } + + max_loop = MIN(capacity, opts->cursor + opts->count); + for (uint64_t i = opts->cursor; i < max_loop; i++) + { + sess = session_pool_get0(sess_mgr_rte->sess_pool, i); + tuple = session_get_tuple6(sess); + if (session_get_current_state(sess) == SESSION_STATE_INIT) + { + continue; + } + + if ((opts->flags & SESSION_SCAN_TYPE) && opts->type != session_get_type(sess)) + { + continue; + } + if ((opts->flags & SESSION_SCAN_STATE) && opts->state != session_get_current_state(sess)) + { + continue; + } + if ((opts->flags & SESSION_SCAN_CREATE_TIME) && + (session_get_timestamp(sess, SESSION_TIMESTAMP_START) < opts->create_time_ms[0] || + session_get_timestamp(sess, SESSION_TIMESTAMP_START) > opts->create_time_ms[1])) + { + continue; + } + if ((opts->flags & SESSION_SCAN_LASPKT_TIME) && + (session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) < opts->laspkt_time_ms[0] || + session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) > opts->laspkt_time_ms[1])) + { + continue; + } + if ((opts->flags & SESSION_SCAN_SPORT) && opts->src_port != tuple->src_port) + { + continue; + } + if ((opts->flags & SESSION_SCAN_DPORT) && opts->dst_port != tuple->dst_port) + { + continue; + } + if (opts->flags & SESSION_SCAN_SIP) + { + if (opts->addr_family != tuple->addr_family) + { + continue; + } + if ((opts->addr_family == AF_INET) && !ipv4_in_range(&tuple->src_addr.v4, &opts->src_addr[0].v4, &opts->src_addr[1].v4)) + { + continue; + } + if ((opts->addr_family == AF_INET6) && !ipv6_in_range(&tuple->src_addr.v6, &opts->src_addr[0].v6, &opts->src_addr[1].v6)) + { + continue; + } + } + if (opts->flags & SESSION_SCAN_DIP) + { + if (opts->addr_family != tuple->addr_family) + { + continue; + } + if ((opts->addr_family == AF_INET) && !ipv4_in_range(&tuple->dst_addr.v4, &opts->dst_addr[0].v4, &opts->dst_addr[1].v4)) + { + continue; + } + if ((opts->addr_family == AF_INET6) && !ipv6_in_range(&tuple->dst_addr.v6, &opts->dst_addr[0].v6, &opts->dst_addr[1].v6)) + { + continue; + } + } + + mached_sess_id[mached_sess_num++] = session_get_id(sess); + if (mached_sess_num >= array_size) + { + break; + } + } + + SESSION_MANAGER_LOG_DEBUG("session scan => cursor: %lu, count: %lu, mached_sess_num: %lu", opts->cursor, opts->count, mached_sess_num); + return mached_sess_num; +} + +void session_manager_rte_record_duplicated_packet(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt) +{ + if (sess_mgr_rte->cfg.duplicated_packet_bloom_filter.enable) + { + packet_filter_add(sess_mgr_rte->dup_pkt_filter, pkt, sess_mgr_rte->now_ms); + } +} + +struct session_manager_stat *session_manager_rte_get_stat(struct session_manager_rte *sess_mgr_rte) +{ + return &sess_mgr_rte->stat; +} + +void session_set_discard(struct session *sess) +{ + struct session_manager_rte *sess_mgr_rte = sess->sess_mgr_rte; + enum session_type type = session_get_type(sess); + enum session_state curr_state = session_get_current_state(sess); + enum session_state next_state = session_transition_run(curr_state, USER_CLOSE); + session_transition_log(sess, curr_state, next_state, USER_CLOSE); + session_set_current_state(sess, next_state); + + switch (type) + { + case SESSION_TYPE_TCP: + session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + sess_mgr_rte->cfg.tcp_timeout_ms.discard_default); + SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, tcp); + break; + case SESSION_TYPE_UDP: + session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + sess_mgr_rte->cfg.udp_timeout_ms.discard_default); + SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, udp); + break; + default: + assert(0); + break; + } +} diff --git a/infra/session_manager/session_manager_rte.h b/infra/session_manager/session_manager_rte.h new file mode 100644 index 0000000..de8c09c --- /dev/null +++ b/infra/session_manager/session_manager_rte.h @@ -0,0 +1,67 @@ +#pragma once + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "tuple.h" +#include "stellar/session.h" + +enum session_scan_flags +{ + SESSION_SCAN_TYPE = 1 << 0, + SESSION_SCAN_STATE = 1 << 1, + SESSION_SCAN_SIP = 1 << 2, + SESSION_SCAN_DIP = 1 << 3, + SESSION_SCAN_SPORT = 1 << 4, + SESSION_SCAN_DPORT = 1 << 5, + SESSION_SCAN_CREATE_TIME = 1 << 6, + SESSION_SCAN_LASPKT_TIME = 1 << 7, +}; + +struct session_scan_opts +{ + // required + uint32_t flags; + uint32_t cursor; + uint32_t count; + + // optional + enum session_type type; + enum session_state state; + + uint32_t addr_family; // AF_INET or AF_INET6 + union ip_address src_addr[2]; // network byte order + union ip_address dst_addr[2]; // network byte order + uint16_t src_port; // network byte order + uint16_t dst_port; // network byte order + + uint64_t create_time_ms[2]; // session create time range + uint64_t laspkt_time_ms[2]; // last packet time range +}; + +struct session_manager_rte; +struct session_manager_rte *session_manager_rte_new(const struct session_manager_cfg *sess_mgr_cfg, uint64_t now_ms); +void session_manager_rte_free(struct session_manager_rte *sess_mgr_rte); + +struct session *session_manager_rte_new_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, uint64_t now_ms); +void session_manager_rte_free_session(struct session_manager_rte *sess_mgr_rte, struct session *sess); + +struct session *session_manager_rte_lookup_session_by_packet(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt); +struct session *session_manager_rte_lookup_session_by_id(struct session_manager_rte *sess_mgr_rte, uint64_t sess_id); +int session_manager_rte_update_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, uint64_t now_ms); + +struct session *session_manager_rte_get_expired_session(struct session_manager_rte *sess_mgr_rte, uint64_t now_ms); +struct session *session_manager_rte_get_evicted_session(struct session_manager_rte *sess_mgr_rte); + +uint64_t session_manager_rte_clean_session(struct session_manager_rte *sess_mgr_rte, uint64_t now_ms, struct session *cleaned_sess_ptr[], uint64_t array_size); +uint64_t session_manager_rte_scan_session(struct session_manager_rte *sess_mgr_rte, const struct session_scan_opts *opts, uint64_t mached_sess_id[], uint64_t array_size); + +void session_manager_rte_record_duplicated_packet(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt); + +struct session_manager_stat *session_manager_rte_get_stat(struct session_manager_rte *sess_mgr_rte); + +#ifdef __cplusplus +} +#endif diff --git a/infra/session_manager/session_manager_runtime.c b/infra/session_manager/session_manager_runtime.c deleted file mode 100644 index 97fbb28..0000000 --- a/infra/session_manager/session_manager_runtime.c +++ /dev/null @@ -1,1464 +0,0 @@ -#include -#include -#include -#include - -#include "utils_internal.h" -#include "packet_helper.h" -#include "packet_filter.h" -#include "session_internal.h" -#include "session_pool.h" -#include "session_table.h" -#include "session_timer.h" -#include "session_filter.h" -#include "session_transition.h" -#include "session_manager_runtime.h" - -#include "stellar/exdata.h" - -struct snowflake -{ - uint64_t seed; - uint64_t sequence; -}; - -struct session_manager_runtime -{ - struct session_queue evicte_list; - struct session_pool *sess_pool; - struct session_timer *sess_timer; - struct session_table *tcp_sess_table; - struct session_table *udp_sess_table; - - struct packet_filter *dup_pkt_filter; - struct session_filter *evicte_sess_filter; - - struct session_manager_stat stat; - struct session_manager_config cfg; - - /* - * only used for session_set_discard() or session_manager_runtime_record_duplicated_packet(), - * because the function is called by plugin and has no time input. - */ - uint64_t now_ms; - uint64_t last_clean_expired_sess_ts; - struct snowflake *sf; -}; - -#define EVICTE_SESSION_BURST (RX_BURST_MAX) - -/****************************************************************************** - * session manager stat macro - ******************************************************************************/ - -#define SESS_MGR_STAT_INC(stat, state, proto) \ - { \ - switch ((state)) \ - { \ - case SESSION_STATE_OPENING: \ - (stat)->proto##_sess_opening++; \ - break; \ - case SESSION_STATE_ACTIVE: \ - (stat)->proto##_sess_active++; \ - break; \ - case SESSION_STATE_CLOSING: \ - (stat)->proto##_sess_closing++; \ - break; \ - case SESSION_STATE_DISCARD: \ - (stat)->proto##_sess_discard++; \ - break; \ - case SESSION_STATE_CLOSED: \ - (stat)->proto##_sess_closed++; \ - break; \ - default: \ - break; \ - } \ - } - -#define SESS_MGR_STAT_DEC(stat, state, proto) \ - { \ - switch ((state)) \ - { \ - case SESSION_STATE_OPENING: \ - (stat)->proto##_sess_opening--; \ - break; \ - case SESSION_STATE_ACTIVE: \ - (stat)->proto##_sess_active--; \ - break; \ - case SESSION_STATE_CLOSING: \ - (stat)->proto##_sess_closing--; \ - break; \ - case SESSION_STATE_DISCARD: \ - (stat)->proto##_sess_discard--; \ - break; \ - case SESSION_STATE_CLOSED: \ - (stat)->proto##_sess_closed--; \ - break; \ - default: \ - break; \ - } \ - } - -#define SESS_MGR_STAT_UPDATE(stat, curr, next, proto) \ - { \ - if (curr != next) \ - { \ - SESS_MGR_STAT_DEC(stat, curr, proto); \ - SESS_MGR_STAT_INC(stat, next, proto); \ - } \ - } - -/****************************************************************************** - * snowflake - ******************************************************************************/ - -static struct snowflake *snowflake_new(uint64_t seed) -{ - struct snowflake *sf = (struct snowflake *)calloc(1, sizeof(struct snowflake)); - if (sf == NULL) - { - return NULL; - } - - sf->seed = seed & 0xFFFFF; - sf->sequence = 0; - - return sf; -} - -static void snowflake_free(struct snowflake *sf) -{ - if (sf != NULL) - { - free(sf); - sf = NULL; - } -} - -/* - * high -> low - * - * +------+------------------+----------------+------------------------+---------------------------+ - * | 1bit | 12bit device_id | 8bit thread_id | 28bit timestamp in sec | 15bit sequence per thread | - * +------+------------------+----------------+------------------------+---------------------------+ - */ - -#define MAX_ID_PER_THREAD (32768) -#define MAX_ID_BASE_TIME (268435456L) - -static uint64_t snowflake_generate(struct snowflake *sf, uint64_t now_sec) -{ - uint64_t id = 0; - uint64_t id_per_thread = (sf->sequence++) % MAX_ID_PER_THREAD; - uint64_t id_base_time = now_sec % MAX_ID_BASE_TIME; - - id = (sf->seed << 43) | (id_base_time << 15) | (id_per_thread); - - return id; -} - -/****************************************************************************** - * TCP utils - ******************************************************************************/ - -static void tcp_clean(struct session_manager_runtime *sess_mgr_rt, struct session *sess) -{ - struct tcp_reassembly *c2s_tcp_reass = sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass; - struct tcp_reassembly *s2c_tcp_reass = sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass; - struct tcp_segment *seg; - if (c2s_tcp_reass) - { - while ((seg = tcp_reassembly_expire(c2s_tcp_reass, UINT64_MAX))) - { - session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RELEASED, 1); - session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RELEASED, seg->len); - sess_mgr_rt->stat.tcp_segs_freed++; - tcp_segment_free(seg); - } - tcp_reassembly_free(c2s_tcp_reass); - } - if (s2c_tcp_reass) - { - while ((seg = tcp_reassembly_expire(s2c_tcp_reass, UINT64_MAX))) - { - session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RELEASED, 1); - session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RELEASED, seg->len); - sess_mgr_rt->stat.tcp_segs_freed++; - tcp_segment_free(seg); - } - tcp_reassembly_free(s2c_tcp_reass); - } -} - -static int tcp_init(struct session_manager_runtime *sess_mgr_rt, struct session *sess) -{ - if (!sess_mgr_rt->cfg.tcp_reassembly.enable) - { - return 0; - } - - sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass = tcp_reassembly_new(sess_mgr_rt->cfg.tcp_reassembly.timeout_ms, sess_mgr_rt->cfg.tcp_reassembly.buffered_segments_max); - sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass = tcp_reassembly_new(sess_mgr_rt->cfg.tcp_reassembly.timeout_ms, sess_mgr_rt->cfg.tcp_reassembly.buffered_segments_max); - if (sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass == NULL || sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass == NULL) - { - tcp_clean(sess_mgr_rt, sess); - return -1; - } - - SESSION_MANAGER_LOG_DEBUG("session %lu %s new c2s tcp tcp_reass %p, s2c tcp tcp_reass %p", - session_get_id(sess), session_get0_readable_addr(sess), - sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass, - sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass); - - return 0; -} - -static void tcp_update(struct session_manager_runtime *sess_mgr_rt, struct session *sess, enum flow_type type, const struct layer_private *tcp_layer) -{ - struct tcp_segment *seg; - struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr; - struct tcp_half *half = &sess->tcp_halfs[type]; - uint8_t flags = tcp_hdr_get_flags(hdr); - uint16_t len = tcp_layer->pld_len; - - if ((flags & TH_SYN) && half->isn == 0) - { - half->isn = tcp_hdr_get_seq(hdr); - } - half->flags = flags; - half->history |= flags; - half->seq = tcp_hdr_get_seq(hdr); - half->ack = tcp_hdr_get_ack(hdr); - half->len = tcp_layer->pld_len; - - if (!sess_mgr_rt->cfg.tcp_reassembly.enable) - { - if (len) - { - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len); - sess_mgr_rt->stat.tcp_segs_input++; - - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len); - sess_mgr_rt->stat.tcp_segs_inorder++; - - half->inorder_seg.data = tcp_layer->pld_ptr; - half->inorder_seg.len = len; - half->inorder_seg_consumed = 0; - } - return; - } - - if (unlikely(flags & TH_SYN)) - { - // len > 0 is SYN with data (TCP Fast Open) - tcp_reassembly_set_recv_next(half->tcp_reass, len ? half->seq : half->seq + 1); - } - - seg = tcp_reassembly_expire(half->tcp_reass, sess_mgr_rt->now_ms); - if (seg) - { - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_EXPIRED, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_EXPIRED, seg->len); - sess_mgr_rt->stat.tcp_segs_timeout++; - - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len); - sess_mgr_rt->stat.tcp_segs_freed++; - - tcp_segment_free(seg); - } - - if (len) - { - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len); - sess_mgr_rt->stat.tcp_segs_input++; - - uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->tcp_reass); - // in order - if (half->seq == rcv_nxt) - { - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len); - sess_mgr_rt->stat.tcp_segs_inorder++; - - half->inorder_seg.data = tcp_layer->pld_ptr; - half->inorder_seg.len = len; - half->inorder_seg_consumed = 0; - tcp_reassembly_inc_recv_next(half->tcp_reass, len); - } - // retransmission - else if (uint32_before(uint32_add(half->seq, len), rcv_nxt)) - { - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len); - sess_mgr_rt->stat.tcp_segs_retransmited++; - } - else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len))) - { - switch (tcp_reassembly_push(half->tcp_reass, seg, sess_mgr_rt->now_ms)) - { - case -2: - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len); - sess_mgr_rt->stat.tcp_segs_retransmited++; - tcp_segment_free(seg); - break; - case -1: - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len); - sess_mgr_rt->stat.tcp_segs_omitted_too_many++; - tcp_segment_free(seg); - break; - case 0: - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len); - sess_mgr_rt->stat.tcp_segs_buffered++; - break; - case 1: - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_OVERLAP, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_OVERLAP, len); - sess_mgr_rt->stat.tcp_segs_overlapped++; - - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len); - sess_mgr_rt->stat.tcp_segs_buffered++; - break; - default: - assert(0); - break; - } - } - else - { - session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1); - session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len); - sess_mgr_rt->stat.tcp_segs_omitted_too_many++; - } - } -} - -/****************************************************************************** - * session flow - ******************************************************************************/ - -static enum flow_type identify_flow_type_by_port(uint16_t src_port, uint16_t dst_port) -{ - // big port is client - if (src_port > dst_port) - { - return FLOW_TYPE_C2S; - } - else if (src_port < dst_port) - { - return FLOW_TYPE_S2C; - } - else - { - // if port is equal, first packet is C2S - return FLOW_TYPE_C2S; - } -} - -static enum flow_type identify_flow_type_by_history(const struct session *sess, const struct tuple6 *key) -{ - if (tuple6_cmp(session_get_tuple6(sess), key) == 0) - { - return FLOW_TYPE_C2S; - } - else - { - return FLOW_TYPE_S2C; - } -} - -/****************************************************************************** - * bypass packet -- table limit / session evicted / duplicated packet - ******************************************************************************/ - -static int session_manager_runtime_bypass_packet_on_tcp_table_limit(struct session_manager_runtime *sess_mgr_rt, const struct tuple6 *key) -{ - if (key->ip_proto == IPPROTO_TCP && sess_mgr_rt->stat.tcp_sess_used >= sess_mgr_rt->cfg.tcp_session_max) - { - sess_mgr_rt->stat.tcp_pkts_bypass_table_full++; - return 1; - } - return 0; -} - -static int session_manager_runtime_bypass_packet_on_udp_table_limit(struct session_manager_runtime *sess_mgr_rt, const struct tuple6 *key) -{ - if (key->ip_proto == IPPROTO_UDP && sess_mgr_rt->stat.udp_sess_used >= sess_mgr_rt->cfg.udp_session_max) - { - sess_mgr_rt->stat.udp_pkts_bypass_table_full++; - return 1; - } - return 0; -} - -static int session_manager_runtime_bypass_packet_on_session_evicted(struct session_manager_runtime *sess_mgr_rt, const struct tuple6 *key) -{ - if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable && session_filter_lookup(sess_mgr_rt->evicte_sess_filter, key, sess_mgr_rt->now_ms)) - { - sess_mgr_rt->stat.udp_pkts_bypass_session_evicted++; - return 1; - } - - return 0; -} - -static int session_manager_runtime_bypass_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, const struct tuple6 *key) -{ - if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable == 0) - { - return 0; - } - - enum flow_type type = identify_flow_type_by_history(sess, key); - if (session_get_stat(sess, type, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess)) - { - if (packet_filter_lookup(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms)) - { - session_inc_stat(sess, type, STAT_DUPLICATE_PACKETS_BYPASS, 1); - session_inc_stat(sess, type, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt)); - switch (session_get_type(sess)) - { - case SESSION_TYPE_TCP: - sess_mgr_rt->stat.tcp_pkts_bypass_duplicated++; - break; - case SESSION_TYPE_UDP: - sess_mgr_rt->stat.udp_pkts_bypass_duplicated++; - break; - default: - assert(0); - break; - } - session_set_duplicate_traffic(sess); - - session_set_current_packet(sess, pkt); - session_set_flow_type(sess, type); - return 1; - } - else - { - packet_filter_add(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms); - return 0; - } - } - - return 0; -} - -void session_manager_runtime_record_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt) -{ - if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable) - { - packet_filter_add(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms); - } -} - -/****************************************************************************** - * config -- new / free / print - ******************************************************************************/ - -struct session_manager_config *session_manager_config_new(const char *toml_file) -{ - if (toml_file == NULL) - { - return NULL; - } - - struct session_manager_config *sess_mgr_cfg = (struct session_manager_config *)calloc(1, sizeof(struct session_manager_config)); - if (sess_mgr_cfg == NULL) - { - return NULL; - } - - int ret = 0; - ret += load_toml_integer_config(toml_file, "instance.id", (uint64_t *)&sess_mgr_cfg->instance_id, 0, 4095); - ret += load_toml_integer_config(toml_file, "packet_io.thread_num", (uint64_t *)&sess_mgr_cfg->thread_num, 0, MAX_THREAD_NUM); - ret += load_toml_integer_config(toml_file, "session_manager.tcp_session_max", (uint64_t *)&sess_mgr_cfg->tcp_session_max, EVICTE_SESSION_BURST * 2, UINT64_MAX); - ret += load_toml_integer_config(toml_file, "session_manager.udp_session_max", (uint64_t *)&sess_mgr_cfg->udp_session_max, EVICTE_SESSION_BURST * 2, UINT64_MAX); - - ret += load_toml_integer_config(toml_file, "session_manager.evict_old_on_tcp_table_limit", (uint64_t *)&sess_mgr_cfg->evict_old_on_tcp_table_limit, 0, 1); - ret += load_toml_integer_config(toml_file, "session_manager.evict_old_on_udp_table_limit", (uint64_t *)&sess_mgr_cfg->evict_old_on_udp_table_limit, 0, 1); - - ret += load_toml_integer_config(toml_file, "session_manager.expire_period_ms", (uint64_t *)&sess_mgr_cfg->expire_period_ms, 0, 60000); - ret += load_toml_integer_config(toml_file, "session_manager.expire_batch_max", (uint64_t *)&sess_mgr_cfg->expire_batch_max, 1, 1024); - - ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.init", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.init, 1, 60000); - ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.handshake", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.handshake, 1, 60000); - ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.data", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.data, 1, 15999999000); - ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.half_closed", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.half_closed, 1, 604800000); - ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.time_wait", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.time_wait, 1, 60000); - ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.discard_default", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.discard_default, 1, 15999999000); - ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.unverified_rst", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.unverified_rst, 1, 60000); - - ret += load_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.data", (uint64_t *)&sess_mgr_cfg->udp_timeout_ms.data, 1, 15999999000); - ret += load_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.discard_default", (uint64_t *)&sess_mgr_cfg->udp_timeout_ms.discard_default, 1, 15999999000); - - ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.enable", (uint64_t *)&sess_mgr_cfg->duplicated_packet_bloom_filter.enable, 0, 1); - ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.capacity", (uint64_t *)&sess_mgr_cfg->duplicated_packet_bloom_filter.capacity, 1, 4294967295); - ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.time_window_ms", (uint64_t *)&sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms, 1, 60000); - ret += load_toml_double_config(toml_file, "session_manager.duplicated_packet_bloom_filter.error_rate", (double *)&sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate, 0.0, 1.0); - - ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.enable", (uint64_t *)&sess_mgr_cfg->evicted_session_bloom_filter.enable, 0, 1); - ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.capacity", (uint64_t *)&sess_mgr_cfg->evicted_session_bloom_filter.capacity, 1, 4294967295); - ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.time_window_ms", (uint64_t *)&sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms, 1, 60000); - ret += load_toml_double_config(toml_file, "session_manager.evicted_session_bloom_filter.error_rate", (double *)&sess_mgr_cfg->evicted_session_bloom_filter.error_rate, 0.0, 1.0); - - ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.enable", (uint64_t *)&sess_mgr_cfg->tcp_reassembly.enable, 0, 1); - ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.timeout_ms", (uint64_t *)&sess_mgr_cfg->tcp_reassembly.timeout_ms, 1, 60000); - ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.buffered_segments_max", (uint64_t *)&sess_mgr_cfg->tcp_reassembly.buffered_segments_max, 2, 4096); - - if (ret != 0) - { - session_manager_config_free(sess_mgr_cfg); - return NULL; - } - - return sess_mgr_cfg; -} - -void session_manager_config_free(struct session_manager_config *sess_mgr_cfg) -{ - if (sess_mgr_cfg) - { - free(sess_mgr_cfg); - sess_mgr_cfg = NULL; - } -} - -void session_manager_config_print(struct session_manager_config *sess_mgr_cfg) -{ - if (sess_mgr_cfg) - { - // max session number - SESSION_MANAGER_LOG_INFO("session_manager.tcp_session_max : %lu", sess_mgr_cfg->tcp_session_max); - SESSION_MANAGER_LOG_INFO("session_manager.udp_session_max : %lu", sess_mgr_cfg->udp_session_max); - - // session overload - SESSION_MANAGER_LOG_INFO("session_manager.evict_old_on_tcp_table_limit : %d", sess_mgr_cfg->evict_old_on_tcp_table_limit); - SESSION_MANAGER_LOG_INFO("session_manager.evict_old_on_udp_table_limit : %d", sess_mgr_cfg->evict_old_on_udp_table_limit); - - // TCP timeout - SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.init : %lu", sess_mgr_cfg->tcp_timeout_ms.init); - SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.handshake : %lu", sess_mgr_cfg->tcp_timeout_ms.handshake); - SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.data : %lu", sess_mgr_cfg->tcp_timeout_ms.data); - SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.half_closed : %lu", sess_mgr_cfg->tcp_timeout_ms.half_closed); - SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.time_wait : %lu", sess_mgr_cfg->tcp_timeout_ms.time_wait); - SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.discard_default : %lu", sess_mgr_cfg->tcp_timeout_ms.discard_default); - SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.unverified_rst : %lu", sess_mgr_cfg->tcp_timeout_ms.unverified_rst); - - // UDP timeout - SESSION_MANAGER_LOG_INFO("session_manager.udp_timeout_ms.data : %lu", sess_mgr_cfg->udp_timeout_ms.data); - SESSION_MANAGER_LOG_INFO("session_manager.udp_timeout_ms.discard_default : %lu", sess_mgr_cfg->udp_timeout_ms.discard_default); - - // limit - SESSION_MANAGER_LOG_INFO("session_manager.expire_period_ms : %lu", sess_mgr_cfg->expire_period_ms); - SESSION_MANAGER_LOG_INFO("session_manager.expire_batch_max : %lu", sess_mgr_cfg->expire_batch_max); - - // duplicated packet filter - SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.enable : %d", sess_mgr_cfg->duplicated_packet_bloom_filter.enable); - SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.capacity : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.capacity); - SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.time_window_ms : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms); - SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.error_rate : %f", sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate); - - // eviction session filter - SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.enable : %d", sess_mgr_cfg->evicted_session_bloom_filter.enable); - SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.capacity : %lu", sess_mgr_cfg->evicted_session_bloom_filter.capacity); - SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.time_window_ms : %lu", sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms); - SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.error_rate : %f", sess_mgr_cfg->evicted_session_bloom_filter.error_rate); - - // TCP reassembly - SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.enable : %d", sess_mgr_cfg->tcp_reassembly.enable); - SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.timeout_ms : %lu", sess_mgr_cfg->tcp_reassembly.timeout_ms); - SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.buffered_segments_max : %lu", sess_mgr_cfg->tcp_reassembly.buffered_segments_max); - } -} - -/****************************************************************************** - * runtime -- new / free - ******************************************************************************/ - -struct session_manager_runtime *session_manager_runtime_new(const struct session_manager_config *sess_mgr_cfg, uint64_t now_ms) -{ - struct session_manager_runtime *sess_mgr_rt = (struct session_manager_runtime *)calloc(1, sizeof(struct session_manager_runtime)); - if (sess_mgr_rt == NULL) - { - return NULL; - } - memcpy(&sess_mgr_rt->cfg, sess_mgr_cfg, sizeof(struct session_manager_config)); - - sess_mgr_rt->sess_pool = session_pool_new(sess_mgr_rt->cfg.tcp_session_max + sess_mgr_rt->cfg.udp_session_max); - sess_mgr_rt->tcp_sess_table = session_table_new(); - sess_mgr_rt->udp_sess_table = session_table_new(); - sess_mgr_rt->sess_timer = session_timer_new(now_ms); - if (sess_mgr_rt->sess_pool == NULL || sess_mgr_rt->tcp_sess_table == NULL || sess_mgr_rt->udp_sess_table == NULL || sess_mgr_rt->sess_timer == NULL) - { - goto error; - } - if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable) - { - sess_mgr_rt->evicte_sess_filter = session_filter_new(sess_mgr_rt->cfg.evicted_session_bloom_filter.capacity, - sess_mgr_rt->cfg.evicted_session_bloom_filter.time_window_ms, - sess_mgr_rt->cfg.evicted_session_bloom_filter.error_rate, now_ms); - if (sess_mgr_rt->evicte_sess_filter == NULL) - { - goto error; - } - } - if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable) - { - sess_mgr_rt->dup_pkt_filter = packet_filter_new(sess_mgr_rt->cfg.duplicated_packet_bloom_filter.capacity, - sess_mgr_rt->cfg.duplicated_packet_bloom_filter.time_window_ms, - sess_mgr_rt->cfg.duplicated_packet_bloom_filter.error_rate, now_ms); - if (sess_mgr_rt->dup_pkt_filter == NULL) - { - goto error; - } - } - sess_mgr_rt->sf = snowflake_new(sess_mgr_rt->cfg.session_id_seed); - if (sess_mgr_rt->sf == NULL) - { - goto error; - } - - TAILQ_INIT(&sess_mgr_rt->evicte_list); - session_transition_init(); - sess_mgr_rt->now_ms = now_ms; - sess_mgr_rt->last_clean_expired_sess_ts = now_ms; - - return sess_mgr_rt; - -error: - session_manager_runtime_free(sess_mgr_rt); - return NULL; -} - -void session_manager_runtime_free(struct session_manager_runtime *sess_mgr_rt) -{ - struct session *sess; - if (sess_mgr_rt) - { - // free all evicted session - while ((sess = TAILQ_FIRST(&sess_mgr_rt->evicte_list))) - { - TAILQ_REMOVE(&sess_mgr_rt->evicte_list, sess, evicte_tqe); - session_manager_runtime_free_session(sess_mgr_rt, sess); - } - // free all udp session - while (sess_mgr_rt->udp_sess_table && (sess = session_table_find_lru(sess_mgr_rt->udp_sess_table))) - { - session_manager_runtime_free_session(sess_mgr_rt, sess); - } - // free all tcp session - while (sess_mgr_rt->tcp_sess_table && (sess = session_table_find_lru(sess_mgr_rt->tcp_sess_table))) - { - session_manager_runtime_free_session(sess_mgr_rt, sess); - } - if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable) - { - session_filter_free(sess_mgr_rt->evicte_sess_filter); - } - if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable) - { - packet_filter_free(sess_mgr_rt->dup_pkt_filter); - } - snowflake_free(sess_mgr_rt->sf); - session_timer_free(sess_mgr_rt->sess_timer); - session_table_free(sess_mgr_rt->udp_sess_table); - session_table_free(sess_mgr_rt->tcp_sess_table); - session_pool_free(sess_mgr_rt->sess_pool); - free(sess_mgr_rt); - sess_mgr_rt = NULL; - } -} - -/****************************************************************************** - * session -- new / free / lookup / updata / expire / evicte / clean - ******************************************************************************/ - -static void session_update(struct session_manager_runtime *sess_mgr_rt, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_type type) -{ - if (session_get_current_state(sess) == SESSION_STATE_INIT) - { - uint64_t sess_id = snowflake_generate(sess_mgr_rt->sf, sess_mgr_rt->now_ms / 1000); - session_set_id(sess, sess_id); - enum packet_direction pkt_dir = packet_get_direction(pkt); - if (type == FLOW_TYPE_C2S) - { - session_set_tuple6(sess, key); - if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External - { - session_set_direction(sess, SESSION_DIRECTION_OUTBOUND); - } - else - { - session_set_direction(sess, SESSION_DIRECTION_INBOUND); - } - tuple6_to_str(key, sess->tuple_str, sizeof(sess->tuple_str)); - } - else - { - struct tuple6 out; - tuple6_reverse(key, &out); - session_set_tuple6(sess, &out); - if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External - { - session_set_direction(sess, SESSION_DIRECTION_INBOUND); - } - else - { - session_set_direction(sess, SESSION_DIRECTION_OUTBOUND); - } - tuple6_to_str(&out, sess->tuple_str, sizeof(sess->tuple_str)); - } - - session_set_timestamp(sess, SESSION_TIMESTAMP_START, sess_mgr_rt->now_ms); - switch (key->ip_proto) - { - case IPPROTO_TCP: - session_set_type(sess, SESSION_TYPE_TCP); - break; - case IPPROTO_UDP: - session_set_type(sess, SESSION_TYPE_UDP); - break; - default: - assert(0); - break; - } - } - - session_inc_stat(sess, type, STAT_RAW_PACKETS_RECEIVED, 1); - session_inc_stat(sess, type, STAT_RAW_BYTES_RECEIVED, packet_get_raw_len(pkt)); - - if (!session_get_first_packet(sess, type)) - { - session_set_first_packet(sess, type, packet_dup(pkt)); - session_set_route_ctx(sess, type, packet_get_route_ctx(pkt)); - session_set_sids(sess, type, packet_get_sids(pkt)); - } - - session_set_current_packet(sess, pkt); - session_set_flow_type(sess, type); - session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, sess_mgr_rt->now_ms); - session_set_current_state(sess, next_state); -} - -static void session_manager_runtime_evicte_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, int reason) -{ - if (sess == NULL) - { - return; - } - - // when session add to evicted queue, session lifetime is over - enum session_state curr_state = session_get_current_state(sess); - enum session_state next_state = session_transition_run(curr_state, reason); - session_transition_log(sess, curr_state, next_state, reason); - session_set_current_state(sess, next_state); - if (!session_get_closing_reason(sess)) - { - if (reason == PORT_REUSE_EVICT) - { - session_set_closing_reason(sess, CLOSING_BY_PORT_REUSE_EVICTED); - } - if (reason == LRU_EVICT) - { - session_set_closing_reason(sess, CLOSING_BY_LRU_EVICTED); - } - } - session_timer_del(sess_mgr_rt->sess_timer, sess); - TAILQ_INSERT_TAIL(&sess_mgr_rt->evicte_list, sess, evicte_tqe); - - switch (session_get_type(sess)) - { - case SESSION_TYPE_TCP: - SESSION_MANAGER_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess)); - session_table_del(sess_mgr_rt->tcp_sess_table, sess); - SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp); - sess_mgr_rt->stat.tcp_sess_evicted++; - break; - case SESSION_TYPE_UDP: - SESSION_MANAGER_LOG_DEBUG("evicte udp old session: %lu", session_get_id(sess)); - session_table_del(sess_mgr_rt->udp_sess_table, sess); - if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable) - { - session_filter_add(sess_mgr_rt->evicte_sess_filter, session_get_tuple6(sess), sess_mgr_rt->now_ms); - } - SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp); - sess_mgr_rt->stat.udp_sess_evicted++; - break; - default: - assert(0); - break; - } -} - -static struct session *session_manager_runtime_lookup_tcp_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, const struct tuple6 *key) -{ - struct session *sess = session_table_find_tuple6(sess_mgr_rt->tcp_sess_table, key, 0); - if (sess == NULL) - { - return NULL; - } - - const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP); - const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr; - uint8_t flags = tcp_hdr_get_flags(hdr); - if ((flags & TH_SYN) == 0) - { - return sess; - } - - enum flow_type type = identify_flow_type_by_history(sess, key); - struct tcp_half *half = &sess->tcp_halfs[type]; - if ((half->isn && half->isn != tcp_hdr_get_seq(hdr)) || // recv SYN with different ISN - ((half->history & TH_FIN) || (half->history & TH_RST))) // recv SYN after FIN or RST - { - // TCP port reuse, evict old session - session_manager_runtime_evicte_session(sess_mgr_rt, sess, PORT_REUSE_EVICT); - return NULL; - } - else - { - // TCP SYN retransmission - return sess; - } -} - -static struct session *session_manager_runtime_new_tcp_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, const struct tuple6 *key) -{ - const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP); - const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr; - uint8_t flags = tcp_hdr_get_flags(hdr); - if (!(flags & TH_SYN)) - { - sess_mgr_rt->stat.tcp_pkts_bypass_session_not_found++; - return NULL; - } - - // tcp table full evict old session - if (sess_mgr_rt->cfg.evict_old_on_tcp_table_limit && sess_mgr_rt->stat.tcp_sess_used >= sess_mgr_rt->cfg.tcp_session_max - EVICTE_SESSION_BURST) - { - struct session *evic_sess = session_table_find_lru(sess_mgr_rt->tcp_sess_table); - session_manager_runtime_evicte_session(sess_mgr_rt, evic_sess, LRU_EVICT); - } - - enum flow_type type = (flags & TH_ACK) ? FLOW_TYPE_S2C : FLOW_TYPE_C2S; - struct session *sess = session_pool_pop(sess_mgr_rt->sess_pool); - if (sess == NULL) - { - assert(0); - return NULL; - } - session_init(sess); - sess->sess_mgr_rt = sess_mgr_rt; - sess->sess_mgr_stat = &sess_mgr_rt->stat; - - enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN); - session_update(sess_mgr_rt, sess, next_state, pkt, key, type); - session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN); - - if (tcp_init(sess_mgr_rt, sess) == -1) - { - assert(0); - session_pool_push(sess_mgr_rt->sess_pool, sess); - return NULL; - } - tcp_update(sess_mgr_rt, sess, type, tcp_layer); - - uint64_t timeout = (flags & TH_ACK) ? sess_mgr_rt->cfg.tcp_timeout_ms.handshake : sess_mgr_rt->cfg.tcp_timeout_ms.init; - session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + timeout); - session_table_add(sess_mgr_rt->tcp_sess_table, sess); - - if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable) - { - packet_filter_add(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms); - } - - SESS_MGR_STAT_INC(&sess_mgr_rt->stat, next_state, tcp); - sess_mgr_rt->stat.tcp_sess_used++; - sess_mgr_rt->stat.history_tcp_sessions++; - - return sess; -} - -static struct session *session_manager_runtime_new_udp_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, const struct tuple6 *key) -{ - // udp table full evict old session - if (sess_mgr_rt->cfg.evict_old_on_udp_table_limit && sess_mgr_rt->stat.udp_sess_used >= sess_mgr_rt->cfg.udp_session_max - EVICTE_SESSION_BURST) - { - struct session *evic_sess = session_table_find_lru(sess_mgr_rt->udp_sess_table); - session_manager_runtime_evicte_session(sess_mgr_rt, evic_sess, LRU_EVICT); - } - - struct session *sess = session_pool_pop(sess_mgr_rt->sess_pool); - if (sess == NULL) - { - assert(sess); - return NULL; - } - session_init(sess); - sess->sess_mgr_rt = sess_mgr_rt; - sess->sess_mgr_stat = &sess_mgr_rt->stat; - - enum flow_type type = identify_flow_type_by_port(ntohs(key->src_port), ntohs(key->dst_port)); - enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA); - session_update(sess_mgr_rt, sess, next_state, pkt, key, type); - session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA); - - session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.data); - session_table_add(sess_mgr_rt->udp_sess_table, sess); - - SESS_MGR_STAT_INC(&sess_mgr_rt->stat, next_state, udp); - sess_mgr_rt->stat.udp_sess_used++; - sess_mgr_rt->stat.history_udp_sessions++; - - return sess; -} - -static int session_manager_runtime_update_tcp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, const struct tuple6 *key) -{ - const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP); - const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr; - enum flow_type type = identify_flow_type_by_history(sess, key); - uint8_t flags = tcp_hdr_get_flags(hdr); - int inputs = 0; - inputs |= (flags & TH_SYN) ? TCP_SYN : NONE; - inputs |= (flags & TH_FIN) ? TCP_FIN : NONE; - inputs |= (flags & TH_RST) ? TCP_RST : NONE; - inputs |= tcp_layer->pld_len ? TCP_DATA : NONE; - - // update state - enum session_state curr_state = session_get_current_state(sess); - enum session_state next_state = session_transition_run(curr_state, inputs); - - // update session - session_update(sess_mgr_rt, sess, next_state, pkt, key, type); - session_transition_log(sess, curr_state, next_state, inputs); - - // update tcp - tcp_update(sess_mgr_rt, sess, type, tcp_layer); - - // set closing reason - if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess)) - { - if (flags & TH_FIN) - { - session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_FIN : CLOSING_BY_SERVER_FIN)); - } - if (flags & TH_RST) - { - session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_RST : CLOSING_BY_SERVER_RST)); - } - } - - // update timeout - struct tcp_half *curr = &sess->tcp_halfs[type]; - struct tcp_half *peer = &sess->tcp_halfs[(type == FLOW_TYPE_C2S ? FLOW_TYPE_S2C : FLOW_TYPE_C2S)]; - uint64_t timeout = 0; - switch (next_state) - { - case SESSION_STATE_OPENING: - if (flags & TH_SYN) - { - timeout = (flags & TH_ACK) ? sess_mgr_rt->cfg.tcp_timeout_ms.handshake : sess_mgr_rt->cfg.tcp_timeout_ms.init; - } - else - { - timeout = sess_mgr_rt->cfg.tcp_timeout_ms.data; - } - break; - case SESSION_STATE_ACTIVE: - timeout = sess_mgr_rt->cfg.tcp_timeout_ms.data; - break; - case SESSION_STATE_CLOSING: - if (flags & TH_FIN) - { - timeout = (peer->history & TH_FIN) ? sess_mgr_rt->cfg.tcp_timeout_ms.time_wait : sess_mgr_rt->cfg.tcp_timeout_ms.half_closed; - } - else if (flags & TH_RST) - { - // if fin is received, the expected sequence number should be increased by 1 - uint32_t expected = (peer->history & TH_FIN) ? peer->ack + 1 : peer->ack; - timeout = (expected == curr->seq) ? sess_mgr_rt->cfg.tcp_timeout_ms.time_wait : sess_mgr_rt->cfg.tcp_timeout_ms.unverified_rst; - } - else - { - timeout = sess_mgr_rt->cfg.tcp_timeout_ms.data; - } - break; - case SESSION_STATE_DISCARD: - timeout = sess_mgr_rt->cfg.tcp_timeout_ms.discard_default; - break; - default: - assert(0); - break; - } - session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + timeout); - - SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp); - - return 0; -} - -static int session_manager_runtime_update_udp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, const struct tuple6 *key) -{ - enum flow_type type = identify_flow_type_by_history(sess, key); - enum session_state curr_state = session_get_current_state(sess); - enum session_state next_state = session_transition_run(curr_state, UDP_DATA); - session_update(sess_mgr_rt, sess, next_state, pkt, key, type); - session_transition_log(sess, curr_state, next_state, UDP_DATA); - - if (session_get_current_state(sess) == SESSION_STATE_DISCARD) - { - session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.discard_default); - } - else - { - session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.data); - } - - SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp); - - return 0; -} - -struct session *session_manager_runtime_new_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, uint64_t now_ms) -{ - sess_mgr_rt->now_ms = now_ms; - - struct tuple6 key; - if (packet_get_innermost_tuple6(pkt, &key)) - { - return NULL; - } - switch (key.ip_proto) - { - case IPPROTO_TCP: - if (session_manager_runtime_bypass_packet_on_tcp_table_limit(sess_mgr_rt, &key)) - { - return NULL; - } - return session_manager_runtime_new_tcp_session(sess_mgr_rt, pkt, &key); - case IPPROTO_UDP: - if (session_manager_runtime_bypass_packet_on_session_evicted(sess_mgr_rt, &key)) - { - return NULL; - } - if (session_manager_runtime_bypass_packet_on_udp_table_limit(sess_mgr_rt, &key)) - { - return NULL; - } - return session_manager_runtime_new_udp_session(sess_mgr_rt, pkt, &key); - default: - return NULL; - } -} - -void session_manager_runtime_free_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess) -{ - if (sess) - { - SESSION_MANAGER_LOG_DEBUG("session %lu closed (%s)", session_get_id(sess), closing_reason_to_str(session_get_closing_reason(sess))); - - session_timer_del(sess_mgr_rt->sess_timer, sess); - switch (session_get_type(sess)) - { - case SESSION_TYPE_TCP: - tcp_clean(sess_mgr_rt, sess); - if (session_table_find_sessid(sess_mgr_rt->tcp_sess_table, session_get_id(sess), 0) == sess) - { - session_table_del(sess_mgr_rt->tcp_sess_table, sess); - } - SESS_MGR_STAT_DEC(&sess_mgr_rt->stat, session_get_current_state(sess), tcp); - sess_mgr_rt->stat.tcp_sess_used--; - break; - case SESSION_TYPE_UDP: - if (session_table_find_sessid(sess_mgr_rt->udp_sess_table, session_get_id(sess), 0) == sess) - { - session_table_del(sess_mgr_rt->udp_sess_table, sess); - } - SESS_MGR_STAT_DEC(&sess_mgr_rt->stat, session_get_current_state(sess), udp); - sess_mgr_rt->stat.udp_sess_used--; - break; - default: - assert(0); - break; - } - - packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_C2S)); - packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_S2C)); - session_set_first_packet(sess, FLOW_TYPE_C2S, NULL); - session_set_first_packet(sess, FLOW_TYPE_S2C, NULL); - session_clear_route_ctx(sess, FLOW_TYPE_C2S); - session_clear_route_ctx(sess, FLOW_TYPE_S2C); - session_clear_sids(sess, FLOW_TYPE_C2S); - session_clear_sids(sess, FLOW_TYPE_S2C); - session_set_current_state(sess, SESSION_STATE_INIT); - session_set_current_packet(sess, NULL); - session_set_flow_type(sess, FLOW_TYPE_NONE); - session_init(sess); - session_pool_push(sess_mgr_rt->sess_pool, sess); - sess = NULL; - } -} - -struct session *session_manager_runtime_lookup_session_by_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt) -{ - struct tuple6 key; - if (packet_get_innermost_tuple6(pkt, &key)) - { - return NULL; - } - switch (key.ip_proto) - { - case IPPROTO_UDP: - return session_table_find_tuple6(sess_mgr_rt->udp_sess_table, &key, 0); - case IPPROTO_TCP: - return session_manager_runtime_lookup_tcp_session(sess_mgr_rt, pkt, &key); - default: - return NULL; - } -} - -struct session *session_manager_runtime_lookup_session_by_id(struct session_manager_runtime *sess_mgr_rt, uint64_t sess_id) -{ - struct session *sess = NULL; - sess = session_table_find_sessid(sess_mgr_rt->tcp_sess_table, sess_id, 1); - if (sess) - { - return sess; - } - - sess = session_table_find_sessid(sess_mgr_rt->udp_sess_table, sess_id, 1); - if (sess) - { - return sess; - } - - return NULL; -} - -int session_manager_runtime_update_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, uint64_t now_ms) -{ - sess_mgr_rt->now_ms = now_ms; - - struct tuple6 key; - if (packet_get_innermost_tuple6(pkt, &key)) - { - return -1; - } - if (session_manager_runtime_bypass_duplicated_packet(sess_mgr_rt, sess, pkt, &key)) - { - return -1; - } - switch (session_get_type(sess)) - { - case SESSION_TYPE_TCP: - return session_manager_runtime_update_tcp_session(sess_mgr_rt, sess, pkt, &key); - case SESSION_TYPE_UDP: - return session_manager_runtime_update_udp_session(sess_mgr_rt, sess, pkt, &key); - default: - return -1; - } -} - -struct session *session_manager_runtime_get_expired_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms) -{ - sess_mgr_rt->now_ms = now_ms; - - struct session *sess = session_timer_expire(sess_mgr_rt->sess_timer, now_ms); - if (sess) - { - enum session_state curr_state = session_get_current_state(sess); - enum session_state next_state = session_transition_run(curr_state, TIMEOUT); - session_transition_log(sess, curr_state, next_state, TIMEOUT); - session_set_current_state(sess, next_state); - - switch (session_get_type(sess)) - { - case SESSION_TYPE_TCP: - SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp); - break; - case SESSION_TYPE_UDP: - SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp); - break; - default: - assert(0); - break; - } - - // next state is closed, need to free session - if (next_state == SESSION_STATE_CLOSED) - { - if (!session_get_closing_reason(sess)) - { - session_set_closing_reason(sess, CLOSING_BY_TIMEOUT); - } - return sess; - } - // next state is closing, only update timeout - else - { - switch (session_get_type(sess)) - { - case SESSION_TYPE_TCP: - session_timer_update(sess_mgr_rt->sess_timer, sess, now_ms + sess_mgr_rt->cfg.tcp_timeout_ms.data); - break; - case SESSION_TYPE_UDP: - session_timer_update(sess_mgr_rt->sess_timer, sess, now_ms + sess_mgr_rt->cfg.udp_timeout_ms.data); - break; - default: - assert(0); - break; - } - return NULL; - } - } - - return NULL; -} - -struct session *session_manager_runtime_get_evicted_session(struct session_manager_runtime *sess_mgr_rt) -{ - struct session *sess = TAILQ_FIRST(&sess_mgr_rt->evicte_list); - if (sess) - { - TAILQ_REMOVE(&sess_mgr_rt->evicte_list, sess, evicte_tqe); - } - return sess; -} - -uint64_t session_manager_runtime_clean_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size) -{ - sess_mgr_rt->now_ms = now_ms; - struct session *sess = NULL; - uint64_t cleaned_sess_num = 0; - uint64_t expired_sess_num = 0; - - uint8_t expired_sess_canbe_clean = 0; - if (now_ms - sess_mgr_rt->last_clean_expired_sess_ts >= sess_mgr_rt->cfg.expire_period_ms || - now_ms == UINT64_MAX) - { - expired_sess_canbe_clean = 1; - } - - for (uint64_t i = 0; i < array_size; i++) - { - // frist clean evicted session - sess = session_manager_runtime_get_evicted_session(sess_mgr_rt); - if (sess) - { - cleaned_sess[cleaned_sess_num++] = sess; - } - // then clean expired session - else - { - if (expired_sess_canbe_clean && expired_sess_num < sess_mgr_rt->cfg.expire_batch_max) - { - sess_mgr_rt->last_clean_expired_sess_ts = now_ms; - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, now_ms); - if (sess) - { - cleaned_sess[cleaned_sess_num++] = sess; - expired_sess_num++; - } - else - { - break; - } - } - else - { - break; - } - } - } - - return cleaned_sess_num; -} - -/****************************************************************************** - * stat -- get / print - ******************************************************************************/ - -struct session_manager_stat *session_manager_runtime_get_stat(struct session_manager_runtime *sess_mgr_rt) -{ - return &sess_mgr_rt->stat; -} - -void session_manager_runtime_print_stat(struct session_manager_runtime *sess_mgr_rt) -{ - struct session_manager_stat *stat = &sess_mgr_rt->stat; - - // TCP session - SESSION_MANAGER_LOG_INFO("runtime: %p, TCP session stat => history: %lu, used: %lu, opening: %lu, active: %lu, closing: %lu, discard: %lu, closed: %lu", - sess_mgr_rt, stat->history_tcp_sessions, stat->tcp_sess_used, stat->tcp_sess_opening, stat->tcp_sess_active, - stat->tcp_sess_closing, stat->tcp_sess_discard, stat->tcp_sess_closed); - // UDP session - SESSION_MANAGER_LOG_INFO("runtime: %p, UDP session stat => history: %lu, used: %lu, opening: %lu, active: %lu, closing: %lu, discard: %lu, closed: %lu", - sess_mgr_rt, stat->history_udp_sessions, stat->udp_sess_used, stat->udp_sess_opening, stat->udp_sess_active, - stat->udp_sess_closing, stat->udp_sess_discard, stat->udp_sess_closed); - // evicted session - SESSION_MANAGER_LOG_INFO("runtime: %p, evicted session stat => TCP: %lu, UDP: %lu", sess_mgr_rt, stat->tcp_sess_evicted, stat->udp_sess_evicted); - // Bypassed packet - SESSION_MANAGER_LOG_INFO("runtime: %p, bypassed TCP packet stat => table_full: %lu, session_not_found: %lu, duplicated: %lu", - sess_mgr_rt, stat->tcp_pkts_bypass_table_full, stat->tcp_pkts_bypass_session_not_found, stat->tcp_pkts_bypass_duplicated); - SESSION_MANAGER_LOG_INFO("runtime: %p, bypassed UDP packet stat => table_full: %lu, session_evicted: %lu, duplicated: %lu", - sess_mgr_rt, stat->udp_pkts_bypass_table_full, stat->udp_pkts_bypass_session_evicted, stat->udp_pkts_bypass_duplicated); - // TCP segment - SESSION_MANAGER_LOG_INFO("runtime: %p, TCP segment stat => input: %lu, consumed: %lu, timeout: %lu, retransmited: %lu, overlapped: %lu, omitted_too_many: %lu, inorder: %lu, reordered: %lu, buffered: %lu, freed: %lu", - sess_mgr_rt, stat->tcp_segs_input, stat->tcp_segs_consumed, stat->tcp_segs_timeout, stat->tcp_segs_retransmited, - stat->tcp_segs_overlapped, stat->tcp_segs_omitted_too_many, stat->tcp_segs_inorder, stat->tcp_segs_reordered, - stat->tcp_segs_buffered, stat->tcp_segs_freed); -} - -/****************************************************************************** - * scan - ******************************************************************************/ - -static inline uint8_t ipv4_in_range(const struct in_addr *addr, const struct in_addr *start, const struct in_addr *end) -{ - return (memcmp(addr, start, sizeof(struct in_addr)) >= 0 && memcmp(addr, end, sizeof(struct in_addr)) <= 0); -} - -static inline uint8_t ipv6_in_range(const struct in6_addr *addr, const struct in6_addr *start, const struct in6_addr *end) -{ - return (memcmp(addr, start, sizeof(struct in6_addr)) >= 0 && memcmp(addr, end, sizeof(struct in6_addr)) <= 0); -} - -uint64_t session_manager_runtime_scan(const struct session_manager_runtime *sess_mgr_rt, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size) -{ - uint64_t capacity = 0; - uint64_t max_loop = 0; - uint64_t mached_sess_num = 0; - const struct session *sess = NULL; - const struct tuple6 *tuple = NULL; - - if (sess_mgr_rt == NULL || opts == NULL || mached_sess_ids == NULL || array_size == 0) - { - return mached_sess_num; - } - if (opts->count == 0) - { - return mached_sess_num; - } - capacity = sess_mgr_rt->cfg.tcp_session_max + sess_mgr_rt->cfg.udp_session_max; - if (opts->cursor >= capacity) - { - return mached_sess_num; - } - - max_loop = MIN(capacity, opts->cursor + opts->count); - for (uint64_t i = opts->cursor; i < max_loop; i++) - { - sess = session_pool_get0(sess_mgr_rt->sess_pool, i); - tuple = session_get_tuple6(sess); - if (session_get_current_state(sess) == SESSION_STATE_INIT) - { - continue; - } - - if ((opts->flags & SESSION_SCAN_TYPE) && opts->type != session_get_type(sess)) - { - continue; - } - if ((opts->flags & SESSION_SCAN_STATE) && opts->state != session_get_current_state(sess)) - { - continue; - } - if ((opts->flags & SESSION_SCAN_CREATE_TIME) && - (session_get_timestamp(sess, SESSION_TIMESTAMP_START) < opts->create_time_ms[0] || - session_get_timestamp(sess, SESSION_TIMESTAMP_START) > opts->create_time_ms[1])) - { - continue; - } - if ((opts->flags & SESSION_SCAN_LAST_PKT_TIME) && - (session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) < opts->last_pkt_time_ms[0] || - session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) > opts->last_pkt_time_ms[1])) - { - continue; - } - if ((opts->flags & SESSION_SCAN_SPORT) && opts->src_port != tuple->src_port) - { - continue; - } - if ((opts->flags & SESSION_SCAN_DPORT) && opts->dst_port != tuple->dst_port) - { - continue; - } - if (opts->flags & SESSION_SCAN_SIP) - { - if (opts->addr_family != tuple->addr_family) - { - continue; - } - if ((opts->addr_family == AF_INET) && !ipv4_in_range(&tuple->src_addr.v4, &opts->src_addr[0].v4, &opts->src_addr[1].v4)) - { - continue; - } - if ((opts->addr_family == AF_INET6) && !ipv6_in_range(&tuple->src_addr.v6, &opts->src_addr[0].v6, &opts->src_addr[1].v6)) - { - continue; - } - } - if (opts->flags & SESSION_SCAN_DIP) - { - if (opts->addr_family != tuple->addr_family) - { - continue; - } - if ((opts->addr_family == AF_INET) && !ipv4_in_range(&tuple->dst_addr.v4, &opts->dst_addr[0].v4, &opts->dst_addr[1].v4)) - { - continue; - } - if ((opts->addr_family == AF_INET6) && !ipv6_in_range(&tuple->dst_addr.v6, &opts->dst_addr[0].v6, &opts->dst_addr[1].v6)) - { - continue; - } - } - - mached_sess_ids[mached_sess_num++] = session_get_id(sess); - if (mached_sess_num >= array_size) - { - break; - } - } - - SESSION_MANAGER_LOG_DEBUG("session scan => cursor: %lu, count: %lu, mached_sess_num: %lu", opts->cursor, opts->count, mached_sess_num); - return mached_sess_num; -} - -/****************************************************************************** - * other - ******************************************************************************/ - -void session_set_discard(struct session *sess) -{ - struct session_manager_runtime *sess_mgr_rt = sess->sess_mgr_rt; - enum session_type type = session_get_type(sess); - enum session_state curr_state = session_get_current_state(sess); - enum session_state next_state = session_transition_run(curr_state, USER_CLOSE); - session_transition_log(sess, curr_state, next_state, USER_CLOSE); - session_set_current_state(sess, next_state); - - switch (type) - { - case SESSION_TYPE_TCP: - session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.tcp_timeout_ms.discard_default); - SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp); - break; - case SESSION_TYPE_UDP: - session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.discard_default); - SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp); - break; - default: - assert(0); - break; - } -} \ No newline at end of file diff --git a/infra/session_manager/session_manager_runtime.h b/infra/session_manager/session_manager_runtime.h deleted file mode 100644 index 0b5a961..0000000 --- a/infra/session_manager/session_manager_runtime.h +++ /dev/null @@ -1,184 +0,0 @@ -#pragma once - -#ifdef __cplusplus -extern "C" -{ -#endif - -#include "tuple.h" -#include "stellar/session.h" - -#define SESSION_MANAGER_LOG_FATAL(format, ...) STELLAR_LOG_FATAL(__thread_local_logger, "session manager", format, ##__VA_ARGS__) -#define SESSION_MANAGER_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "session manager", format, ##__VA_ARGS__) -#define SESSION_MANAGER_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "session manager", format, ##__VA_ARGS__) -#define SESSION_MANAGER_LOG_INFO(format, ...) STELLAR_LOG_INFO(__thread_local_logger, "session manager", format, ##__VA_ARGS__) - -struct session_manager_config -{ - uint64_t instance_id; - uint16_t thread_num; - uint64_t session_id_seed; - uint64_t tcp_session_max; - uint64_t udp_session_max; - - uint8_t evict_old_on_tcp_table_limit; // range: [0, 1] - uint8_t evict_old_on_udp_table_limit; // range: [0, 1] - - uint64_t expire_period_ms; // range: [0, 60000] (ms) - uint64_t expire_batch_max; // range: [1, 1024] - - struct - { - uint64_t init; // range: [1, 60000] (ms) - uint64_t handshake; // range: [1, 60000] (ms) - uint64_t data; // range: [1, 15999999000] (ms) - uint64_t half_closed; // range: [1, 604800000] (ms) - uint64_t time_wait; // range: [1, 600000] (ms) - uint64_t discard_default; // range: [1, 15999999000] (ms) - uint64_t unverified_rst; // range: [1, 600000] (ms) - } tcp_timeout_ms; - - struct - { - uint64_t data; // range: [1, 15999999000] (ms) - uint64_t discard_default; // range: [1, 15999999000] (ms) - } udp_timeout_ms; - - struct - { - uint8_t enable; // range: [0, 1] - uint32_t capacity; // range: [1, 4294967295] - uint32_t time_window_ms; // range: [1, 60000] (ms) - double error_rate; // range: [0.0, 1.0] - } duplicated_packet_bloom_filter; - - struct - { - uint8_t enable; // range: [0, 1] - uint32_t capacity; // range: [1, 4294967295] - uint32_t time_window_ms; // range: [1, 60000] (ms) - double error_rate; // range: [0.0, 1.0] - } evicted_session_bloom_filter; - - struct - { - uint8_t enable; // range: [0, 1] - uint32_t timeout_ms; // range: [1, 60000] (ms) - uint32_t buffered_segments_max; // range: [2, 4096] - } tcp_reassembly; -}; - -struct session_manager_stat -{ - // TCP session - uint64_t history_tcp_sessions; - uint64_t tcp_sess_used; - uint64_t tcp_sess_opening; - uint64_t tcp_sess_active; - uint64_t tcp_sess_closing; - uint64_t tcp_sess_discard; - uint64_t tcp_sess_closed; - - // UDP session - uint64_t history_udp_sessions; - uint64_t udp_sess_used; - uint64_t udp_sess_opening; - uint64_t udp_sess_active; - uint64_t udp_sess_closing; - uint64_t udp_sess_discard; - uint64_t udp_sess_closed; - - // Evicted session - uint64_t tcp_sess_evicted; // sum - uint64_t udp_sess_evicted; // sum - - // Packet - uint64_t udp_pkts_bypass_table_full; // sum - uint64_t tcp_pkts_bypass_table_full; // sum - uint64_t tcp_pkts_bypass_session_not_found; // sum - uint64_t tcp_pkts_bypass_duplicated; // sum - uint64_t udp_pkts_bypass_duplicated; // sum - uint64_t udp_pkts_bypass_session_evicted; // sum - - // TCP segments - uint64_t tcp_segs_input; // sum - uint64_t tcp_segs_consumed; // sum - uint64_t tcp_segs_timeout; // sum - uint64_t tcp_segs_retransmited; // sum - uint64_t tcp_segs_overlapped; // sum - uint64_t tcp_segs_omitted_too_many; // sum - uint64_t tcp_segs_inorder; // sum - uint64_t tcp_segs_reordered; // sum - uint64_t tcp_segs_buffered; // sum - uint64_t tcp_segs_freed; // sum -} __attribute__((aligned(64))); - -enum session_scan_flags -{ - SESSION_SCAN_TYPE = 1 << 0, - SESSION_SCAN_STATE = 1 << 1, - - SESSION_SCAN_SIP = 1 << 2, - SESSION_SCAN_DIP = 1 << 3, - - SESSION_SCAN_SPORT = 1 << 4, - SESSION_SCAN_DPORT = 1 << 5, - - SESSION_SCAN_CREATE_TIME = 1 << 6, - SESSION_SCAN_LAST_PKT_TIME = 1 << 7, -}; - -struct session_scan_opts -{ - // required - uint32_t flags; - uint32_t cursor; - uint32_t count; - - // optional - enum session_type type; - enum session_state state; - - uint32_t addr_family; // AF_INET or AF_INET6 - union ip_address src_addr[2]; // network byte order - union ip_address dst_addr[2]; // network byte order - uint16_t src_port; // network byte order - uint16_t dst_port; // network byte order - - uint64_t create_time_ms[2]; - uint64_t last_pkt_time_ms[2]; -}; - -// new/free/print config -struct session_manager_config *session_manager_config_new(const char *toml_file); -void session_manager_config_free(struct session_manager_config *sess_mgr_cfg); -void session_manager_config_print(struct session_manager_config *sess_mgr_cfg); - -// new/free runtime -struct session_manager_runtime; -struct session_manager_runtime *session_manager_runtime_new(const struct session_manager_config *sess_mgr_cfg, uint64_t now_ms); -void session_manager_runtime_free(struct session_manager_runtime *sess_mgr_rt); - -// new/free/lookup/update/clean session -struct session *session_manager_runtime_new_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, uint64_t now_ms); -void session_manager_runtime_free_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess); -struct session *session_manager_runtime_lookup_session_by_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt); -struct session *session_manager_runtime_lookup_session_by_id(struct session_manager_runtime *sess_mgr_rt, uint64_t sess_id); -int session_manager_runtime_update_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, uint64_t now_ms); -struct session *session_manager_runtime_get_expired_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms); -struct session *session_manager_runtime_get_evicted_session(struct session_manager_runtime *sess_mgr_rt); -uint64_t session_manager_runtime_clean_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size); - -// stat -struct session_manager_stat *session_manager_runtime_get_stat(struct session_manager_runtime *sess_mgr_rt); -void session_manager_runtime_print_stat(struct session_manager_runtime *sess_mgr_rt); - -// scan -uint64_t session_manager_runtime_scan(const struct session_manager_runtime *sess_mgr_rt, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size); - -// duplicated packet -void session_manager_runtime_record_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt); - -#ifdef __cplusplus -} -#endif diff --git a/infra/session_manager/session_manager_stat.c b/infra/session_manager/session_manager_stat.c new file mode 100644 index 0000000..8591f6b --- /dev/null +++ b/infra/session_manager/session_manager_stat.c @@ -0,0 +1,39 @@ +#include "session_manager_log.h" +#include "session_manager_stat.h" + +uint64_t session_manager_stat_get(struct session_manager_stat *stat, enum sess_mgr_stat_type type) +{ + switch (type) + { +#define XX(_type, _name) case _type: return stat->_name; + SESS_MGR_STAT_MAP(XX) +#undef XX + default: + return 0; + } +} + +void session_manager_stat_print(struct session_manager_stat *stat) +{ + // TCP session + SESSION_MANAGER_LOG_INFO("runtime: %p, TCP session stat => history: %lu, used: %lu, opening: %lu, active: %lu, closing: %lu, discard: %lu, closed: %lu", + stat, stat->history_tcp_sessions, stat->tcp_sess_used, stat->tcp_sess_opening, stat->tcp_sess_active, + stat->tcp_sess_closing, stat->tcp_sess_discard, stat->tcp_sess_closed); + // UDP session + SESSION_MANAGER_LOG_INFO("runtime: %p, UDP session stat => history: %lu, used: %lu, opening: %lu, active: %lu, closing: %lu, discard: %lu, closed: %lu", + stat, stat->history_udp_sessions, stat->udp_sess_used, stat->udp_sess_opening, stat->udp_sess_active, + stat->udp_sess_closing, stat->udp_sess_discard, stat->udp_sess_closed); + // Evicted session + SESSION_MANAGER_LOG_INFO("runtime: %p, evicted session stat => TCP: %lu, UDP: %lu", + stat, stat->tcp_sess_evicted, stat->udp_sess_evicted); + // Bypassed packet + SESSION_MANAGER_LOG_INFO("runtime: %p, bypassed TCP packet stat => table_full: %lu, session_not_found: %lu, duplicated: %lu", + stat, stat->tcp_pkts_bypass_table_full, stat->tcp_pkts_bypass_session_not_found, stat->tcp_pkts_bypass_duplicated); + SESSION_MANAGER_LOG_INFO("runtime: %p, bypassed UDP packet stat => table_full: %lu, session_evicted: %lu, duplicated: %lu", + stat, stat->udp_pkts_bypass_table_full, stat->udp_pkts_bypass_session_evicted, stat->udp_pkts_bypass_duplicated); + // TCP segment + SESSION_MANAGER_LOG_INFO("runtime: %p, TCP segment stat => input: %lu, consumed: %lu, timeout: %lu, retransmited: %lu, overlapped: %lu, omitted_too_many: %lu, inorder: %lu, reordered: %lu, buffered: %lu, freed: %lu", + stat, stat->tcp_segs_input, stat->tcp_segs_consumed, stat->tcp_segs_timeout, stat->tcp_segs_retransmited, + stat->tcp_segs_overlapped, stat->tcp_segs_omitted_too_many, stat->tcp_segs_inorder, stat->tcp_segs_reordered, + stat->tcp_segs_buffered, stat->tcp_segs_freed); +} diff --git a/infra/session_manager/session_manager_stat.h b/infra/session_manager/session_manager_stat.h new file mode 100644 index 0000000..b279764 --- /dev/null +++ b/infra/session_manager/session_manager_stat.h @@ -0,0 +1,166 @@ +#pragma once + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include + +#define SESS_MGR_STAT_INC(stat, state, proto) \ + { \ + switch ((state)) \ + { \ + case SESSION_STATE_OPENING: \ + (stat)->proto##_sess_opening++; \ + break; \ + case SESSION_STATE_ACTIVE: \ + (stat)->proto##_sess_active++; \ + break; \ + case SESSION_STATE_CLOSING: \ + (stat)->proto##_sess_closing++; \ + break; \ + case SESSION_STATE_DISCARD: \ + (stat)->proto##_sess_discard++; \ + break; \ + case SESSION_STATE_CLOSED: \ + (stat)->proto##_sess_closed++; \ + break; \ + default: \ + break; \ + } \ + } + +#define SESS_MGR_STAT_DEC(stat, state, proto) \ + { \ + switch ((state)) \ + { \ + case SESSION_STATE_OPENING: \ + (stat)->proto##_sess_opening--; \ + break; \ + case SESSION_STATE_ACTIVE: \ + (stat)->proto##_sess_active--; \ + break; \ + case SESSION_STATE_CLOSING: \ + (stat)->proto##_sess_closing--; \ + break; \ + case SESSION_STATE_DISCARD: \ + (stat)->proto##_sess_discard--; \ + break; \ + case SESSION_STATE_CLOSED: \ + (stat)->proto##_sess_closed--; \ + break; \ + default: \ + break; \ + } \ + } + +#define SESS_MGR_STAT_UPDATE(stat, curr, next, proto) \ + { \ + if (curr != next) \ + { \ + SESS_MGR_STAT_DEC(stat, curr, proto); \ + SESS_MGR_STAT_INC(stat, next, proto); \ + } \ + } + +struct session_manager_stat +{ + // TCP session + uint64_t history_tcp_sessions; + uint64_t tcp_sess_used; + uint64_t tcp_sess_opening; + uint64_t tcp_sess_active; + uint64_t tcp_sess_closing; + uint64_t tcp_sess_discard; + uint64_t tcp_sess_closed; + + // UDP session + uint64_t history_udp_sessions; + uint64_t udp_sess_used; + uint64_t udp_sess_opening; + uint64_t udp_sess_active; + uint64_t udp_sess_closing; + uint64_t udp_sess_discard; + uint64_t udp_sess_closed; + + // Evicted session + uint64_t tcp_sess_evicted; // sum + uint64_t udp_sess_evicted; // sum + + // Packet + uint64_t udp_pkts_bypass_table_full; // sum + uint64_t tcp_pkts_bypass_table_full; // sum + uint64_t tcp_pkts_bypass_session_not_found; // sum + uint64_t tcp_pkts_bypass_duplicated; // sum + uint64_t udp_pkts_bypass_duplicated; // sum + uint64_t udp_pkts_bypass_session_evicted; // sum + + // TCP segments + uint64_t tcp_segs_input; // sum + uint64_t tcp_segs_consumed; // sum + uint64_t tcp_segs_timeout; // sum + uint64_t tcp_segs_retransmited; // sum + uint64_t tcp_segs_overlapped; // sum + uint64_t tcp_segs_omitted_too_many; // sum + uint64_t tcp_segs_inorder; // sum + uint64_t tcp_segs_reordered; // sum + uint64_t tcp_segs_buffered; // sum + uint64_t tcp_segs_freed; // sum +} __attribute__((aligned(64))); + +#define SESS_MGR_STAT_MAP(XX) \ + XX(SESS_MGR_STAT_HISTORY_TCP_SESSIONS, history_tcp_sessions) \ + XX(SESS_MGR_STAT_TCP_SESS_USED, tcp_sess_used) \ + XX(SESS_MGR_STAT_TCP_SESS_OPENING, tcp_sess_opening) \ + XX(SESS_MGR_STAT_TCP_SESS_ACTIVE, tcp_sess_active) \ + XX(SESS_MGR_STAT_TCP_SESS_CLOSING, tcp_sess_closing) \ + XX(SESS_MGR_STAT_TCP_SESS_DISCARD, tcp_sess_discard) \ + XX(SESS_MGR_STAT_TCP_SESS_CLOSED, tcp_sess_closed) \ + XX(SESS_MGR_STAT_HISTORY_UDP_SESSIONS, history_udp_sessions) \ + XX(SESS_MGR_STAT_UDP_SESS_USED, udp_sess_used) \ + XX(SESS_MGR_STAT_UDP_SESS_OPENING, udp_sess_opening) \ + XX(SESS_MGR_STAT_UDP_SESS_ACTIVE, udp_sess_active) \ + XX(SESS_MGR_STAT_UDP_SESS_CLOSING, udp_sess_closing) \ + XX(SESS_MGR_STAT_UDP_SESS_DISCARD, udp_sess_discard) \ + XX(SESS_MGR_STAT_UDP_SESS_CLOSED, udp_sess_closed) \ + XX(SESS_MGR_STAT_TCP_SESS_EVICTED, tcp_sess_evicted) \ + XX(SESS_MGR_STAT_UDP_SESS_EVICTED, udp_sess_evicted) \ + XX(SESS_MGR_STAT_UDP_PKTS_BYPASS_TABLE_FULL, udp_pkts_bypass_table_full) \ + XX(SESS_MGR_STAT_TCP_PKTS_BYPASS_TABLE_FULL, tcp_pkts_bypass_table_full) \ + XX(SESS_MGR_STAT_TCP_PKTS_BYPASS_SESSION_NOT_FOUND, tcp_pkts_bypass_session_not_found) \ + XX(SESS_MGR_STAT_TCP_PKTS_BYPASS_DUPLICATED, tcp_pkts_bypass_duplicated) \ + XX(SESS_MGR_STAT_UDP_PKTS_BYPASS_DUPLICATED, udp_pkts_bypass_duplicated) \ + XX(SESS_MGR_STAT_UDP_PKTS_BYPASS_SESSION_EVICTED, udp_pkts_bypass_session_evicted) \ + XX(SESS_MGR_STAT_TCP_SEGS_INPUT, tcp_segs_input) \ + XX(SESS_MGR_STAT_TCP_SEGS_CONSUMED, tcp_segs_consumed) \ + XX(SESS_MGR_STAT_TCP_SEGS_TIMEOUT, tcp_segs_timeout) \ + XX(SESS_MGR_STAT_TCP_SEGS_RETRANSMITED, tcp_segs_retransmited) \ + XX(SESS_MGR_STAT_TCP_SEGS_OVERLAPPED, tcp_segs_overlapped) \ + XX(SESS_MGR_STAT_TCP_SEGS_OMITTED_TOO_MANY, tcp_segs_omitted_too_many) \ + XX(SESS_MGR_STAT_TCP_SEGS_INORDER, tcp_segs_inorder) \ + XX(SESS_MGR_STAT_TCP_SEGS_REORDERED, tcp_segs_reordered) \ + XX(SESS_MGR_STAT_TCP_SEGS_BUFFERED, tcp_segs_buffered) \ + XX(SESS_MGR_STAT_TCP_SEGS_FREED, tcp_segs_freed) + +enum sess_mgr_stat_type +{ +#define XX(type, name) type, + SESS_MGR_STAT_MAP(XX) +#undef XX + SESS_MGR_STAT_MAX +}; + +__attribute__((unused)) static const char sess_mgr_stat_str[SESS_MGR_STAT_MAX][64] = +{ +#define XX(type, name) #name, + SESS_MGR_STAT_MAP(XX) +#undef XX +}; + +uint64_t session_manager_stat_get(struct session_manager_stat *stat, enum sess_mgr_stat_type type); +void session_manager_stat_print(struct session_manager_stat *stat); + +#ifdef __cplusplus +} +#endif diff --git a/infra/session_manager/session_table.h b/infra/session_manager/session_table.h index 5dc73fb..2452361 100644 --- a/infra/session_manager/session_table.h +++ b/infra/session_manager/session_table.h @@ -5,6 +5,8 @@ extern "C" { #endif +#include "tuple.h" + struct session_table; struct session_table *session_table_new(); void session_table_free(struct session_table *table); diff --git a/infra/session_manager/session_utils.c b/infra/session_manager/session_utils.c index 801ddd4..6bf2386 100644 --- a/infra/session_manager/session_utils.c +++ b/infra/session_manager/session_utils.c @@ -1,6 +1,6 @@ #include "stellar/exdata.h" #include "session_internal.h" -#include "session_manager_runtime.h" +#include "session_manager_stat.h" void session_init(struct session *sess) { diff --git a/infra/session_manager/test/default_config.h b/infra/session_manager/test/default_config.h deleted file mode 100644 index f6d8af6..0000000 --- a/infra/session_manager/test/default_config.h +++ /dev/null @@ -1,68 +0,0 @@ - - -#pragma once - -#ifdef __cplusplus -extern "C" -{ -#endif - -#include "session_manager_runtime.h" - -static struct session_manager_config sess_mgr_cfg = { - .instance_id = 1, - .thread_num = 1, - .session_id_seed = 0xFFFFF, - .tcp_session_max = 256, - .udp_session_max = 256, - - .evict_old_on_tcp_table_limit = 1, - .evict_old_on_udp_table_limit = 1, - - .expire_period_ms = 0, - .expire_batch_max = 1024, - - .tcp_timeout_ms = - { - .init = 1, - .handshake = 2, - .data = 3, - .half_closed = 4, - .time_wait = 5, - .discard_default = 6, - .unverified_rst = 7, - }, - - .udp_timeout_ms = - { - .data = 8, - .discard_default = 0, - }, - - .duplicated_packet_bloom_filter = - { - .enable = 1, - .capacity = 1000, - .time_window_ms = 10, - .error_rate = 0.0001, - }, - - .evicted_session_bloom_filter = - { - .enable = 1, - .capacity = 1000, - .time_window_ms = 10, - .error_rate = 0.0001, - }, - - .tcp_reassembly = - { - .enable = 1, - .timeout_ms = 1000, - .buffered_segments_max = 16, - }, -}; - -#ifdef __cplusplus -} -#endif diff --git a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp index 0f7e80c..ee382a2 100644 --- a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp +++ b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp @@ -1,10 +1,4 @@ -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" +#include "test_utils.h" /****************************************************************************** * case: TCP init -> opening (by TCP Fast Open) @@ -263,11 +257,11 @@ TEST(CASE, TCP_FAST_OPEN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S fast open packet\n"); @@ -276,9 +270,10 @@ TEST(CASE, TCP_FAST_OPEN) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -347,7 +342,7 @@ TEST(CASE, TCP_FAST_OPEN) session_free_tcp_segment(sess, seg); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -355,24 +350,25 @@ TEST(CASE, TCP_FAST_OPEN) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp index 8ae1a9b..b8d0334 100644 --- a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp +++ b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp @@ -1,29 +1,15 @@ -#include - -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" - -static void packet_set_ip_id(struct packet *pkt, uint16_t ip_id) -{ - const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4); - EXPECT_TRUE(ipv4_layer); - struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr; - hdr->ip_id = htons(ip_id); -} +#include "test_utils.h" #if 1 TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -32,12 +18,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); @@ -48,12 +37,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == -1); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1); @@ -63,20 +55,23 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP) memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); memset(&pkt, 0, sizeof(pkt)); packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn)); - packet_set_ip_id(&pkt, 0x1234); + packet_overwrite_ipid(&pkt, 0x1234); printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -85,11 +80,11 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -98,12 +93,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); @@ -114,12 +112,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == -1); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1); @@ -129,20 +130,23 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP) memcpy(synack_retransmission, tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack)); memset(&pkt, 0, sizeof(pkt)); packet_parse(&pkt, (const char *)synack_retransmission, sizeof(tcp_pkt2_s2c_syn_ack)); - packet_set_ip_id(&pkt, 0x1234); + packet_overwrite_ipid(&pkt, 0x1234); printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -151,12 +155,12 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; char syn_retransmission[1500] = {0}; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -165,12 +169,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); @@ -179,16 +186,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP) memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); memset(&pkt, 0, sizeof(pkt)); packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn)); - packet_set_ip_id(&pkt, 0x1234); + packet_overwrite_ipid(&pkt, 0x1234); printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); @@ -197,16 +207,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP) memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); memset(&pkt, 0, sizeof(pkt)); packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn)); - packet_set_ip_id(&pkt, 0x1235); + packet_overwrite_ipid(&pkt, 0x1235); printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); @@ -217,16 +230,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -235,14 +251,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - struct session_manager_config _cfg; - memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config)); - _cfg.duplicated_packet_bloom_filter.enable = 0; + struct session_manager_cfg _sess_mgr_cfg; + memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg)); + _sess_mgr_cfg.duplicated_packet_bloom_filter.enable = 0; - sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -251,12 +267,15 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); @@ -267,16 +286,19 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -285,14 +307,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - struct session_manager_config _cfg; - memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config)); - _cfg.duplicated_packet_bloom_filter.enable = 0; + struct session_manager_cfg _sess_mgr_cfg; + memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg)); + _sess_mgr_cfg.duplicated_packet_bloom_filter.enable = 0; - sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -301,12 +323,15 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); @@ -317,16 +342,19 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + + // check stat + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp index d7ec896..50e024d 100644 --- a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp +++ b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp @@ -1,33 +1,18 @@ -#include - -#include "utils_internal.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" - -static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr) -{ - const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4); - EXPECT_TRUE(ipv4_layer); - struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr; - hdr->ip_src.s_addr = htonl(addr); -} +#include "test_utils.h" #if 1 TEST(TCP_OVERLOAD, EVICT_OLD_SESS) { struct packet pkt; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - struct session_manager_config _cfg; - memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config)); - _cfg.tcp_session_max = RX_BURST_MAX * 2; - _cfg.udp_session_max = RX_BURST_MAX * 2; + struct session_manager_cfg _sess_mgr_cfg; + memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg)); + _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2; + _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2; - sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -36,15 +21,15 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS) printf("<= Packet Parse: done\n\n"); // new session - for (uint32_t i = 0; i < _cfg.tcp_session_max; i++) + for (uint32_t i = 0; i < _sess_mgr_cfg.tcp_session_max; i++) { - packet_set_ip_src_addr(&pkt, i); - EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1)); + packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i); + EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1)); } - printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.tcp_session_max); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); - EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); @@ -53,7 +38,7 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS) EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == 0); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -61,16 +46,16 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS) TEST(TCP_OVERLOAD, EVICT_NEW_SESS) { struct packet pkt; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - struct session_manager_config _cfg; - memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config)); - _cfg.tcp_session_max = RX_BURST_MAX * 2; - _cfg.udp_session_max = RX_BURST_MAX * 2; - _cfg.evict_old_on_tcp_table_limit = 0; + struct session_manager_cfg _sess_mgr_cfg; + memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg)); + _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2; + _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2; + _sess_mgr_cfg.evict_old_on_tcp_table_limit = 0; - sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -79,16 +64,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS) printf("<= Packet Parse: done\n\n"); // new session - for (uint32_t i = 0; i < _cfg.tcp_session_max; i++) + for (uint32_t i = 0; i < _sess_mgr_cfg.tcp_session_max; i++) { - packet_set_ip_src_addr(&pkt, i); - EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1)); + packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i); + EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1)); } - printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.tcp_session_max); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); - EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max); - EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _sess_mgr_cfg.tcp_session_max); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0); @@ -99,15 +84,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS) // table full, evict new session for (uint32_t i = 0; i < RX_BURST_MAX; i++) { - packet_set_ip_src_addr(&pkt, _cfg.tcp_session_max + i); - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); - EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL); + uint32_t idx = _sess_mgr_cfg.tcp_session_max + i; + packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL); } printf("=> Session Manager: after evicte new session\n"); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); - EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max); - EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max); + EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _sess_mgr_cfg.tcp_session_max); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0); @@ -115,7 +101,7 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS) EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp index cb7b8b6..fbc8adb 100644 --- a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp +++ b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp @@ -1,34 +1,19 @@ -#include - -#include "utils_internal.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" - -static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr) -{ - const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4); - EXPECT_TRUE(ipv4_layer); - struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr; - hdr->ip_src.s_addr = htonl(addr); -} +#include "test_utils.h" #if 1 TEST(UDP_OVERLOAD, EVICT_OLD_SESS) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - struct session_manager_config _cfg; - memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config)); - _cfg.tcp_session_max = RX_BURST_MAX * 2; - _cfg.udp_session_max = RX_BURST_MAX * 2; + struct session_manager_cfg _sess_mgr_cfg; + memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg)); + _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2; + _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2; - sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -37,15 +22,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) printf("<= Packet Parse: done\n\n"); // new session - for (uint32_t i = 0; i < _cfg.udp_session_max; i++) + for (uint32_t i = 0; i < _sess_mgr_cfg.udp_session_max; i++) { - packet_set_ip_src_addr(&pkt, i); - EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1)); + packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i); + EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1)); } - printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.udp_session_max); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); - EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); @@ -57,10 +42,10 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) // evicted session while (1) { - sess = session_manager_runtime_get_evicted_session(sess_mgr_rt); + sess = session_manager_rte_get_evicted_session(sess_mgr_rte); if (sess) { - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); } else { @@ -70,12 +55,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) for (uint32_t i = 0; i < RX_BURST_MAX; i++) { - packet_set_ip_src_addr(&pkt, i); - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); - EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL); // hit evicted session, can't renew session + packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL); // hit evicted session, can't renew session } printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX); @@ -87,11 +72,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX); // evicted session timeout - packet_set_ip_src_addr(&pkt, 0); - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); - EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1 + _cfg.evicted_session_bloom_filter.time_window_ms)); + uint32_t idx = 0; + packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1 + _sess_mgr_cfg.evicted_session_bloom_filter.time_window_ms)); printf("=> Session Manager: after evicted session timeout\n"); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX + 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX); @@ -102,7 +88,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -110,16 +96,16 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS) TEST(UDP_OVERLOAD, EVICT_NEW_SESS) { struct packet pkt; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - struct session_manager_config _cfg; - memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config)); - _cfg.tcp_session_max = RX_BURST_MAX * 2; - _cfg.udp_session_max = RX_BURST_MAX * 2; - _cfg.evict_old_on_udp_table_limit = 0; + struct session_manager_cfg _sess_mgr_cfg; + memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg)); + _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2; + _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2; + _sess_mgr_cfg.evict_old_on_udp_table_limit = 0; - sess_mgr_rt = session_manager_runtime_new(&_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -128,16 +114,16 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS) printf("<= Packet Parse: done\n\n"); // new session - for (uint32_t i = 0; i < _cfg.udp_session_max; i++) + for (uint32_t i = 0; i < _sess_mgr_cfg.udp_session_max; i++) { - packet_set_ip_src_addr(&pkt, i); - EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1)); + packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i); + EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1)); } - printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.udp_session_max); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); - EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max); - EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _sess_mgr_cfg.udp_session_max); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0); @@ -146,20 +132,21 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS) EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0); // evicted session - EXPECT_TRUE(session_manager_runtime_get_evicted_session(sess_mgr_rt) == NULL); + EXPECT_TRUE(session_manager_rte_get_evicted_session(sess_mgr_rte) == NULL); // table full, evict new session for (uint32_t i = 0; i < RX_BURST_MAX; i++) { - packet_set_ip_src_addr(&pkt, _cfg.udp_session_max + i); - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); - EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL); + uint32_t idx = _sess_mgr_cfg.udp_session_max + i; + packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL); } printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX); - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); - EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max); - EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max); + EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max); + EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _sess_mgr_cfg.udp_session_max); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0); @@ -167,7 +154,7 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS) EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == RX_BURST_MAX); EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_sess_mgr_scan.cpp b/infra/session_manager/test/gtest_sess_mgr_scan.cpp index 6b9530b..0369fcc 100644 --- a/infra/session_manager/test/gtest_sess_mgr_scan.cpp +++ b/infra/session_manager/test/gtest_sess_mgr_scan.cpp @@ -1,27 +1,13 @@ -#include +#include "test_utils.h" -#include "session_internal.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "default_config.h" -#include "test_packets.h" - -static inline void packet_overwrite_src_addr(struct packet *pkt, struct in_addr addr) +static inline void mached_session_print(const char *title, struct session_manager_rte *sess_mgr_rte, uint64_t mached_sess_id[], uint64_t mached_sess_num) { - const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4); - struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr; - hdr->ip_src = addr; -} - -static inline void mached_session_print(const char *title, struct session_manager_runtime *sess_mgr_rt, uint64_t mached_sess_ids[], uint64_t mached_sess_num) -{ - struct session *sess = NULL; printf("%-*s mached_sess_num: %lu\n", 40, title, mached_sess_num); for (uint64_t i = 0; i < mached_sess_num; i++) { - sess = session_manager_runtime_lookup_session_by_id(sess_mgr_rt, mached_sess_ids[i]); + struct session *sess = session_manager_rte_lookup_session_by_id(sess_mgr_rte, mached_sess_id[i]); printf("session id: %lu, addr: %s, type: %s, state: %s, start: %lu, last: %lu\n", - mached_sess_ids[i], session_get0_readable_addr(sess), + mached_sess_id[i], session_get0_readable_addr(sess), session_type_to_str(session_get_type(sess)), session_state_to_str(session_get_current_state(sess)), session_get_timestamp(sess, SESSION_TIMESTAMP_START), @@ -34,10 +20,10 @@ TEST(SESS_MGR_SCAN, OPTS) { char buff[1500] = {0}; uint64_t mached_sess_num = 0; - uint64_t mached_sess_ids[1460]; + uint64_t mached_sess_id[1460]; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct in_addr v4_src_addr1 = {}; struct in_addr v4_src_addr2 = {}; @@ -85,91 +71,91 @@ TEST(SESS_MGR_SCAN, OPTS) inet_pton(AF_INET6, "cafe::0000", &v6_dst_subnet_beg); inet_pton(AF_INET6, "cafe::ffff", &v6_dst_subnet_end); - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // new session memset(&pkt, 0, sizeof(pkt)); memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn)); - packet_overwrite_src_addr(&pkt, v4_src_addr1); - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + packet_overwrite_v4_saddr(&pkt, &v4_src_addr1); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // new session memset(&pkt, 0, sizeof(pkt)); memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn)); - packet_overwrite_src_addr(&pkt, v4_src_addr2); - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 2); + packet_overwrite_v4_saddr(&pkt, &v4_src_addr2); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 2); EXPECT_TRUE(sess); // new session memset(&pkt, 0, sizeof(pkt)); memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn)); packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn)); - packet_overwrite_src_addr(&pkt, v4_src_addr3); - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 3); + packet_overwrite_v4_saddr(&pkt, &v4_src_addr3); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 3); EXPECT_TRUE(sess); // new session memset(&pkt, 0, sizeof(pkt)); packet_parse(&pkt, (const char *)ipv6_in_ipv6_udp, sizeof(ipv6_in_ipv6_udp)); - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 4); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 4); EXPECT_TRUE(sess); struct session_scan_opts scan = {}; - // scan.flags = SESSION_SCAN_TYPE | SESSION_SCAN_STATE | SESSION_SCAN_SIP | SESSION_SCAN_DIP | SESSION_SCAN_SPORT | SESSION_SCAN_DPORT | SESSION_SCAN_CREATE_TIME | SESSION_SCAN_LAST_PKT_TIME; + // scan.flags = SESSION_SCAN_TYPE | SESSION_SCAN_STATE | SESSION_SCAN_SIP | SESSION_SCAN_DIP | SESSION_SCAN_SPORT | SESSION_SCAN_DPORT | SESSION_SCAN_CREATE_TIME | SESSION_SCAN_LASPKT_TIME; scan.cursor = 0; scan.count = 1460; - scan.last_pkt_time_ms[0] = 0; - scan.last_pkt_time_ms[1] = UINT64_MAX; + scan.laspkt_time_ms[0] = 0; + scan.laspkt_time_ms[1] = UINT64_MAX; // SESSION_SCAN_TYPE scan.flags = SESSION_SCAN_TYPE; scan.type = SESSION_TYPE_TCP; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.type = SESSION_TYPE_UDP; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rte, mached_sess_id, mached_sess_num); // SESSION_SCAN_STATE scan.flags = SESSION_SCAN_STATE; scan.state = SESSION_STATE_OPENING; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 4); - mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.state = SESSION_STATE_ACTIVE; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.state = SESSION_STATE_CLOSING; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.state = SESSION_STATE_DISCARD; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.state = SESSION_STATE_CLOSED; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rte, mached_sess_id, mached_sess_num); // SESSION_SCAN_SIP scan.flags = SESSION_SCAN_SIP; @@ -177,44 +163,44 @@ TEST(SESS_MGR_SCAN, OPTS) scan.addr_family = AF_INET; scan.src_addr[0].v4 = v4_src_addr1; scan.src_addr[1].v4 = v4_src_addr1; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.addr_family = AF_INET; scan.src_addr[0].v4 = v4_src_subnet_beg; scan.src_addr[1].v4 = v4_src_subnet_end; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.addr_family = AF_INET; scan.src_addr[0].v4 = v4_min_addr; scan.src_addr[1].v4 = v4_max_addr; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.src_addr[0].v6, &v6_src_addr, sizeof(v6_src_addr)); memcpy(&scan.src_addr[1].v6, &v6_src_addr, sizeof(v6_src_addr)); - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.src_addr[0].v6, &v6_src_subnet_beg, sizeof(v6_src_subnet_beg)); memcpy(&scan.src_addr[1].v6, &v6_src_subnet_end, sizeof(v6_src_subnet_end)); - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.src_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr)); memcpy(&scan.src_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr)); - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num); // SESSION_SCAN_DIP scan.flags = SESSION_SCAN_DIP; @@ -222,126 +208,126 @@ TEST(SESS_MGR_SCAN, OPTS) scan.addr_family = AF_INET; scan.dst_addr[0].v4 = v4_dst_addr; scan.dst_addr[1].v4 = v4_dst_addr; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.addr_family = AF_INET; scan.dst_addr[0].v4 = v4_dst_subnet_beg; scan.dst_addr[1].v4 = v4_dst_subnet_end; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.addr_family = AF_INET; scan.dst_addr[0].v4 = v4_min_addr; scan.dst_addr[1].v4 = v4_max_addr; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.dst_addr[0].v6, &v6_dst_addr, sizeof(v6_dst_addr)); memcpy(&scan.dst_addr[1].v6, &v6_dst_addr, sizeof(v6_dst_addr)); - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.dst_addr[0].v6, &v6_dst_subnet_beg, sizeof(v6_dst_subnet_beg)); memcpy(&scan.dst_addr[1].v6, &v6_dst_subnet_end, sizeof(v6_dst_subnet_end)); - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.addr_family = AF_INET6; memcpy(&scan.dst_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr)); memcpy(&scan.dst_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr)); - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 1); - mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num); // SESSION_SCAN_SPORT scan.flags = SESSION_SCAN_SPORT; scan.src_port = htons(60111); - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.src_port = htons(60110); - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num); // SESSION_SCAN_DPORT scan.flags = SESSION_SCAN_DPORT; scan.dst_port = htons(80); - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 3); - mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.dst_port = htons(81); - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num); // SESSION_SCAN_CREATE_TIME scan.flags = SESSION_SCAN_CREATE_TIME; scan.create_time_ms[0] = 0; scan.create_time_ms[1] = UINT64_MAX; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 4); - mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.create_time_ms[0] = 1; scan.create_time_ms[1] = 2; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 2); - mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.create_time_ms[0] = 0; scan.create_time_ms[1] = 0; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num); scan.create_time_ms[0] = UINT64_MAX; scan.create_time_ms[1] = UINT64_MAX; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num); - // SESSION_SCAN_LAST_PKT_TIME - scan.flags = SESSION_SCAN_LAST_PKT_TIME; + // SESSION_SCAN_LASPKT_TIME + scan.flags = SESSION_SCAN_LASPKT_TIME; - scan.last_pkt_time_ms[0] = 0; - scan.last_pkt_time_ms[1] = UINT64_MAX; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + scan.laspkt_time_ms[0] = 0; + scan.laspkt_time_ms[1] = UINT64_MAX; + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 4); - mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_LASPKT_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num); - scan.last_pkt_time_ms[0] = 1; - scan.last_pkt_time_ms[1] = 2; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + scan.laspkt_time_ms[0] = 1; + scan.laspkt_time_ms[1] = 2; + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 2); - mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_LASPKT_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num); - scan.last_pkt_time_ms[0] = 0; - scan.last_pkt_time_ms[1] = 0; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + scan.laspkt_time_ms[0] = 0; + scan.laspkt_time_ms[1] = 0; + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_LASPKT_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num); - scan.last_pkt_time_ms[0] = UINT64_MAX; - scan.last_pkt_time_ms[1] = UINT64_MAX; - mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0])); + scan.laspkt_time_ms[0] = UINT64_MAX; + scan.laspkt_time_ms[1] = UINT64_MAX; + mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0])); EXPECT_TRUE(mached_sess_num == 0); - mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num); + mached_session_print("SESSION_SCAN_LASPKT_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp index 88eb20f..7ee70e4 100644 --- a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp +++ b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp @@ -1,24 +1,4 @@ -#include - -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" - -static void hex_dump(const char *payload, uint32_t len) -{ - printf("Payload Length: %u\n", len); - for (uint32_t i = 0; i < len; i++) - { - if (i > 0 && i % 16 == 0) - { - printf("\n"); - } - printf("%02x ", (uint8_t)payload[i]); - } - printf("\n"); -} +#include "test_utils.h" #if 1 TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) @@ -26,10 +6,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) struct tcp_segment *seg; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -38,9 +18,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); seg = session_get_tcp_segment(sess); @@ -53,10 +34,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -68,10 +50,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -83,10 +66,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -98,10 +82,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 5) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -113,10 +98,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 6) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -128,10 +114,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 7) == 0); /* * 11111111111111111111111111111111111111111111111111111111111111 @@ -166,48 +153,49 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER) EXPECT_TRUE(seg != NULL); EXPECT_TRUE(seg->len == sizeof(payload1)); EXPECT_TRUE(memcmp((void *)seg->data, payload1, sizeof(payload1)) == 0); - hex_dump((const char *)seg->data, seg->len); + hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len); session_free_tcp_segment(sess, seg); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg != NULL); EXPECT_TRUE(seg->len == sizeof(payload2)); EXPECT_TRUE(memcmp((void *)seg->data, payload2, sizeof(payload2)) == 0); - hex_dump((const char *)seg->data, seg->len); + hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len); session_free_tcp_segment(sess, seg); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg != NULL); EXPECT_TRUE(seg->len == sizeof(payload3)); EXPECT_TRUE(memcmp((void *)seg->data, payload3, sizeof(payload3)) == 0); - hex_dump((const char *)seg->data, seg->len); + hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len); session_free_tcp_segment(sess, seg); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg != NULL); EXPECT_TRUE(seg->len == sizeof(payload4)); EXPECT_TRUE(memcmp((void *)seg->data, payload4, sizeof(payload4)) == 0); - hex_dump((const char *)seg->data, seg->len); + hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len); session_free_tcp_segment(sess, seg); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg != NULL); EXPECT_TRUE(seg->len == sizeof(payload5)); EXPECT_TRUE(memcmp((void *)seg->data, payload5, sizeof(payload5)) == 0); - hex_dump((const char *)seg->data, seg->len); + hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len); session_free_tcp_segment(sess, seg); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); // active -> closing - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 7 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 7 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); - // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_runtime_free(sess_mgr_rt); + // free session + session_manager_rte_free_session(sess_mgr_rte, sess); + + session_manager_rte_free(sess_mgr_rte); } #endif @@ -217,10 +205,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND) struct tcp_segment *seg; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -229,9 +217,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); seg = session_get_tcp_segment(sess); @@ -244,10 +233,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg == NULL); @@ -259,16 +249,17 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg != NULL); EXPECT_TRUE(seg->len == sizeof(tcp_seq_wraparound_pkt3_payload)); EXPECT_TRUE(memcmp((void *)seg->data, tcp_seq_wraparound_pkt3_payload, sizeof(tcp_seq_wraparound_pkt3_payload)) == 0); - hex_dump((const char *)seg->data, seg->len); + hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len); session_free_tcp_segment(sess, seg); // C2S Data Packet @@ -278,29 +269,31 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0); seg = session_get_tcp_segment(sess); EXPECT_TRUE(seg != NULL); EXPECT_TRUE(seg->len == sizeof(tcp_seq_wraparound_pkt4_payload)); EXPECT_TRUE(memcmp((void *)seg->data, tcp_seq_wraparound_pkt4_payload, sizeof(tcp_seq_wraparound_pkt4_payload)) == 0); - hex_dump((const char *)seg->data, seg->len); + hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len); session_free_tcp_segment(sess, seg); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); // active -> closing - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 4 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 4 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); - // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_runtime_free(sess_mgr_rt); + // free session + session_manager_rte_free_session(sess_mgr_rte, sess); + + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_session_filter.cpp b/infra/session_manager/test/gtest_session_filter.cpp index c3a0911..c9c6d05 100644 --- a/infra/session_manager/test/gtest_session_filter.cpp +++ b/infra/session_manager/test/gtest_session_filter.cpp @@ -1,7 +1,4 @@ -#include - -#include "tuple.h" -#include "session_filter.h" +#include "test_utils.h" TEST(SESSION_FILTER, TEST) { diff --git a/infra/session_manager/test/gtest_session_pool.cpp b/infra/session_manager/test/gtest_session_pool.cpp index db6df28..8c868ee 100644 --- a/infra/session_manager/test/gtest_session_pool.cpp +++ b/infra/session_manager/test/gtest_session_pool.cpp @@ -1,6 +1,4 @@ -#include - -#include "session_pool.h" +#include "test_utils.h" TEST(SESSION_POOL, POP_PUSH) { diff --git a/infra/session_manager/test/gtest_session_table.cpp b/infra/session_manager/test/gtest_session_table.cpp index 72906eb..4a45f38 100644 --- a/infra/session_manager/test/gtest_session_table.cpp +++ b/infra/session_manager/test/gtest_session_table.cpp @@ -1,9 +1,4 @@ -#include - -#include "tuple.h" -#include "session_internal.h" -#include "session_pool.h" -#include "session_table.h" +#include "test_utils.h" #define TUPLE6_SET_V4_TCP(t6) \ { \ diff --git a/infra/session_manager/test/gtest_session_timer.cpp b/infra/session_manager/test/gtest_session_timer.cpp index ef5a720..a118629 100644 --- a/infra/session_manager/test/gtest_session_timer.cpp +++ b/infra/session_manager/test/gtest_session_timer.cpp @@ -1,7 +1,4 @@ -#include - -#include "session_internal.h" -#include "session_timer.h" +#include "test_utils.h" TEST(SESSION_TIMER, EXPIRE) { diff --git a/infra/session_manager/test/gtest_session_transition.cpp b/infra/session_manager/test/gtest_session_transition.cpp index a41309e..f9c9ed2 100644 --- a/infra/session_manager/test/gtest_session_transition.cpp +++ b/infra/session_manager/test/gtest_session_transition.cpp @@ -1,6 +1,4 @@ -#include - -#include "session_transition.h" +#include "test_utils.h" TEST(SESSION_TRANSITION, RUN) { diff --git a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp index d45eb2b..f84a59f 100644 --- a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp @@ -1,14 +1,7 @@ // TCP state machine test: active -> closing -#include +#include "test_utils.h" -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" - -static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess) +static void build_active_tcp_session(struct session_manager_rte *sess_mgr_rte, struct session *sess) { struct packet pkt; @@ -19,9 +12,10 @@ static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // C2S DATA Packet @@ -31,10 +25,11 @@ static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); } /****************************************************************************** @@ -47,14 +42,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(sess_mgr_rt, sess); + build_active_tcp_session(sess_mgr_rte, sess); // C2S FIN Packet printf("\n=> Packet Parse: TCP C2S FIN packet\n"); @@ -63,10 +58,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); // S2C FIN Packet printf("\n=> Packet Parse: TCP S2C FIN packet\n"); @@ -75,10 +71,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -100,7 +97,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -108,23 +105,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -138,14 +136,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(sess_mgr_rt, sess); + build_active_tcp_session(sess_mgr_rte, sess); // C2S RST Packet printf("\n=> Packet Parse: TCP C2S RST packet\n"); @@ -160,10 +158,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -185,7 +184,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -193,23 +192,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -223,14 +223,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(sess_mgr_rt, sess); + build_active_tcp_session(sess_mgr_rte, sess); // S2C RST Packet printf("\n=> Packet Parse: TCP S2C RST packet\n"); @@ -245,10 +245,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -270,7 +271,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -278,23 +279,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -306,17 +308,17 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST) TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT) { struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(sess_mgr_rt, sess); + build_active_tcp_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -324,24 +326,25 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -355,14 +358,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(sess_mgr_rt, sess); + build_active_tcp_session(sess_mgr_rte, sess); // C2S FIN Packet printf("\n=> Packet Parse: TCP C2S FIN packet\n"); @@ -371,10 +374,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -396,7 +400,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -404,23 +408,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -434,14 +439,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet & C2S DATA Packet - build_active_tcp_session(sess_mgr_rt, sess); + build_active_tcp_session(sess_mgr_rte, sess); // S2C FIN Packet printf("\n=> Packet Parse: TCP S2C FIN packet\n"); @@ -450,10 +455,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -475,7 +481,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -483,23 +489,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp index 92002b5..3ae89ff 100644 --- a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp +++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp @@ -1,12 +1,5 @@ // TCP state machine test: init -> opening -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" +#include "test_utils.h" /****************************************************************************** * case: TCP init -> opening (by SYN) @@ -18,11 +11,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -31,9 +24,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -56,7 +50,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -64,24 +58,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -95,11 +90,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -108,9 +103,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -133,7 +129,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -141,24 +137,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -172,11 +169,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -185,9 +182,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // S2C SYNACK Packet @@ -197,10 +195,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -222,7 +221,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -230,24 +229,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -261,11 +261,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -274,9 +274,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // S2C SYNACK Packet @@ -286,10 +287,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); // C2S ACK Packet printf("\n=> Packet Parse: TCP C2S ACK packet\n"); @@ -298,10 +300,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -323,7 +326,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -331,24 +334,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -364,11 +368,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -377,9 +381,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // C2S SYN Packet retransmission @@ -394,10 +399,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -419,7 +425,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -427,24 +433,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -460,11 +467,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -473,9 +480,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // SYNACK Packet retransmission @@ -491,10 +499,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -516,7 +525,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -524,24 +533,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -555,11 +565,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -568,9 +578,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // C2S ACK Packet @@ -580,10 +591,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -605,7 +617,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -613,24 +625,25 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -644,11 +657,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -657,9 +670,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // S2C ACK Packet @@ -669,10 +683,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -694,7 +709,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -702,24 +717,25 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp index 4678fd8..508ebd9 100644 --- a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp +++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp @@ -1,12 +1,5 @@ // TCP state machine test: init -> opening -> active -> closing -> closed -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" +#include "test_utils.h" #if 1 TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) @@ -14,11 +7,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) char buffer[1024]; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -27,9 +20,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -58,10 +52,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -89,10 +84,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -120,10 +116,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -151,10 +148,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 5) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -182,10 +180,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 6) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -213,10 +212,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 7) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -244,10 +244,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 8) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 8) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -275,10 +276,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 9) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 9) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -306,10 +308,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 10) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 10) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -337,10 +340,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 11) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 11) == 0); EXPECT_TRUE(session_get_id(sess) != 0); memset(buffer, 0, sizeof(buffer)); @@ -362,7 +366,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -370,23 +374,24 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 11 + sess_mgr_cfg.tcp_timeout_ms.time_wait); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 11 + sess_mgr_cfg.tcp_timeout_ms.time_wait); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp index a1e5fba..5ecded6 100644 --- a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp +++ b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp @@ -1,12 +1,5 @@ // TCP state machine test: opening -> active -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" +#include "test_utils.h" /****************************************************************************** * case: TCP opening -> active (by C2S DATA) @@ -18,11 +11,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -31,9 +24,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // C2S DATA Packet @@ -43,10 +37,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -68,7 +63,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -76,24 +71,25 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -107,11 +103,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -120,9 +116,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // S2C DATA Packet @@ -132,10 +129,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -157,7 +155,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -165,24 +163,25 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp index 06f4f16..7a28bfd 100644 --- a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp @@ -1,12 +1,5 @@ // TCP state machine test: opening -> closing -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" +#include "test_utils.h" /****************************************************************************** * case: TCP opening -> closing (by FIN-FIN) @@ -18,11 +11,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -31,9 +24,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // C2S FIN Packet @@ -43,10 +37,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); // S2C FIN Packet printf("\n=> Packet Parse: TCP S2C FIN packet\n"); @@ -55,10 +50,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -80,7 +76,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -88,23 +84,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -118,11 +115,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -131,9 +128,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // C2S RST Packet @@ -149,10 +147,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -174,7 +173,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -182,23 +181,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -212,11 +212,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -225,9 +225,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // S2C RST Packet @@ -243,10 +244,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -268,7 +270,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -276,23 +278,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -305,11 +308,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -318,13 +321,14 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -332,24 +336,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -363,11 +368,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -376,9 +381,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // S2C SYNACK Packet @@ -388,10 +394,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -413,7 +420,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -421,24 +428,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -452,11 +460,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -465,9 +473,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // S2C SYNACK Packet @@ -477,10 +486,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); // C2S ACK Packet printf("\n=> Packet Parse: TCP C2S ACK packet\n"); @@ -489,10 +499,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -514,7 +525,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1); @@ -522,24 +533,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -553,11 +565,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -566,9 +578,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // C2S FIN Packet @@ -578,10 +591,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -603,7 +617,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -611,23 +625,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -641,11 +656,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -654,9 +669,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // S2C FIN Packet @@ -666,10 +682,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -691,7 +708,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); @@ -699,23 +716,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN) EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1); // expire session - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp index 739f04d..c66708c 100644 --- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp @@ -1,24 +1,16 @@ // UDP state machine test: init -> opening -> active -> closing -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" - +#include "test_utils.h" #if 1 TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST) { char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -27,9 +19,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -57,10 +50,11 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); EXPECT_TRUE(session_get_id(sess) != 0); tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer)); @@ -82,7 +76,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0); @@ -90,24 +84,25 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST) EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // active -> closing - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp index 48f6f6a..3c66a18 100644 --- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp +++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp @@ -1,12 +1,5 @@ // UDP state machine test: init -> opening -> closing -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" +#include "test_utils.h" /****************************************************************************** * case: UDP init -> opening (by C2S Packet) @@ -19,11 +12,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -32,9 +25,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -57,7 +51,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1); @@ -65,24 +59,25 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S) EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); + // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif @@ -97,11 +92,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C) char buffer[1024] = {0}; struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; struct session_manager_stat *sess_mgr_stat = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // S2C RESP Packet printf("\n=> Packet Parse: UDP S2C RESP packet\n"); @@ -110,9 +105,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_id(sess) != 0); @@ -135,7 +131,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C) session_print(sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1); @@ -143,8 +139,8 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C) EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); @@ -152,17 +148,17 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C) session_print(sess); // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); + session_manager_rte_free_session(sess_mgr_rte, sess); // check stat - sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt); + sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte); EXPECT_TRUE(sess_mgr_stat); EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0); EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0); - session_manager_runtime_free(sess_mgr_rt); + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_timeout_tcp_data.cpp b/infra/session_manager/test/gtest_timeout_tcp_data.cpp index 0cfcc57..768494e 100644 --- a/infra/session_manager/test/gtest_timeout_tcp_data.cpp +++ b/infra/session_manager/test/gtest_timeout_tcp_data.cpp @@ -1,21 +1,14 @@ -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" +#include "test_utils.h" #if 1 TEST(TIMEOUT, TCP_TIMEOUT_DATA) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -24,9 +17,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // C2S DATA Packet @@ -36,22 +30,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); - // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_runtime_free(sess_mgr_rt); + // free session + session_manager_rte_free_session(sess_mgr_rte, sess); + + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp index d837a8a..0cb79f6 100644 --- a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp +++ b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp @@ -1,21 +1,14 @@ -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" +#include "test_utils.h" #if 1 TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // S2C SYNACK Packet printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); @@ -24,22 +17,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data); + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL); + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data); EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); - // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_runtime_free(sess_mgr_rt); + // free session + session_manager_rte_free_session(sess_mgr_rte, sess); + + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_timeout_tcp_init.cpp b/infra/session_manager/test/gtest_timeout_tcp_init.cpp index b3ca04a..cfc6292 100644 --- a/infra/session_manager/test/gtest_timeout_tcp_init.cpp +++ b/infra/session_manager/test/gtest_timeout_tcp_init.cpp @@ -1,21 +1,14 @@ -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" +#include "test_utils.h" #if 1 TEST(TIMEOUT, TCP_TIMEOUT_INIT) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S SYN Packet printf("\n=> Packet Parse: TCP C2S SYN packet\n"); @@ -24,22 +17,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL); // opening -> closing + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); - // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_runtime_free(sess_mgr_rt); + // free session + session_manager_rte_free_session(sess_mgr_rte, sess); + + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/gtest_timeout_udp_data.cpp b/infra/session_manager/test/gtest_timeout_udp_data.cpp index d5663fe..9da1f15 100644 --- a/infra/session_manager/test/gtest_timeout_udp_data.cpp +++ b/infra/session_manager/test/gtest_timeout_udp_data.cpp @@ -1,21 +1,14 @@ -#include - -#include "tuple.h" -#include "packet_internal.h" -#include "packet_parser.h" -#include "session_internal.h" -#include "default_config.h" -#include "test_packets.h" +#include "test_utils.h" #if 1 TEST(TIMEOUT, UDP_TIMEOUT_DATA1) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -24,22 +17,24 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // opening -> closing + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); - // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_runtime_free(sess_mgr_rt); + // free session + session_manager_rte_free_session(sess_mgr_rte, sess); + + session_manager_rte_free(sess_mgr_rte); } #endif @@ -48,10 +43,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2) { struct packet pkt; struct session *sess = NULL; - struct session_manager_runtime *sess_mgr_rt = NULL; + struct session_manager_rte *sess_mgr_rte = NULL; - sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1); - EXPECT_TRUE(sess_mgr_rt != NULL); + sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1); + EXPECT_TRUE(sess_mgr_rte != NULL); // C2S REQ Packet printf("\n=> Packet Parse: UDP C2S REQ packet\n"); @@ -60,9 +55,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2) printf("<= Packet Parse: done\n\n"); // lookup session - EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL); + EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL); + // new session - sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1); + sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1); EXPECT_TRUE(sess); // S2C RESP Packet @@ -72,22 +68,24 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2) printf("<= Packet Parse: done\n\n"); // lookup session - sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt); + sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt); EXPECT_TRUE(sess); + // update session - EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0); + EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0); // expire session - EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // active -> closing - sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed + EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL); // active -> closing + sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed EXPECT_TRUE(sess); EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED); EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT); session_print(sess); - // free session - session_manager_runtime_free_session(sess_mgr_rt, sess); - session_manager_runtime_free(sess_mgr_rt); + // free session + session_manager_rte_free_session(sess_mgr_rte, sess); + + session_manager_rte_free(sess_mgr_rte); } #endif diff --git a/infra/session_manager/test/test_packets.h b/infra/session_manager/test/test_utils.h similarity index 98% rename from infra/session_manager/test/test_packets.h rename to infra/session_manager/test/test_utils.h index 231ef88..64df5dd 100644 --- a/infra/session_manager/test/test_packets.h +++ b/infra/session_manager/test/test_utils.h @@ -1,10 +1,97 @@ #pragma once +#include + #ifdef __cplusplus extern "C" { #endif +#include "tuple.h" +#include "packet_parser.h" +#include "packet_internal.h" +#include "utils_internal.h" + +#include "session_pool.h" +#include "session_timer.h" +#include "session_table.h" +#include "session_filter.h" +#include "session_internal.h" +#include "session_transition.h" +#include "session_manager_cfg.h" +#include "session_manager_rte.h" + +__attribute__((unused)) static struct session_manager_cfg sess_mgr_cfg = { + .instance_id = 1, + .thread_num = 1, + .session_id_seed = 0xFFFFF, + + .tcp_session_max = 256, + .udp_session_max = 256, + + .evict_old_on_tcp_table_limit = 1, + .evict_old_on_udp_table_limit = 1, + + .expire_period_ms = 0, + .expire_batch_max = 1024, + + .tcp_timeout_ms = + { + .init = 1, + .handshake = 2, + .data = 3, + .half_closed = 4, + .time_wait = 5, + .discard_default = 6, + .unverified_rst = 7, + }, + + .udp_timeout_ms = + { + .data = 8, + .discard_default = 0, + }, + + .duplicated_packet_bloom_filter = + { + .enable = 1, + .capacity = 1000, + .time_window_ms = 10, + .error_rate = 0.0001, + }, + + .evicted_session_bloom_filter = + { + .enable = 1, + .capacity = 1000, + .time_window_ms = 10, + .error_rate = 0.0001, + }, + + .tcp_reassembly = + { + .enable = 1, + .timeout_ms = 1000, + .buffered_segments_max = 16, + }, +}; + +static inline void packet_overwrite_ipid(struct packet *pkt, uint16_t ip_id) +{ + const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4); + EXPECT_TRUE(ipv4_layer); + struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr; + hdr->ip_id = htons(ip_id); +} + +static inline void packet_overwrite_v4_saddr(struct packet *pkt, struct in_addr *addr) +{ + const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4); + EXPECT_TRUE(ipv4_layer); + struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr; + hdr->ip_src = *addr; +} + /****************************************************************************** * test packet: HTTP www.example.com ******************************************************************************/ diff --git a/scripts/CMakeLists.txt b/scripts/CMakeLists.txt index 7243c1d..af17de6 100644 --- a/scripts/CMakeLists.txt +++ b/scripts/CMakeLists.txt @@ -1,2 +1 @@ -install(FILES python_stat.sh DESTINATION ./ COMPONENT PROGRAM) -install(FILES shell_stat.sh DESTINATION ./ COMPONENT PROGRAM) \ No newline at end of file +install(FILES stat_format.sh DESTINATION ./ COMPONENT PROGRAM) \ No newline at end of file diff --git a/scripts/python_stat.sh b/scripts/python_stat.sh deleted file mode 100644 index 2cfb69b..0000000 --- a/scripts/python_stat.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/bash - -/opt/MESA/bin/fieldstat_exporter.py local -j /opt/tsg/stellar/log/stellar_fs4.json -l --clear-screen -e diff --git a/scripts/shell_stat.sh b/scripts/shell_stat.sh deleted file mode 100644 index 056f882..0000000 --- a/scripts/shell_stat.sh +++ /dev/null @@ -1,59 +0,0 @@ -#!/bin/bash +x - -#cat stellar_fs4.json |jq -#[ -# { -# "name": "stellar", -# "tags": {}, -# "fields": { -# "aaaa": 1111111, -# "bbbb": 2222222, -# }, -# "timestamp_ms": 1713053113549 -# } -#] - -calculate() { - local curr_data=$1 - local prev_data=$2 - - local fields=($(echo "$curr_data" | jq -r '.[].fields | to_entries | .[] | .key' | grep -v timestamp_ms)) - local curr_ts=$(echo "$curr_data" | jq -r '.[].timestamp_ms') - local prev_ts=$(echo "$prev_data" | jq -r '.[].timestamp_ms') - local diff_ts=$(($curr_ts - $prev_ts)) - local seconds=$((curr_ts / 1000)) - local buffer=() - - local curr_fileds=$(echo "$curr_data" | jq -r '.[].fields' | grep -v timestamp_ms) - local prev_fileds=$(echo "$prev_data" | jq -r '.[].fields' | grep -v timestamp_ms) - - buffer+=("====================================$(date -d "@$seconds" +"%Y-%m-%d %H:%M:%S")====================================\n") - buffer+=("$(printf "%-30s" Field)$(printf "%-20s" Sum)$(printf "%-20s" Speed)\n") - local result=() - for field in "${fields[@]}"; do - local curr_val=$(echo "$curr_fileds" | grep $field | awk '{print $2}' | sed 's/,//g') - local prev_val=$(echo "$prev_fileds" | grep $field | awk '{print $2}' | sed 's/,//g') - local diff_val=$((curr_val - prev_val)) - local speed=0 - if [ $diff_ts -eq 0 ]; then - speed=0 - else - speed=$((diff_val * 1000 / diff_ts)) - fi - buffer+=("$(printf "%-30s" $field)$(printf "%-20s" $curr_val)$(printf "%-20s" $speed)\n") - done - buffer+=("===========================================================================================\n") - clear - echo -e "${buffer[@]}" -} - -prev_data="" - -while true; do - curr_data=$(cat /opt/tsg/stellar/log/stellar_fs4.json) - if [ ! -z "$prev_data" ]; then - calculate "$curr_data" "$prev_data" - fi - prev_data="$curr_data" - sleep 1 -done diff --git a/scripts/stat_format.sh b/scripts/stat_format.sh new file mode 100644 index 0000000..999e839 --- /dev/null +++ b/scripts/stat_format.sh @@ -0,0 +1,9 @@ +#!/bin/bash + +if [ $# -ne 1 ]; then + echo "Usage: $0 " + exit 1 +fi + +f4_json_file=$1 +/opt/MESA/bin/fieldstat_exporter.py local -j $f4_json_file -l --clear-screen