gfwleak/stellar-stellar
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

session manager support output fieldstat

Browse Source
This commit is contained in:
luwenpeng
2024-10-30 17:00:20 +08:00
parent 03864c9731
commit d56cda3d9a
46 changed files with 3208 additions and 3141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
infra/packet_io/pcap_io.c
View File

@@ -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;

4
infra/packet_manager/packet_manager.c
View File

@@ -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)

6
infra/session_manager/CMakeLists.txt
View File

@@ -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)

1
infra/session_manager/session_filter.c
View File

@@ -1,4 +1,3 @@
#include "tuple.h"
#include "dablooms.h"
#include "session_filter.h"

5
infra/session_manager/session_filter.h
View File

@@ -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);

7
infra/session_manager/session_internal.h
View File

@@ -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;
};

879
infra/session_manager/session_manager.c
View File

File diff suppressed because it is too large Load Diff

128
infra/session_manager/session_manager_cfg.c Normal file
View File

@@ -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);
}
}

72
infra/session_manager/session_manager_cfg.h Normal file
View File

@@ -0,0 +1,72 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdint.h>
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

17
infra/session_manager/session_manager_log.h Normal file
View File

@@ -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

1244
infra/session_manager/session_manager_rte.c Normal file
View File

File diff suppressed because it is too large Load Diff

67
infra/session_manager/session_manager_rte.h Normal file
View File

@@ -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

1464
infra/session_manager/session_manager_runtime.c
View File

File diff suppressed because it is too large Load Diff

184
infra/session_manager/session_manager_runtime.h
View File

@@ -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

39
infra/session_manager/session_manager_stat.c Normal file
View File

@@ -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);
}

166
infra/session_manager/session_manager_stat.h Normal file
View File

@@ -0,0 +1,166 @@
#pragma once
#ifdef __cplusplus
extern "C"
{
#endif
#include <stdint.h>
#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

2
infra/session_manager/session_table.h
View File

@@ -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);

2
infra/session_manager/session_utils.c
View File

@@ -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)
{

68
infra/session_manager/test/default_config.h
View File

@@ -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

32
infra/session_manager/test/gtest_case_tcp_fast_open.cpp
View File

@@ -1,10 +1,4 @@
#include <gtest/gtest.h>
#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

202
infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
View File

@@ -1,29 +1,15 @@
#include <gtest/gtest.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_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

90
infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
View File

@@ -1,33 +1,18 @@
#include <gtest/gtest.h>
#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

113
infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
View File

@@ -1,34 +1,19 @@
#include <gtest/gtest.h>
#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

204
infra/session_manager/test/gtest_sess_mgr_scan.cpp
View File

@@ -1,27 +1,13 @@
#include <gtest/gtest.h>
#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

125
infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
View File

@@ -1,24 +1,4 @@
#include <gtest/gtest.h>
#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

5
infra/session_manager/test/gtest_session_filter.cpp
View File

@@ -1,7 +1,4 @@
#include <gtest/gtest.h>
#include "tuple.h"
#include "session_filter.h"
#include "test_utils.h"
TEST(SESSION_FILTER, TEST)
{

4
infra/session_manager/test/gtest_session_pool.cpp
View File

@@ -1,6 +1,4 @@
#include <gtest/gtest.h>
#include "session_pool.h"
#include "test_utils.h"
TEST(SESSION_POOL, POP_PUSH)
{

7
infra/session_manager/test/gtest_session_table.cpp
View File

@@ -1,9 +1,4 @@
#include <gtest/gtest.h>
#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) \
{ \

5
infra/session_manager/test/gtest_session_timer.cpp
View File

@@ -1,7 +1,4 @@
#include <gtest/gtest.h>
#include "session_internal.h"
#include "session_timer.h"
#include "test_utils.h"
TEST(SESSION_TIMER, EXPIRE)
{

4
infra/session_manager/test/gtest_session_transition.cpp
View File

@@ -1,6 +1,4 @@
#include <gtest/gtest.h>
#include "session_transition.h"
#include "test_utils.h"
TEST(SESSION_TRANSITION, RUN)
{

167
infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
View File

@@ -1,14 +1,7 @@
// TCP state machine test: active -> closing
#include <gtest/gtest.h>
#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

236
infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
View File

@@ -1,12 +1,5 @@
// TCP state machine test: init -> opening
#include <gtest/gtest.h>
#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

81
infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
View File

@@ -1,12 +1,5 @@
// TCP state machine test: init -> opening -> active -> closing -> closed
#include <gtest/gtest.h>
#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

67
infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
View File

@@ -1,12 +1,5 @@
// TCP state machine test: opening -> active
#include <gtest/gtest.h>
#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

236
infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
View File

@@ -1,12 +1,5 @@
// TCP state machine test: opening -> closing
#include <gtest/gtest.h>
#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

39
infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
View File

@@ -1,24 +1,16 @@
// UDP state machine test: init -> opening -> active -> closing
#include <gtest/gtest.h>
#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

56
infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
View File

@@ -1,12 +1,5 @@
// UDP state machine test: init -> opening -> closing
#include <gtest/gtest.h>
#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

36
infra/session_manager/test/gtest_timeout_tcp_data.cpp
View File

@@ -1,21 +1,14 @@
#include <gtest/gtest.h>
#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

31
infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
View File

@@ -1,21 +1,14 @@
#include <gtest/gtest.h>
#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

31
infra/session_manager/test/gtest_timeout_tcp_init.cpp
View File

@@ -1,21 +1,14 @@
#include <gtest/gtest.h>
#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

58
infra/session_manager/test/gtest_timeout_udp_data.cpp
View File

@@ -1,21 +1,14 @@
#include <gtest/gtest.h>
#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

87
infra/session_manager/test/test_packets.h → infra/session_manager/test/test_utils.h
View File

@@ -1,10 +1,97 @@
#pragma once
#include <gtest/gtest.h>
#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
******************************************************************************/

3
scripts/CMakeLists.txt
View File

@@ -1,2 +1 @@
install(FILES python_stat.sh DESTINATION ./ COMPONENT PROGRAM)
install(FILES shell_stat.sh DESTINATION ./ COMPONENT PROGRAM)
install(FILES stat_format.sh DESTINATION ./ COMPONENT PROGRAM)

3
scripts/python_stat.sh
View File

@@ -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

59
scripts/shell_stat.sh
View File

@@ -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

9
scripts/stat_format.sh Normal file
View File

@@ -0,0 +1,9 @@
#!/bin/bash
if [ $# -ne 1 ]; then
echo "Usage: $0 <f4_json_file>"
exit 1
fi
f4_json_file=$1
/opt/MESA/bin/fieldstat_exporter.py local -j $f4_json_file -l --clear-screen