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

rename session_direction to flow_direction

Browse Source
This commit is contained in:
luwenpeng
2024-05-09 14:57:12 +08:00
parent 37d12ebcfc
commit cc380d9271
21 changed files with 610 additions and 556 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
src/session/session_manager.cpp
View File

@@ -227,15 +227,15 @@ static int check_options(const struct session_manager_options *opts)
static void tcp_clean(struct session_manager *mgr, struct session *sess)
{
struct tcp_reassembly *c2s_ssembler = sess->tcp_halfs[SESSION_DIRECTION_C2S].assembler;
struct tcp_reassembly *s2c_ssembler = sess->tcp_halfs[SESSION_DIRECTION_S2C].assembler;
struct tcp_reassembly *c2s_ssembler = sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler;
struct tcp_reassembly *s2c_ssembler = sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler;
struct tcp_segment *seg;
if (c2s_ssembler)
{
while ((seg = tcp_reassembly_expire(c2s_ssembler, UINT64_MAX)))
{
session_inc_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_RELEASED, 1);
session_inc_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_RELEASED, seg->len);
session_inc_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGS_RELEASED, 1);
session_inc_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PLDS_RELEASED, seg->len);
mgr->stat.nr_tcp_seg_released++;
tcp_segment_free(seg);
}
@@ -245,8 +245,8 @@ static void tcp_clean(struct session_manager *mgr, struct session *sess)
{
while ((seg = tcp_reassembly_expire(s2c_ssembler, UINT64_MAX)))
{
session_inc_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_RELEASED, 1);
session_inc_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_RELEASED, seg->len);
session_inc_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGS_RELEASED, 1);
session_inc_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PLDS_RELEASED, seg->len);
mgr->stat.nr_tcp_seg_released++;
tcp_segment_free(seg);
}
@@ -261,9 +261,9 @@ static int tcp_init(struct session_manager *mgr, struct session *sess)
return 0;
}
sess->tcp_halfs[SESSION_DIRECTION_C2S].assembler = tcp_reassembly_new(mgr->opts.tcp_reassembly_max_timeout, mgr->opts.tcp_reassembly_max_segments);
sess->tcp_halfs[SESSION_DIRECTION_S2C].assembler = tcp_reassembly_new(mgr->opts.tcp_reassembly_max_timeout, mgr->opts.tcp_reassembly_max_segments);
if (sess->tcp_halfs[SESSION_DIRECTION_C2S].assembler == NULL || sess->tcp_halfs[SESSION_DIRECTION_S2C].assembler == NULL)
sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler = tcp_reassembly_new(mgr->opts.tcp_reassembly_max_timeout, mgr->opts.tcp_reassembly_max_segments);
sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler = tcp_reassembly_new(mgr->opts.tcp_reassembly_max_timeout, mgr->opts.tcp_reassembly_max_segments);
if (sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler == NULL || sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler == NULL)
{
tcp_clean(mgr, sess);
return -1;
@@ -271,13 +271,13 @@ static int tcp_init(struct session_manager *mgr, struct session *sess)
SESSION_LOG_DEBUG("session %lu %s new c2s tcp assembler %p, s2c tcp assembler %p",
session_get_id(sess), session_get_tuple_str(sess),
sess->tcp_halfs[SESSION_DIRECTION_C2S].assembler,
sess->tcp_halfs[SESSION_DIRECTION_S2C].assembler);
sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler,
sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler);
return 0;
}
static void tcp_update(struct session_manager *mgr, struct session *sess, enum session_direction dir, const struct packet_layer *tcp_layer, uint64_t now)
static void tcp_update(struct session_manager *mgr, struct session *sess, enum flow_direction dir, const struct packet_layer *tcp_layer, uint64_t now)
{
struct tcp_segment *seg;
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
@@ -400,25 +400,25 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum s
* Session Direction
******************************************************************************/
static enum session_direction identify_direction_by_port(uint16_t src_port, uint16_t dst_port)
static enum flow_direction identify_direction_by_port(uint16_t src_port, uint16_t dst_port)
{
// big port is client
if (src_port > dst_port)
{
return SESSION_DIRECTION_C2S;
return FLOW_DIRECTION_C2S;
}
else if (src_port < dst_port)
{
return SESSION_DIRECTION_S2C;
return FLOW_DIRECTION_S2C;
}
else
{
// if port is equal, first packet is C2S
return SESSION_DIRECTION_C2S;
return FLOW_DIRECTION_C2S;
}
}
static enum session_direction identify_direction_by_history(const struct session *sess, const struct tuple6 *key)
static enum flow_direction identify_direction_by_history(const struct session *sess, const struct tuple6 *key)
{
if (tuple6_cmp(session_get_tuple(sess), key) == 0)
{
@@ -426,7 +426,7 @@ static enum session_direction identify_direction_by_history(const struct session
}
else
{
return (session_get_tuple_direction(sess) == SESSION_DIRECTION_C2S ? SESSION_DIRECTION_S2C : SESSION_DIRECTION_C2S);
return (session_get_tuple_direction(sess) == FLOW_DIRECTION_C2S ? FLOW_DIRECTION_S2C : FLOW_DIRECTION_C2S);
}
}
@@ -471,7 +471,7 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
return 0;
}
enum session_direction dir = identify_direction_by_history(sess, key);
enum flow_direction dir = identify_direction_by_history(sess, key);
if (session_get_stat(sess, dir, STAT_RAW_PKTS_RX) < 3 || session_has_dup_traffic(sess))
{
if (duplicated_packet_filter_lookup(mgr->dup_pkt_filter, pkt, now))
@@ -507,7 +507,7 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
* Session Manager
******************************************************************************/
static void session_update(struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum session_direction dir)
static void session_update(struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_direction dir)
{
struct timespec real;
clock_gettime(CLOCK_REALTIME, &real); // must be realtime
@@ -517,6 +517,32 @@ static void session_update(struct session *sess, enum session_state next_state,
session_set_id(sess, id_generator_alloc());
session_set_tuple(sess, key);
session_set_tuple_direction(sess, dir);
enum packet_direction pkt_dir = packet_get_direction(pkt);
if (dir == FLOW_DIRECTION_C2S)
{
if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External
{
session_set_direction(sess, SESSION_DIRECTION_OUTBOUND);
}
else
{
session_set_direction(sess, SESSION_DIRECTION_INBOUND);
}
}
else
{
if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External
{
session_set_direction(sess, SESSION_DIRECTION_INBOUND);
}
else
{
session_set_direction(sess, SESSION_DIRECTION_OUTBOUND);
}
}
tuple6_to_str(key, sess->tuple_str, sizeof(sess->tuple_str));
session_set_timestamp(sess, SESSION_TIMESTAMP_START, real.tv_sec);
switch (key->ip_proto)
@@ -536,20 +562,20 @@ static void session_update(struct session *sess, enum session_state next_state,
session_inc_stat(sess, dir, STAT_RAW_PKTS_RX, 1);
session_inc_stat(sess, dir, STAT_RAW_BYTES_RX, packet_get_len(pkt));
if (!session_get_1st_packet(sess, dir))
if (!session_get_first_packet(sess, dir))
{
struct route_ctx ctx = {0};
struct sid_list list = {0};
packet_get_route_ctx(pkt, &ctx);
packet_get_sid_list(pkt, &list);
session_set_1st_packet(sess, dir, pkt);
session_set_first_packet(sess, dir, pkt);
session_set_route_ctx(sess, dir, &ctx);
session_set_sid_list(sess, dir, &list);
}
session_set_current_packet(sess, pkt);
session_set_current_direction(sess, dir);
session_set_flow_direction(sess, dir);
session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, real.tv_sec);
session_set_state(sess, next_state);
}
@@ -615,7 +641,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
session_manager_evicte_session(mgr, evic_sess, now);
}
enum session_direction dir = (flags & TH_ACK) ? SESSION_DIRECTION_S2C : SESSION_DIRECTION_C2S;
enum flow_direction dir = (flags & TH_ACK) ? FLOW_DIRECTION_S2C : FLOW_DIRECTION_C2S;
struct session *sess = session_pool_pop(mgr->sess_pool);
if (sess == NULL)
{
@@ -671,7 +697,7 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
session_init(sess);
sess->mgr_stat = &mgr->stat;
enum session_direction dir = identify_direction_by_port(ntohs(key->src_port), ntohs(key->dst_port));
enum flow_direction dir = identify_direction_by_port(ntohs(key->src_port), ntohs(key->dst_port));
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA);
session_update(sess, next_state, pkt, key, dir);
session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA);
@@ -690,7 +716,7 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
{
const struct packet_layer *tcp_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_TCP);
const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
enum session_direction dir = identify_direction_by_history(sess, key);
enum flow_direction dir = identify_direction_by_history(sess, key);
uint8_t flags = tcp_hdr_get_flags(hdr);
int inputs = 0;
inputs |= (flags & TH_SYN) ? TCP_SYN : NONE;
@@ -714,17 +740,17 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
{
if (flags & TH_FIN)
{
session_set_closing_reason(sess, (dir == SESSION_DIRECTION_C2S ? CLOSING_BY_CLIENT_FIN : CLOSING_BY_SERVER_FIN));
session_set_closing_reason(sess, (dir == FLOW_DIRECTION_C2S ? CLOSING_BY_CLIENT_FIN : CLOSING_BY_SERVER_FIN));
}
if (flags & TH_RST)
{
session_set_closing_reason(sess, (dir == SESSION_DIRECTION_C2S ? CLOSING_BY_CLIENT_RST : CLOSING_BY_SERVER_RST));
session_set_closing_reason(sess, (dir == FLOW_DIRECTION_C2S ? CLOSING_BY_CLIENT_RST : CLOSING_BY_SERVER_RST));
}
}
// update timeout
struct tcp_half *curr = &sess->tcp_halfs[dir];
struct tcp_half *peer = &sess->tcp_halfs[(dir == SESSION_DIRECTION_C2S ? SESSION_DIRECTION_S2C : SESSION_DIRECTION_C2S)];
struct tcp_half *peer = &sess->tcp_halfs[(dir == FLOW_DIRECTION_C2S ? FLOW_DIRECTION_S2C : FLOW_DIRECTION_C2S)];
uint64_t timeout = 0;
switch (next_state)
{
@@ -773,7 +799,7 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
static int session_manager_update_udp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key, uint64_t now)
{
enum session_direction dir = identify_direction_by_history(sess, key);
enum flow_direction dir = identify_direction_by_history(sess, key);
enum session_state curr_state = session_get_state(sess);
enum session_state next_state = session_transition_run(curr_state, UDP_DATA);
session_update(sess, next_state, pkt, key, dir);
@@ -951,16 +977,16 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
}
session_free_all_ex_data(sess);
packet_free((struct packet *)session_get_1st_packet(sess, SESSION_DIRECTION_C2S));
packet_free((struct packet *)session_get_1st_packet(sess, SESSION_DIRECTION_S2C));
session_set_1st_packet(sess, SESSION_DIRECTION_C2S, NULL);
session_set_1st_packet(sess, SESSION_DIRECTION_S2C, NULL);
session_clear_route_ctx(sess, SESSION_DIRECTION_C2S);
session_clear_route_ctx(sess, SESSION_DIRECTION_S2C);
session_clear_sid_list(sess, SESSION_DIRECTION_C2S);
session_clear_sid_list(sess, SESSION_DIRECTION_S2C);
packet_free((struct packet *)session_get_first_packet(sess, FLOW_DIRECTION_C2S));
packet_free((struct packet *)session_get_first_packet(sess, FLOW_DIRECTION_S2C));
session_set_first_packet(sess, FLOW_DIRECTION_C2S, NULL);
session_set_first_packet(sess, FLOW_DIRECTION_S2C, NULL);
session_clear_route_ctx(sess, FLOW_DIRECTION_C2S);
session_clear_route_ctx(sess, FLOW_DIRECTION_S2C);
session_clear_sid_list(sess, FLOW_DIRECTION_C2S);
session_clear_sid_list(sess, FLOW_DIRECTION_S2C);
session_set_current_packet(sess, NULL);
session_set_current_direction(sess, SESSION_DIRECTION_NONE);
session_set_flow_direction(sess, FLOW_DIRECTION_NONE);
session_pool_push(mgr->sess_pool, sess);
sess = NULL;
}