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

TSG-14654: 控制报文格式调整, 增加将cmsg字段发送给TFE, 控制报文采用mpack封装格式

Browse Source
This commit is contained in:
刘学利
2023-05-06 02:23:12 +00:00
parent 5bc9831e03
commit 224f503289
28 changed files with 17186 additions and 396 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
test/src/CMakeLists.txt
View File

@@ -37,13 +37,19 @@ set(TSG_MASTER_SRC ${PROJECT_SOURCE_DIR}/src/tsg_entry.cpp
${PROJECT_SOURCE_DIR}/src/tsg_sync_state.cpp
${PROJECT_SOURCE_DIR}/src/tsg_variable.cpp
${PROJECT_SOURCE_DIR}/src/tsg_protocol.cpp
${PROJECT_SOURCE_DIR}/src/tsg_proxy.cpp
)
add_executable(gtest_master ${TSG_MASTER_SRC} gtest_kafka.cpp gtest_common.cpp gtest_master.cpp)
add_executable(gtest_master ${TSG_MASTER_SRC} ${PROJECT_SOURCE_DIR}/src/mpack.c gtest_kafka.cpp gtest_common.cpp gtest_master.cpp)
target_link_libraries(gtest_master gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger MESA_jump_layer MESA_field_stat2 maat4 MESA_htable fieldstat3)
add_executable(gtest_sync_session_state ${PROJECT_SOURCE_DIR}/src/tsg_sync_state.cpp gtest_common.cpp gtest_session_state.cpp)
target_link_libraries(gtest_sync_session_state gtest-static cjson ctemplate-static)
add_executable(gtest_sync_state ${PROJECT_SOURCE_DIR}/src/tsg_sync_state.cpp ${PROJECT_SOURCE_DIR}/src/mpack.c gtest_common.cpp gtest_sync_state.cpp)
target_link_libraries(gtest_sync_state gtest-static cjson ctemplate-static MESA_handle_logger)
add_executable(gtest_fieldstat3 ${PROJECT_SOURCE_DIR}/src/tsg_statistic.cpp gtest_common.cpp gtest_fieldstat3.cpp)
target_link_libraries(gtest_fieldstat3 gtest-static ctemplate-static MESA_field_stat2 fieldstat3 MESA_prof_load MESA_handle_logger)
add_executable(gtest_proxy ${TSG_MASTER_SRC} ${PROJECT_SOURCE_DIR}/src/mpack.c gtest_common.cpp gtest_proxy.cpp)
target_link_libraries(gtest_proxy gtest-static ctemplate-static cjson MESA_prof_load MESA_handle_logger MESA_jump_layer MESA_field_stat2 maat4 rdkafka MESA_htable fieldstat3 pcap)
file(COPY ../pcap/ DESTINATION ./pcap/)

2
test/src/gtest_bridge.cpp
View File

@@ -76,7 +76,7 @@ int session_flags_identify_result_cb(const struct streaminfo * a_stream, int bri
return 0;
}
int tsg_sync_policy_update(const struct streaminfo *a_stream, struct update_policy *policy_array, int policy_array_num)
int tsg_sync_policy_update(const struct streaminfo *a_stream, struct update_policy *policy_update)
{
return 0;
}

20
test/src/gtest_common.cpp
View File

