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

test/src/gtest_sync_state.cpp

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