@@ -42,11 +42,11 @@ int sapp_inject_pkt(struct streaminfo * stream, enum sapp_inject_opt sio, const
int sapp_inject_ctrl_pkt(struct streaminfo * stream, enum sapp_inject_opt sio, const void * payload, int payload_len, unsigned char snd_routedir)
{
memset(&ctrl_pkt, 0, 1024);
memcpy(ctrl_pkt.buf, payload, payload_len);
ctrl_pkt.len = payload_len;
memset(&ctrl_pkt, 0, 1050);
memcpy(ctrl_pkt.buf, payload, payload_len);
ctrl_pkt.len = payload_len;
return 0;
return 0;
}
int get_ctrl_pkt(char *buf, int len)
@@ -113,6 +113,18 @@ int MESA_get_stream_opt(const struct streaminfo * pstream, enum MESA_stream_opt
return 0;
}
const void *get_rawpkt_from_streaminfo(const struct streaminfo *pstream)
{
return (void*)1;
}
int get_opt_from_rawpkt(const void *rawpkt, int type, void *out_value)
{
if (type > RWA_PKT_GET_SID_LIST) {
return -1;
}
return 0;
}
int sapp_get_platform_opt(enum sapp_platform_opt opt, void * opt_val, int * opt_val_len)
{

140
test/src/gtest_proxy.cpp Normal file
View File

@@ -0,0 +1,140 @@
#include <linux/if_ether.h>
#include <netinet/ip6.h>
#include <pcap.h>
#include <gtest/gtest.h>
#include <pcap/pcap.h>
#include <netinet/ip.h>
#include "tsg_proxy.h"
TEST(IPV4, tcp_opt_parse)
{
struct pkt_info pktinfo;
struct tsg_proxy_tcp_attribute tcp_attr;
pcap_t *pcap_file_fd = NULL;
struct pcap_pkthdr *header; // pcap报文头部结构
const u_char *packet; // 报文数据指针
struct iphdr *ip; // ip头部结构
struct streaminfo stream;
char errbuf[PCAP_ERRBUF_SIZE];
pcap_file_fd = pcap_open_offline("pcap/ipv4_ssl_handshake.pcapng", errbuf);
ASSERT_TRUE(pcap_file_fd != NULL);
//syn
ASSERT_TRUE(pcap_next_ex(pcap_file_fd, &header, &packet) >= 0);
ip = (struct iphdr*) (packet + sizeof(struct ethhdr));
tsg_proxy_ipv4_header_parse((void *)ip, &pktinfo);
tsg_proxy_tcp_parse(&tcp_attr, &pktinfo, &stream);
ASSERT_EQ(tcp_attr.tcp_opt_client.mss, 1460);
ASSERT_EQ(tcp_attr.tcp_opt_client.wscale_set, 1);
ASSERT_EQ(tcp_attr.tcp_opt_client.wscale, 8);
ASSERT_EQ(tcp_attr.tcp_opt_client.sack, 1);
ASSERT_EQ(tcp_attr.tcp_opt_client.ts_set, 1);
ASSERT_EQ(tcp_attr.tcp_opt_client.ts_val, ntohl(619788329));
ASSERT_EQ(tcp_attr.tcp_opt_client.ts_ecr, 0);
ASSERT_EQ(tcp_attr.tcp_opt_client.window, 64240);
//syn&ack
ASSERT_TRUE(pcap_next_ex(pcap_file_fd, &header, &packet) >= 0);
ip = (struct iphdr*) (packet + sizeof(struct ethhdr));
tsg_proxy_ipv4_header_parse((void *)ip, &pktinfo);
tsg_proxy_tcp_parse(&tcp_attr, &pktinfo, &stream);
ASSERT_EQ(tcp_attr.tcp_opt_server.mss, 1460);
ASSERT_EQ(tcp_attr.tcp_opt_server.wscale_set, 1);
ASSERT_EQ(tcp_attr.tcp_opt_server.wscale, 8);
ASSERT_EQ(tcp_attr.tcp_opt_server.sack, 1);
ASSERT_EQ(tcp_attr.tcp_opt_server.ts_set, 1);
ASSERT_EQ(tcp_attr.tcp_opt_server.ts_val, ntohl(201296612));
ASSERT_EQ(tcp_attr.tcp_opt_server.ts_ecr, ntohl(619788329));
ASSERT_EQ(tcp_attr.tcp_opt_server.window, 65535);
//ack
ASSERT_TRUE(pcap_next_ex(pcap_file_fd, &header, &packet) >= 0);
ip = (struct iphdr*) (packet + sizeof(struct ethhdr));
tsg_proxy_ipv4_header_parse((void *)ip, &pktinfo);
tsg_proxy_tcp_parse(&tcp_attr, &pktinfo, &stream);
//first data pkt
ASSERT_TRUE(pcap_next_ex(pcap_file_fd, &header, &packet) >= 0);
ip = (struct iphdr*) (packet + sizeof(struct ethhdr));
tsg_proxy_ipv4_header_parse((void *)ip, &pktinfo);
stream.curdir = DIR_C2S;
tsg_proxy_first_data_process(&stream, &tcp_attr, &pktinfo);
ASSERT_EQ(tcp_attr.tcp_opt_client.ts_val, ntohl(619788360));
ASSERT_EQ(tcp_attr.tcp_opt_server.ts_val, ntohl(201296612));
ASSERT_EQ(tcp_attr.tcp_seq, ntohl(265573753));
ASSERT_EQ(tcp_attr.tcp_ack, ntohl(2286004672));
ASSERT_EQ(tcp_attr.tcp_info_packet_cur_dir, DIR_C2S);
pcap_close(pcap_file_fd);
}
TEST(IPV6, tcp_opt_parse)
{
struct pkt_info pktinfo;
struct tsg_proxy_tcp_attribute tcp_attr;
pcap_t *pcap_file_fd = NULL;
struct pcap_pkthdr *header; // pcap报文头部结构
const u_char *packet; // 报文数据指针
struct ip6_hdr *ip6; // ip头部结构
struct streaminfo stream;
char errbuf[PCAP_ERRBUF_SIZE];
pcap_file_fd = pcap_open_offline("pcap/ipv6_ssl_handshake.pcapng", errbuf);
ASSERT_TRUE(pcap_file_fd != NULL);
//syn
ASSERT_TRUE(pcap_next_ex(pcap_file_fd, &header, &packet) >= 0);
ip6 = (struct ip6_hdr*) (packet + sizeof(struct ethhdr));
tsg_proxy_ipv6_header_parse((void *)ip6, &pktinfo);
tsg_proxy_tcp_parse(&tcp_attr, &pktinfo, &stream);
ASSERT_EQ(tcp_attr.tcp_opt_client.mss, 1440);
ASSERT_EQ(tcp_attr.tcp_opt_client.wscale_set, 1);
ASSERT_EQ(tcp_attr.tcp_opt_client.wscale, 8);
ASSERT_EQ(tcp_attr.tcp_opt_client.sack, 1);
ASSERT_EQ(tcp_attr.tcp_opt_client.ts_set, 1);
ASSERT_EQ(tcp_attr.tcp_opt_client.ts_val, ntohl(619788492));
ASSERT_EQ(tcp_attr.tcp_opt_client.ts_ecr, 0);
ASSERT_EQ(tcp_attr.tcp_opt_client.window, 64800);
//syn&ack
ASSERT_TRUE(pcap_next_ex(pcap_file_fd, &header, &packet) >= 0);
ip6 = (struct ip6_hdr*) (packet + sizeof(struct ethhdr));
tsg_proxy_ipv6_header_parse((void *)ip6, &pktinfo);
tsg_proxy_tcp_parse(&tcp_attr, &pktinfo, &stream);
ASSERT_EQ(tcp_attr.tcp_opt_server.mss, 1440);
ASSERT_EQ(tcp_attr.tcp_opt_server.wscale_set, 1);
ASSERT_EQ(tcp_attr.tcp_opt_server.wscale, 8);
ASSERT_EQ(tcp_attr.tcp_opt_server.sack, 1);
ASSERT_EQ(tcp_attr.tcp_opt_server.ts_set, 1);
ASSERT_EQ(tcp_attr.tcp_opt_server.ts_val, ntohl(1014079587));
ASSERT_EQ(tcp_attr.tcp_opt_server.ts_ecr, ntohl(619788492));
ASSERT_EQ(tcp_attr.tcp_opt_server.window, 65535);
//ack
ASSERT_TRUE(pcap_next_ex(pcap_file_fd, &header, &packet) >= 0);
ip6 = (struct ip6_hdr*) (packet + sizeof(struct ethhdr));
tsg_proxy_ipv6_header_parse((void *)ip6, &pktinfo);
tsg_proxy_tcp_parse(&tcp_attr, &pktinfo, &stream);
//first data pkt
ASSERT_TRUE(pcap_next_ex(pcap_file_fd, &header, &packet) >= 0);
ip6 = (struct ip6_hdr*) (packet + sizeof(struct ethhdr));
tsg_proxy_ipv6_header_parse((void *)ip6, &pktinfo);
stream.curdir = DIR_C2S;
tsg_proxy_first_data_process(&stream, &tcp_attr, &pktinfo);
ASSERT_EQ(tcp_attr.tcp_opt_client.ts_val, ntohl(619788540));
ASSERT_EQ(tcp_attr.tcp_opt_server.ts_val, ntohl(1014079587));
ASSERT_EQ(tcp_attr.tcp_seq, ntohl(625826589));
ASSERT_EQ(tcp_attr.tcp_ack, ntohl(64211095));
ASSERT_EQ(tcp_attr.tcp_info_packet_cur_dir, DIR_C2S);
pcap_close(pcap_file_fd);
}
int main(int argc, char *argv[])
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

186
test/src/gtest_session_state.cpp
View File

@@ -1,186 +0,0 @@
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <gtest/gtest.h>
#include <MESA/cJSON.h>
#include "tsg_sync_state.h"
extern int get_ctrl_pkt(char *buf, int len);
struct parse_handle test_handle;
unsigned long long tsg_get_stream_trace_id(const struct streaminfo * a_stream)
{
return 10;
}
int set_exec_profile_ids( struct streaminfo *a_stream, struct parse_handle *p)
{
memcpy(&test_handle, p, sizeof(struct parse_handle));
return 0;
}
TEST(SESSION_STATE, IllegalPara)
{
struct streaminfo a_stream = {0};
struct update_policy policy_array[2];
memset(policy_array, 0, sizeof(struct update_policy) * 2);
EXPECT_EQ(-1, tsg_send_session_state(NULL, 0));
a_stream.opstate = OP_STATE_DATA;
EXPECT_EQ(-1, tsg_send_session_state(&a_stream, OP_STATE_DATA));
EXPECT_EQ(-1, tsg_sync_resetall_state(NULL));
EXPECT_EQ(0, tsg_sync_resetall_state(&a_stream));
EXPECT_EQ(-1, tsg_sync_policy_update(&a_stream, policy_array, 0));
EXPECT_EQ(-1, tsg_sync_policy_update(&a_stream, NULL, 2));
EXPECT_EQ(-1, tsg_sync_policy_update(NULL, policy_array, 2));
policy_array[0].type = POLICY_UPDATE_MAX;
EXPECT_EQ(-1, tsg_sync_policy_update(&a_stream, policy_array, 2));
}
TEST(SESSION_STATE, OpeningState)
{
struct streaminfo a_stream = {0};
char ctrl_pkt_buf[1024];
int ctrl_pkt_len = 0;
a_stream.opstate = OP_STATE_PENDING;
EXPECT_EQ(0, tsg_send_session_state(&a_stream, OP_STATE_PENDING));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
EXPECT_EQ(ctrl_pkt_len, strlen(ctrl_pkt_buf)+1);
EXPECT_STREQ("{\"state\":\"opening\",\"session_id\":\"10\",\"tsync\":\"1.0\"}", ctrl_pkt_buf);
}
TEST(SESSION_STATE, CloseState)
{
struct streaminfo a_stream = {0};
char ctrl_pkt_buf[1024];
int ctrl_pkt_len = 0;
a_stream.opstate = OP_STATE_CLOSE;
EXPECT_EQ(0, tsg_send_session_state(&a_stream, OP_STATE_CLOSE));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
EXPECT_EQ(ctrl_pkt_len, strlen(ctrl_pkt_buf)+1);
EXPECT_STREQ("{\"state\":\"closing\",\"session_id\":\"10\",\"tsync\":\"1.0\"}", ctrl_pkt_buf);
}
TEST(SESSION_STATE, ResetAllState)
{
struct streaminfo a_stream = {0};
char ctrl_pkt_buf[1024];
int ctrl_pkt_len = 0;
EXPECT_EQ(0, tsg_sync_resetall_state(&a_stream));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
EXPECT_EQ(ctrl_pkt_len, strlen(ctrl_pkt_buf)+1);
EXPECT_STREQ("{\"state\":\"resetall\",\"session_id\":\"10\",\"tsync\":\"1.0\"}", ctrl_pkt_buf);
}
TEST(SESSION_STATE, ActiveStateOnlyServiceChaining)
{
struct streaminfo a_stream = {0};
struct update_policy policy_array;
char ctrl_pkt_buf[1024];
int ctrl_pkt_len = 0;
memset(&policy_array, 0, sizeof(struct update_policy));
EXPECT_EQ(0, tsg_sync_policy_update(&a_stream, &policy_array, 1));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
EXPECT_EQ(ctrl_pkt_len, strlen(ctrl_pkt_buf)+1);
EXPECT_STREQ("{\"state\":\"active\",\"method\":\"policy_update\",\"params\":{\"service_chaining\":[]},\"session_id\":\"10\",\"tsync\":\"1.0\"}", ctrl_pkt_buf);
}
TEST(SESSION_STATE, ActiveStateOnlyShaping)
{
struct streaminfo a_stream = {0};
struct update_policy policy_array;
char ctrl_pkt_buf[1024];
int ctrl_pkt_len = 0;
memset(&policy_array, 0, sizeof(struct update_policy));
policy_array.type = POLICY_UPDATE_SHAPING;
EXPECT_EQ(0, tsg_sync_policy_update(&a_stream, &policy_array, 1));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
EXPECT_EQ(ctrl_pkt_len, strlen(ctrl_pkt_buf)+1);
EXPECT_STREQ("{\"state\":\"active\",\"method\":\"policy_update\",\"params\":{\"shaping\":[]},\"session_id\":\"10\",\"tsync\":\"1.0\"}", ctrl_pkt_buf);
}
TEST(SESSION_STATE, ActiveStateServiceChainingAndShaping0)
{
struct streaminfo a_stream = {0};
struct update_policy policy_array[2];
char ctrl_pkt_buf[1024];
int ctrl_pkt_len = 0;
memset(&policy_array, 0, sizeof(struct update_policy) * 2);
policy_array[0].type = POLICY_UPDATE_SHAPING;
EXPECT_EQ(0, tsg_sync_policy_update(&a_stream, policy_array, 2));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
EXPECT_EQ(ctrl_pkt_len, strlen(ctrl_pkt_buf)+1);
EXPECT_STREQ("{\"state\":\"active\",\"method\":\"policy_update\",\"params\":{\"shaping\":[],\"service_chaining\":[]},\"session_id\":\"10\",\"tsync\":\"1.0\"}", ctrl_pkt_buf);
}
TEST(SESSION_STATE, ActiveStateServiceChainingAndShaping1)
{
struct streaminfo a_stream = {0};
struct update_policy policy_array[2];
char ctrl_pkt_buf[1024];
int ctrl_pkt_len = 0;
memset(&policy_array, 0, sizeof(struct update_policy) * 2);
policy_array[0].type = POLICY_UPDATE_SHAPING;
policy_array[0].n_ids = 3;
policy_array[0].ids[0] = 1;
policy_array[0].ids[1] = 2;
policy_array[0].ids[2] = 3;
policy_array[1].n_ids = 3;
policy_array[1].ids[0] = 4;
policy_array[1].ids[1] = 5;
policy_array[1].ids[2] = 6;
EXPECT_EQ(0, tsg_sync_policy_update(&a_stream, policy_array, 2));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
EXPECT_EQ(ctrl_pkt_len, strlen(ctrl_pkt_buf)+1);
EXPECT_STREQ("{\"state\":\"active\",\"method\":\"policy_update\",\"params\":{\"shaping\":[1,2,3],\"service_chaining\":[4,5,6]},\"session_id\":\"10\",\"tsync\":\"1.0\"}", ctrl_pkt_buf);
}
TEST(RECEIVE, IllegalPara)
{
struct streaminfo a_stream = {0};
const char *payload = "{\"tsync\":\"1.0\",\"session_id\":\"123456789\",\"state\":\"active\",\"method\":\"log_update\",\"params\":{\"sf_profile_ids\":}}";
const char *payload_ = "{\"tsync\":\"1.0\",\"session_id\":\"123456789\",\"state\":\"active\",\"method\":\"log_update\",\"params\":{\"sf_profile_ids\":[2,3,4,5,6,7]}}";
EXPECT_EQ(-1, tsg_recv_control_pkt(&a_stream, payload, strlen(payload)));
EXPECT_EQ(-1, tsg_recv_control_pkt(&a_stream, NULL, strlen(payload)));
EXPECT_EQ(-1, tsg_recv_control_pkt(&a_stream, payload, 0));
EXPECT_EQ(-1, tsg_recv_control_pkt(NULL, payload_, strlen(payload_)));
EXPECT_EQ(0, tsg_recv_control_pkt(&a_stream, payload_, strlen(payload_)));
}
#if 0
TEST(RECEIVE, JsonParse)
{
struct streaminfo a_stream = {0};
const char *payload_ = "{\"tsync\":\"1.0\",\"session_id\":\"123456789\",\"state\":\"active\",\"method\":\"log_update\",\"params\":{\"sf_profile_ids\":[2,3,4,5,6,7]}}";
EXPECT_EQ(0, tsg_recv_control_pkt(&a_stream, payload_, strlen(payload_)));
EXPECT_STREQ("1.0", test_handle.tsync);
EXPECT_EQ(123456789, test_handle.session_id);
EXPECT_STREQ("log_update", test_handle.method);
EXPECT_STREQ("active", test_handle.state);
EXPECT_EQ(6, test_handle.sf_ids.id_num);
for (int i = 0; i < 6; i++)
{
EXPECT_EQ(i+2, test_handle.sf_ids.ids[i]);
}
}
#endif
int main(int argc, char *argv[])
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

483
test/src/gtest_sync_state.cpp Normal file
View File

@@ -0,0 +1,483 @@
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <gtest/gtest.h>
#include <MESA/cJSON.h>
#include <MESA/MESA_handle_logger.h>
#include "tsg_sync_state.h"
#include "tsg_variable.h"
#include "mpack.h"
struct tsg_rt_para g_tsg_para;
extern int get_ctrl_pkt(char *buf, int len);
unsigned long long tsg_get_stream_trace_id(const struct streaminfo *a_stream)
{
return 10;
}
TEST(SESSION_STATE, IllegalPara)
{
struct streaminfo a_stream = {0};
struct update_policy policy_array[2];
memset(policy_array, 0, sizeof(struct update_policy) * 2);
EXPECT_EQ(-1, tsg_send_session_state(NULL, 0));
a_stream.opstate = OP_STATE_DATA;
EXPECT_EQ(-1, tsg_send_session_state(&a_stream, OP_STATE_DATA));
EXPECT_EQ(-1, tsg_sync_resetall_state(NULL));
EXPECT_EQ(0, tsg_sync_resetall_state(&a_stream));
EXPECT_EQ(-1, tsg_sync_policy_update(&a_stream, policy_array, 0));
EXPECT_EQ(-1, tsg_sync_policy_update(&a_stream, NULL, 2));
EXPECT_EQ(-1, tsg_sync_policy_update(NULL, policy_array, 2));
policy_array[0].type = POLICY_UPDATE_MAX;
EXPECT_EQ(-1, tsg_sync_policy_update(&a_stream, policy_array, 2));
}
TEST(SESSION_STATE, OpeningState)
{
struct streaminfo a_stream = {0};
char ctrl_pkt_buf[1024];
char test_str[256] = {0};
int ctrl_pkt_len = 0;
a_stream.opstate = OP_STATE_PENDING;
EXPECT_EQ(0, tsg_send_session_state(&a_stream, OP_STATE_PENDING));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
mpack_tree_t tree;
mpack_tree_init_data(&tree, ctrl_pkt_buf, ctrl_pkt_len);
mpack_tree_parse(&tree);
mpack_node_t root = mpack_tree_root(&tree);
// tsync:2.0
EXPECT_EQ(mpack_type_str, mpack_node_type(mpack_node_map_cstr(root, "tsync")));
memcpy(test_str, mpack_node_str(mpack_node_map_cstr(root, "tsync")), mpack_node_strlen(mpack_node_map_cstr(root, "tsync")));
EXPECT_STREQ("2.0", test_str);
memset(test_str, 0, 256);
// session_id
EXPECT_EQ(10, mpack_node_u64(mpack_node_map_cstr(root, "session_id")));
// state:opening
memcpy(test_str, mpack_node_str(mpack_node_map_cstr(root, "state")), mpack_node_strlen(mpack_node_map_cstr(root, "state")));
EXPECT_STREQ("opening", test_str);
memset(test_str, 0, 256);
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(SESSION_STATE, CloseState)
{
struct streaminfo a_stream = {0};
char ctrl_pkt_buf[1024];
char test_str[256] = {0};
int ctrl_pkt_len = 0;
a_stream.opstate = OP_STATE_CLOSE;
EXPECT_EQ(0, tsg_send_session_state(&a_stream, OP_STATE_CLOSE));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
mpack_tree_t tree;
mpack_tree_init_data(&tree, ctrl_pkt_buf, ctrl_pkt_len);
mpack_tree_parse(&tree);
mpack_node_t root = mpack_tree_root(&tree);
// tsync:2.0
EXPECT_EQ(mpack_type_str, mpack_node_type(mpack_node_map_cstr(root, "tsync")));
memcpy(test_str, mpack_node_str(mpack_node_map_cstr(root, "tsync")), mpack_node_strlen(mpack_node_map_cstr(root, "tsync")));
EXPECT_STREQ("2.0", test_str);
memset(test_str, 0, 256);
// session_id
EXPECT_EQ(10, mpack_node_u64(mpack_node_map_cstr(root, "session_id")));
// state:colse
memcpy(test_str, mpack_node_str(mpack_node_map_cstr(root, "state")), mpack_node_strlen(mpack_node_map_cstr(root, "state")));
EXPECT_STREQ("closing", test_str);
memset(test_str, 0, 256);
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(SESSION_STATE, ResetAllState)
{
struct streaminfo a_stream = {0};
char ctrl_pkt_buf[1024];
char test_str[256] = {0};
int ctrl_pkt_len = 0;
EXPECT_EQ(0, tsg_sync_resetall_state(&a_stream));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
mpack_tree_t tree;
mpack_tree_init_data(&tree, ctrl_pkt_buf, ctrl_pkt_len);
mpack_tree_parse(&tree);
mpack_node_t root = mpack_tree_root(&tree);
// state:resetall
memcpy(test_str, mpack_node_str(mpack_node_map_cstr(root, "state")), mpack_node_strlen(mpack_node_map_cstr(root, "state")));
EXPECT_STREQ("resetall", test_str);
memset(test_str, 0, 256);
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(POLICY_UPDATE, Sce)
{
char ctrl_pkt_buf[1024] = {0};
int ctrl_pkt_len = 0;
struct streaminfo a_stream = {0};
struct update_policy test;
test.type = POLICY_UPDATE_SERVICE_CHAINING;
test.n_ids = 4;
for (int i = 0; i < test.n_ids; i++)
{
test.ids[i] = 100 + i;
}
tsg_sync_policy_update(&a_stream, &test, 1);
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
mpack_tree_t tree;
mpack_tree_init_data(&tree, ctrl_pkt_buf, ctrl_pkt_len);
mpack_tree_parse(&tree);
mpack_node_t root = mpack_tree_root(&tree);
mpack_node_t sce_map = mpack_node_map_cstr(mpack_node_map_cstr(root, "params"), "sce");
for (int i = 0; i < 4; i++)
{
EXPECT_EQ(100 + i, mpack_node_i64(mpack_node_array_at(mpack_node_map_cstr(sce_map, "rule_ids"), i)));
}
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(POLICY_UPDATE, Shaper)
{
char ctrl_pkt_buf[1024] = {0};
int ctrl_pkt_len = 0;
struct streaminfo a_stream = {0};
struct update_policy test;
test.type = POLICY_UPDATE_SHAPING;
test.n_ids = 6;
for (int i = 0; i < test.n_ids; i++)
{
test.ids[i] = 10000 + i;
}
tsg_sync_policy_update(&a_stream, &test, 1);
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
mpack_tree_t tree;
mpack_tree_init_data(&tree, ctrl_pkt_buf, ctrl_pkt_len);
mpack_tree_parse(&tree);
mpack_node_t root = mpack_tree_root(&tree);
mpack_node_t shaper_map = mpack_node_map_cstr(mpack_node_map_cstr(root, "params"), "shaper");
for (int i = 0; i < 6; i++)
{
EXPECT_EQ(10000 + i, mpack_node_i64(mpack_node_array_at(mpack_node_map_cstr(shaper_map, "rule_ids"), i)));
}
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(SESSION_STATE, ActiveStateServiceChainingAndShaping0)
{
struct streaminfo a_stream = {0};
struct update_policy policy_array[2];
char test_str[256] = {0};
char ctrl_pkt_buf[1024];
int ctrl_pkt_len = 0;
memset(&policy_array, 0, sizeof(struct update_policy) * 2);
policy_array[0].type = POLICY_UPDATE_SHAPING;
EXPECT_EQ(0, tsg_sync_policy_update(&a_stream, policy_array, 2));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
mpack_tree_t tree;
mpack_tree_init_data(&tree, ctrl_pkt_buf, ctrl_pkt_len);
mpack_tree_parse(&tree);
mpack_node_t root = mpack_tree_root(&tree);
// tsync:2.0
EXPECT_EQ(mpack_type_str, mpack_node_type(mpack_node_map_cstr(root, "tsync")));
memcpy(test_str, mpack_node_str(mpack_node_map_cstr(root, "tsync")), mpack_node_strlen(mpack_node_map_cstr(root, "tsync")));
EXPECT_STREQ("2.0", test_str);
memset(test_str, 0, 256);
// session_id
EXPECT_EQ(10, mpack_node_u64(mpack_node_map_cstr(root, "session_id")));
// state:active
EXPECT_EQ(mpack_type_str, mpack_node_type(mpack_node_map_cstr(root, "state")));
memcpy(test_str, mpack_node_str(mpack_node_map_cstr(root, "state")), mpack_node_strlen(mpack_node_map_cstr(root, "state")));
EXPECT_STREQ("active", test_str);
memset(test_str, 0, 256);
// sce
mpack_node_t policy_sce = mpack_node_map_cstr(mpack_node_map_cstr(root, "params"), "sce");
EXPECT_EQ(mpack_type_map, mpack_node_type(policy_sce));
EXPECT_EQ(1, mpack_node_map_count(policy_sce));
EXPECT_EQ(mpack_type_nil, mpack_node_type(mpack_node_map_cstr(policy_sce, "rule_ids")));
// shaper
mpack_node_t policy_shaper = mpack_node_map_cstr(mpack_node_map_cstr(root, "params"), "shaper");
EXPECT_EQ(mpack_type_map, mpack_node_type(policy_shaper));
EXPECT_EQ(1, mpack_node_map_count(policy_shaper));
EXPECT_EQ(mpack_type_nil, mpack_node_type(mpack_node_map_cstr(policy_shaper, "rule_ids")));
// // proxy
// EXPECT_EQ(mpack_type_nil, mpack_node_type(mpack_node_map_cstr(mpack_node_map_cstr(root, "params"), "proxy")));
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(SESSION_STATE, ActiveStateServiceChainingAndShaping1)
{
struct streaminfo a_stream = {0};
struct update_policy policy_array[2];
char ctrl_pkt_buf[1024];
int ctrl_pkt_len = 0;
memset(&policy_array, 0, sizeof(struct update_policy) * 2);
policy_array[0].type = POLICY_UPDATE_SHAPING;
policy_array[0].n_ids = 3;
policy_array[0].ids[0] = 1;
policy_array[0].ids[1] = 2;
policy_array[0].ids[2] = 3;
policy_array[1].n_ids = 3;
policy_array[1].ids[0] = 4;
policy_array[1].ids[1] = 5;
policy_array[1].ids[2] = 6;
EXPECT_EQ(0, tsg_sync_policy_update(&a_stream, policy_array, 2));
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
mpack_tree_t tree;
mpack_tree_init_data(&tree, ctrl_pkt_buf, ctrl_pkt_len);
mpack_tree_parse(&tree);
mpack_node_t root = mpack_tree_root(&tree);
// sce
EXPECT_EQ(mpack_type_map, mpack_node_type(mpack_node_map_cstr(mpack_node_map_cstr(root, "params"), "sce")));
mpack_node_t sce_map = mpack_node_map_cstr(mpack_node_map_cstr(root, "params"), "sce");
EXPECT_EQ(3, mpack_node_array_length(mpack_node_map_cstr(sce_map, "rule_ids")));
for (int i = 0; i < 3; i++)
{
EXPECT_EQ(4 + i, mpack_node_i64(mpack_node_array_at(mpack_node_map_cstr(sce_map, "rule_ids"), i)));
}
// shaper
EXPECT_EQ(mpack_type_map, mpack_node_type(mpack_node_map_cstr(mpack_node_map_cstr(root, "params"), "shaper")));
mpack_node_t shaper_map = mpack_node_map_cstr(mpack_node_map_cstr(root, "params"), "shaper");
EXPECT_EQ(3, mpack_node_array_length(mpack_node_map_cstr(shaper_map, "rule_ids")));
for (int i = 0; i < 3; i++)
{
EXPECT_EQ(1 + i, mpack_node_i64(mpack_node_array_at(mpack_node_map_cstr(shaper_map, "rule_ids"), i)));
}
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
static void gtest_cmsg_init(struct proxy_cmsg *cmsg)
{
cmsg->tcp_wsacle_exist = 1;
cmsg->tcp_seq = 1;
cmsg->tcp_ack = 2;
cmsg->tcp_mss_client = 3;
cmsg->tcp_mss_server = 4;
cmsg->tcp_wsacle_client = 6;
cmsg->tcp_wsacle_server = 7;
cmsg->tcp_sack_client = 8;
cmsg->tcp_sack_server = 9;
cmsg->tcp_ts_client = 10;
cmsg->tcp_ts_server = 11;
cmsg->tcp_protocol = 12;
cmsg->tcp_window_client = 13;
cmsg->tcp_window_server = 14;
cmsg->tcp_ts_client_val = 15;
cmsg->tcp_ts_server_val = 16;
cmsg->tcp_info_packet_cur_dir = 17;
cmsg->src_sub_id = (char *)calloc(1, 256);
snprintf(cmsg->src_sub_id, 256, "thisistest=%d", 1);
cmsg->dst_sub_id = (char *)calloc(1, 256);
snprintf(cmsg->dst_sub_id, 256, "thisistest=%d", 2);
cmsg->src_asn = (char *)calloc(1, 256);
snprintf(cmsg->src_asn, 256, "thisistest=%d", 3);
cmsg->dst_asn = (char *)calloc(1, 256);
snprintf(cmsg->dst_asn, 256, "thisistest=%d", 4);
cmsg->src_organization = (char *)calloc(1, 256);
snprintf(cmsg->src_organization, 256, "thisistest=%d", 5);
cmsg->dst_organization = (char *)calloc(1, 256);
snprintf(cmsg->dst_organization, 256, "thisistest=%d", 6);
cmsg->src_ip_location_country = (char *)calloc(1, 256);
snprintf(cmsg->src_ip_location_country, 256, "thisistest=%d", 7);
cmsg->dst_ip_location_country = (char *)calloc(1, 256);
snprintf(cmsg->dst_ip_location_country, 256, "thisistest=%d", 8);
cmsg->src_ip_location_provine = (char *)calloc(1, 256);
snprintf(cmsg->src_ip_location_provine, 256, "thisistest=%d", 9);
cmsg->dst_ip_location_provine = (char *)calloc(1, 256);
snprintf(cmsg->dst_ip_location_provine, 256, "thisistest=%d", 10);
cmsg->src_ip_location_city = (char *)calloc(1, 256);
snprintf(cmsg->src_ip_location_city, 256, "thisistest=%d", 11);
cmsg->dst_ip_location_city = (char *)calloc(1, 256);
snprintf(cmsg->dst_ip_location_city, 256, "thisistest=%d", 12);
cmsg->src_ip_location_subdivision = (char *)calloc(1, 256);
snprintf(cmsg->src_ip_location_subdivision, 256, "thisistest=%d", 13);
cmsg->dst_ip_location_subdivision = (char *)calloc(1, 256);
snprintf(cmsg->dst_ip_location_subdivision, 256, "thisistest=%d", 14);
cmsg->ssl_client_ja3_fingerprint = (char *)calloc(1, 256);
snprintf(cmsg->ssl_client_ja3_fingerprint, 256, "thisistest=%d", 15);
cmsg->fqdn_cat_id_val.num = 4;
for (size_t i = 0; i < 4; i++)
{
cmsg->fqdn_cat_id_val.value[i] = i + 1;
}
cmsg->tcp_seq_sids.num = 5;
for (size_t i = 0; i < 5; i++)
{
cmsg->tcp_seq_sids.value[i] = i + 2;
}
cmsg->tcp_ack_sids.num = 6;
for (size_t i = 0; i < 6; i++)
{
cmsg->tcp_ack_sids.value[i] = i + 3;
}
cmsg->tcp_seq_route_ctx.num = 7;
for (size_t i = 0; i < 7; i++)
{
cmsg->tcp_seq_route_ctx.value[i] = i + 4;
}
cmsg->tcp_ack_route_ctx.num = 8;
for (size_t i = 0; i < 8; i++)
{
cmsg->tcp_ack_route_ctx.value[i] = i + 5;
}
return;
}
static void gtest_cmsg_destroy(struct proxy_cmsg *cmsg)
{
free(cmsg->src_sub_id);
free(cmsg->dst_sub_id);
free(cmsg->src_asn);
free(cmsg->dst_asn);
free(cmsg->src_organization);
free(cmsg->dst_organization);
free(cmsg->src_ip_location_country);
free(cmsg->dst_ip_location_country);
free(cmsg->src_ip_location_provine);
free(cmsg->dst_ip_location_provine);
free(cmsg->src_ip_location_city);
free(cmsg->dst_ip_location_city);
free(cmsg->src_ip_location_subdivision);
free(cmsg->dst_ip_location_subdivision);
free(cmsg->ssl_client_ja3_fingerprint);
}
TEST(POLICY_UPDATE, Proxy)
{
char ctrl_pkt_buf[1024] = {0};
char test_str[256] = {0};
int ctrl_pkt_len = 0;
struct streaminfo a_stream = {0};
struct update_policy test;
struct proxy_cmsg cmsg;
test.type = POLICY_UPDATE_INTERCEPT;
test.n_ids = 6;
for (int i = 0; i < test.n_ids; i++)
{
test.ids[i] = 10000 + i;
}
gtest_cmsg_init(&cmsg);
memcpy(&test.cmsg, &cmsg, sizeof(struct proxy_cmsg));
tsg_sync_policy_update(&a_stream, &test, 1);
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, 1024);
mpack_tree_t tree;
mpack_tree_init_data(&tree, ctrl_pkt_buf, ctrl_pkt_len);
mpack_tree_parse(&tree);
mpack_node_t root = mpack_tree_root(&tree);
mpack_node_t params = mpack_node_map_cstr(root, "params");
// proxy
EXPECT_EQ(mpack_type_map, mpack_node_type(mpack_node_map_cstr(params, "proxy")));
mpack_node_t proxy_map = mpack_node_map_cstr(params, "proxy");
EXPECT_EQ(6, mpack_node_array_length(mpack_node_map_cstr(proxy_map, "rule_ids")));
// proxy.rule_ids
for (int i = 0; i < test.n_ids; i++)
{
EXPECT_EQ(10000 + i, mpack_node_i64(mpack_node_array_at(mpack_node_map_cstr(proxy_map, "rule_ids"), i)));
}
mpack_node_t tcp_handshake = mpack_node_map_cstr(proxy_map, "tcp_handshake");
EXPECT_EQ(1, mpack_node_u32(mpack_node_array_at(tcp_handshake, 0)));
EXPECT_EQ(16, mpack_node_u32(mpack_node_array_at(tcp_handshake, 14)));
memcpy(test_str, mpack_node_str(mpack_node_array_at(tcp_handshake, 17)), mpack_node_strlen(mpack_node_array_at(tcp_handshake, 17)));
EXPECT_STREQ("thisistest=2", test_str);
memset(test_str, 0, 256);
memcpy(test_str, mpack_node_str(mpack_node_array_at(tcp_handshake, 30)), mpack_node_strlen(mpack_node_array_at(tcp_handshake, 30)));
EXPECT_STREQ("thisistest=15", test_str);
memset(test_str, 0, 256);
mpack_node_t fqdn_cat_id_vals = mpack_node_array_at(tcp_handshake, 31);
EXPECT_EQ(4, mpack_node_array_length(fqdn_cat_id_vals));
for (int i = 0; i < 4; i++)
{
EXPECT_EQ(i + 1, mpack_node_u32(mpack_node_array_at(fqdn_cat_id_vals, i)));
}
mpack_node_t tcp_ack_route_ctxs = mpack_node_array_at(tcp_handshake, 35);
EXPECT_EQ(8, mpack_node_array_length(tcp_ack_route_ctxs));
for (int i = 0; i < 8; i++)
{
EXPECT_EQ(i + 5, mpack_node_u8(mpack_node_array_at(tcp_ack_route_ctxs, i)));
}
// // sce
// EXPECT_EQ(mpack_type_nil, mpack_node_type(mpack_node_map_cstr(params, "sce")));
// // shaper
// EXPECT_EQ(mpack_type_nil, mpack_node_type(mpack_node_map_cstr(params, "shaper")));
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
gtest_cmsg_destroy(&cmsg);
}
int main(int argc, char *argv[])
{
g_tsg_para.logger = MESA_create_runtime_log_handle("log/tsg_sync_state", 10);
testing::InitGoogleTest(&argc, argv);
int ret = RUN_ALL_TESTS();
MESA_destroy_runtime_log_handle(g_tsg_para.logger);
return ret;
}