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

TSG-14928: 接收通知的ssl_intercept_info信息,填充到Proxy_intercept_event日志中发送; 接收SCE/SHAPER通知的日志信息

Browse Source
This commit is contained in:
杨玉波
2023-05-10 07:35:03 +00:00
committed by liuxueli
parent c5e959492d
commit ee0f57d6d3
15 changed files with 1666 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test/src/gtest_common.cpp
View File

@@ -119,7 +119,7 @@ const void *get_rawpkt_from_streaminfo(const struct streaminfo *pstream)
}
int get_opt_from_rawpkt(const void *rawpkt, int type, void *out_value)
{
if (type > RWA_PKT_GET_SID_LIST) {
if (type > RAW_PKT_GET_SID_LIST) {
return -1;
}

33
test/src/gtest_kafka.cpp
View File

@@ -1,6 +1,8 @@
#include <string.h>
#include <librdkafka/rdkafka.h>
#include <MESA/cJSON.h>
#ifndef MIN
#define MIN(a,b) ((a)>(b) ? (b) : (a))
#endif
@@ -56,8 +58,30 @@ const char *rd_kafka_err2str(rd_kafka_resp_err_t err)
int rd_kafka_produce(rd_kafka_topic_t *rkt, int32_t partitition, int msgflags, void *payload, size_t len, const void *key, size_t keylen, void *msg_opaque)
{
int length=MIN(len, sizeof(g_kafka_sendlog[g_kafka_sendlog_cnt]));
memcpy((void *)(g_kafka_sendlog[g_kafka_sendlog_cnt++]), payload, length);
cJSON *object=cJSON_Parse((const char *)payload);
if(object!=NULL)
{
cJSON_DeleteItemFromObject(object, "common_start_time");
cJSON_DeleteItemFromObject(object, "common_end_time");
char *result=cJSON_PrintUnformatted(object);
int length=MIN(strlen(result), sizeof(g_kafka_sendlog[g_kafka_sendlog_cnt]));
memset(g_kafka_sendlog[g_kafka_sendlog_cnt], 0, sizeof(g_kafka_sendlog[g_kafka_sendlog_cnt]));
memcpy((void *)(g_kafka_sendlog[g_kafka_sendlog_cnt++]), result, length);
cJSON_free(result);
result=NULL;
cJSON_Delete(object);
object=NULL;
}
else
{
int length=MIN(len, sizeof(g_kafka_sendlog[g_kafka_sendlog_cnt]));
memset(g_kafka_sendlog[g_kafka_sendlog_cnt], 0, sizeof(g_kafka_sendlog[g_kafka_sendlog_cnt]));
memcpy((void *)(g_kafka_sendlog[g_kafka_sendlog_cnt++]), payload, length);
}
return 0;
}
@@ -66,6 +90,11 @@ int rd_kafka_get_sendlog_cnt(void)
return g_kafka_sendlog_cnt;
}
void rd_kafka_clean_sendlog_cnt(void)
{
g_kafka_sendlog_cnt=0;
}
const char *rd_kafka_get_sendlog_payload(int idx)
{
if(idx>g_kafka_sendlog_cnt || idx <0)

208
test/src/gtest_master.cpp
View File

@@ -4,10 +4,12 @@
#include "gtest_common.h"
#include "tsg_entry.h"
#include "tsg_sync_state.h"
#include "tsg_rule_internal.h"
#include <gtest/gtest.h>
extern int rd_kafka_get_sendlog_cnt(void);
extern void rd_kafka_clean_sendlog_cnt(void);
extern const char *rd_kafka_get_sendlog_payload(int idx);
extern int matched_shaping_rules_deal(const struct streaminfo *a_stream, struct maat_rule *shaping_rules, size_t n_shaping_rules, int thread_seq);;
extern int matched_service_chaining_rules_deal(const struct streaminfo *a_stream, struct maat_rule *service_chaining_rules, size_t n_service_chaining_rules, int thread_seq);
@@ -15,7 +17,6 @@ extern int matched_intercept_rules_deal(const struct streaminfo * a_stream, stru
extern void session_segment_id_free(const struct streaminfo * a_stream, int bridge_id, void * data);
TEST(TSGMaster, SetAPPIDHttp)
{
const struct streaminfo a_stream={0};
@@ -299,15 +300,17 @@ TEST(TSGMaster, SecurityPolicySendlog)
int sendlog_cnt=rd_kafka_get_sendlog_cnt();
EXPECT_EQ(9, sendlog_cnt);
//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(0));
//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(1));
//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(2));
//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(3));
//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(4));
//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(5));
//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(6));
//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(7));
//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(8));
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"common_policy_id\":1,\"common_service\":0,\"common_vsys_id\":0,\"common_action\":1}", rd_kafka_get_sendlog_payload(0));
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"common_policy_id\":2,\"common_service\":0,\"common_vsys_id\":0,\"common_action\":1}", rd_kafka_get_sendlog_payload(1));
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"common_policy_id\":3,\"common_service\":0,\"common_vsys_id\":0,\"common_action\":1}", rd_kafka_get_sendlog_payload(2));
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"common_policy_id\":4,\"common_service\":0,\"common_vsys_id\":0,\"common_action\":1}", rd_kafka_get_sendlog_payload(3));
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"common_policy_id\":5,\"common_service\":0,\"common_vsys_id\":0,\"common_action\":1}", rd_kafka_get_sendlog_payload(4));
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"common_policy_id\":6,\"common_service\":0,\"common_vsys_id\":0,\"common_action\":1}", rd_kafka_get_sendlog_payload(5));
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"common_policy_id\":7,\"common_service\":0,\"common_vsys_id\":0,\"common_action\":1}", rd_kafka_get_sendlog_payload(6));
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"common_policy_id\":8,\"common_service\":0,\"common_vsys_id\":0,\"common_action\":1}", rd_kafka_get_sendlog_payload(7));
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1}", rd_kafka_get_sendlog_payload(8));
rd_kafka_clean_sendlog_cnt();
hited_security=session_matched_rules_get(&a_stream, TSG_SERVICE_SECURITY);
EXPECT_EQ(nullptr, hited_security);
@@ -655,37 +658,6 @@ TEST(TSGMaster, ShapingAndServiceChainingPolicyNotify)
EXPECT_EQ(nullptr, session_matched_rules_get(&a_stream, TSG_SERVICE_CHAINING));
}
TEST(TSGMaster, InterceptPolicy)
{
const struct streaminfo a_stream={0};
struct maat_rule matched_policy[MAX_RESULT_NUM]={0};
matched_policy[1].action=TSG_ACTION_INTERCEPT;
matched_policy[1].rule_id=TSG_ACTION_INTERCEPT;
matched_policy[1].service_id=TSG_SERVICE_INTERCEPT;
// Set Intercept
matched_intercept_rules_deal(&a_stream, &matched_policy[1], 1, 0);
const struct matched_policy_rules *hited_intercept=session_matched_rules_get(&a_stream, TSG_SERVICE_INTERCEPT);
EXPECT_NE(nullptr, hited_intercept);
EXPECT_EQ(1, hited_intercept->n_rules);
EXPECT_EQ(TSG_ACTION_INTERCEPT, hited_intercept->rules[0].action);
EXPECT_EQ(TSG_ACTION_INTERCEPT, hited_intercept->rules[0].rule_id);
EXPECT_EQ(TSG_SERVICE_INTERCEPT, hited_intercept->rules[0].service_id);
struct segment_id_list *segment_ids=(struct segment_id_list *)session_control_segment_ids_get(&a_stream);
EXPECT_NE(nullptr, segment_ids);
EXPECT_EQ(1, segment_ids->sz_sidlist);
EXPECT_EQ(g_tsg_para.intercept_sid, segment_ids->sid_list[0]);
session_segment_id_free(&a_stream, 0, (void *)segment_ids);
session_control_segment_ids_async(&a_stream, NULL);
session_matched_rules_free(&a_stream, TSG_SERVICE_INTERCEPT, (void *)hited_intercept);
session_matched_rules_async(&a_stream, TSG_SERVICE_INTERCEPT, NULL);
EXPECT_EQ(nullptr, session_matched_rules_get(&a_stream, TSG_SERVICE_INTERCEPT));
}
TEST(TSGMaster, InterceptAndNOInterceptPolicy)
{
const struct streaminfo a_stream={0};
@@ -847,6 +819,160 @@ TEST(TSGMaster, ServiceChainingAndShapingAndInterceptPolicy)
EXPECT_EQ(nullptr, session_matched_rules_get(&a_stream, TSG_SERVICE_INTERCEPT));
}
TEST(TSGMaster, InterceptPolicySendLog)
{
const struct streaminfo a_stream={0};
struct maat_rule matched_policy[MAX_RESULT_NUM]={0};
matched_policy[1].do_log=1;
matched_policy[1].action=TSG_ACTION_INTERCEPT;
matched_policy[1].rule_id=TSG_ACTION_INTERCEPT;
matched_policy[1].service_id=TSG_SERVICE_INTERCEPT;
// Set Intercept
matched_intercept_rules_deal(&a_stream, &matched_policy[1], 1, 0);
const struct matched_policy_rules *hited_intercept=session_matched_rules_get(&a_stream, TSG_SERVICE_INTERCEPT);
EXPECT_NE(nullptr, hited_intercept);
EXPECT_EQ(1, hited_intercept->n_rules);
EXPECT_EQ(TSG_ACTION_INTERCEPT, hited_intercept->rules[0].action);
EXPECT_EQ(TSG_ACTION_INTERCEPT, hited_intercept->rules[0].rule_id);
EXPECT_EQ(TSG_SERVICE_INTERCEPT, hited_intercept->rules[0].service_id);
struct segment_id_list *segment_ids=(struct segment_id_list *)session_control_segment_ids_get(&a_stream);
EXPECT_NE(nullptr, segment_ids);
EXPECT_EQ(1, segment_ids->sz_sidlist);
EXPECT_EQ(g_tsg_para.intercept_sid, segment_ids->sid_list[0]);
session_segment_id_free(&a_stream, 0, (void *)segment_ids);
session_control_segment_ids_async(&a_stream, NULL);
struct proxy_log_update proxy={0, 1, 1, 10, 20, (char*)"upstream_version", (char*)"downstream_version", (char*)"error", (char*)"passthrough_reason"};
session_log_update_data_put(&a_stream, TSG_SERVICE_INTERCEPT, (void *)&proxy);
struct TLD_handle_t *handle=TLD_create(0);
matched_policy[0].action=0;
matched_policy[0].rule_id=0;
matched_policy[0].service_id=0;
tsg_send_log(g_tsg_log_instance, handle, &a_stream, LOG_TYPE_SESSION_RECORD, &(matched_policy[0]), 1, 0);
int sendlog_cnt=rd_kafka_get_sendlog_cnt();
EXPECT_EQ(2, sendlog_cnt);
// intercept
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"ssl_pinningst\":0,\"ssl_cert_verify\":1,\"ssl_intercept_state\":1,\"ssl_server_side_latency\":10,\"ssl_client_side_latency\":20,\"ssl_server_side_version\":\"upstream_version\",\"ssl_client_side_version\":\"downstream_version\",\"ssl_error\":\"error\",\"ssl_passthrough_reason\":\"passthrough_reason\"}", rd_kafka_get_sendlog_payload(1));
// session record
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"ssl_pinningst\":0,\"ssl_cert_verify\":1,\"ssl_intercept_state\":1,\"ssl_server_side_latency\":10,\"ssl_client_side_latency\":20,\"ssl_server_side_version\":\"upstream_version\",\"ssl_client_side_version\":\"downstream_version\",\"ssl_error\":\"error\",\"ssl_passthrough_reason\":\"passthrough_reason\",\"common_policy_id\":2,\"common_service\":3,\"common_vsys_id\":0,\"common_action\":2}", rd_kafka_get_sendlog_payload(0));
session_log_update_data_put(&a_stream, TSG_SERVICE_INTERCEPT, NULL);
rd_kafka_clean_sendlog_cnt();
hited_intercept=session_matched_rules_get(&a_stream, TSG_SERVICE_INTERCEPT);
EXPECT_EQ(nullptr, hited_intercept);
}
TEST(TSGMaster, ServiceChainingPolicySendLog)
{
const struct streaminfo a_stream={0};
struct maat_rule matched_policy[MAX_RESULT_NUM]={0};
matched_policy[1].do_log=1;
matched_policy[1].action=TSG_ACTION_S_CHAINING;
matched_policy[1].rule_id=TSG_ACTION_S_CHAINING;
matched_policy[1].service_id=TSG_SERVICE_CHAINING;
// Set Intercept
matched_service_chaining_rules_deal(&a_stream, &matched_policy[1], 1, 0);
const struct matched_policy_rules *hited_s_chaining=session_matched_rules_get(&a_stream, TSG_SERVICE_CHAINING);
EXPECT_NE(nullptr, hited_s_chaining);
EXPECT_EQ(1, hited_s_chaining->n_rules);
EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->rules[0].action);
EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->rules[0].rule_id);
EXPECT_EQ(TSG_SERVICE_CHAINING, hited_s_chaining->rules[0].service_id);
struct segment_id_list *segment_ids=(struct segment_id_list *)session_control_segment_ids_get(&a_stream);
EXPECT_NE(nullptr, segment_ids);
EXPECT_EQ(1, segment_ids->sz_sidlist);
EXPECT_EQ(g_tsg_para.service_chaining_sid, segment_ids->sid_list[0]);
session_segment_id_free(&a_stream, 0, (void *)segment_ids);
session_control_segment_ids_async(&a_stream, NULL);
struct sce_log_update sce={8, {1,2,3,4,5,6,7,8}};
session_log_update_data_put(&a_stream, TSG_SERVICE_CHAINING, (void *)&sce);
struct TLD_handle_t *handle=TLD_create(0);
matched_policy[0].action=0;
matched_policy[0].rule_id=0;
matched_policy[0].service_id=0;
tsg_send_log(g_tsg_log_instance, handle, &a_stream, LOG_TYPE_SESSION_RECORD, &(matched_policy[0]), 1, 0);
int sendlog_cnt=rd_kafka_get_sendlog_cnt();
EXPECT_EQ(1, sendlog_cnt);
// session record
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"sce_profile_ids\":[1,2,3,4,5,6,7,8]}", rd_kafka_get_sendlog_payload(0));
session_log_update_data_put(&a_stream, TSG_SERVICE_CHAINING, NULL);
rd_kafka_clean_sendlog_cnt();
session_matched_rules_free(&a_stream, TSG_SERVICE_CHAINING, (void *)hited_s_chaining);
session_matched_rules_async(&a_stream, TSG_SERVICE_CHAINING, NULL);
EXPECT_EQ(nullptr, session_matched_rules_get(&a_stream, TSG_SERVICE_CHAINING));
hited_s_chaining=session_matched_rules_get(&a_stream, TSG_SERVICE_CHAINING);
EXPECT_EQ(nullptr, hited_s_chaining);
}
TEST(TSGMaster, ShapingPolicySendLog)
{
const struct streaminfo a_stream={0};
struct maat_rule matched_policy[MAX_RESULT_NUM]={0};
matched_policy[1].do_log=1;
matched_policy[1].action=TSG_ACTION_SHAPING;
matched_policy[1].rule_id=TSG_ACTION_SHAPING;
matched_policy[1].service_id=TSG_SERVICE_SHAPING;
// Set Intercept
matched_shaping_rules_deal(&a_stream, &matched_policy[1], 1, 0);
const struct matched_policy_rules *hited_shaping=session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING);
EXPECT_NE(nullptr, hited_shaping);
EXPECT_EQ(1, hited_shaping->n_rules);
EXPECT_EQ(TSG_ACTION_SHAPING, hited_shaping->rules[0].action);
EXPECT_EQ(TSG_ACTION_SHAPING, hited_shaping->rules[0].rule_id);
EXPECT_EQ(TSG_SERVICE_SHAPING, hited_shaping->rules[0].service_id);
struct segment_id_list *segment_ids=(struct segment_id_list *)session_control_segment_ids_get(&a_stream);
EXPECT_NE(nullptr, segment_ids);
EXPECT_EQ(1, segment_ids->sz_sidlist);
EXPECT_EQ(g_tsg_para.shaping_sid, segment_ids->sid_list[0]);
session_segment_id_free(&a_stream, 0, (void *)segment_ids);
session_control_segment_ids_async(&a_stream, NULL);
struct shaper_log_update shaping={1, {TSG_ACTION_SHAPING, 8, {1,2,3,4,5,6,7,8}}};
session_log_update_data_put(&a_stream, TSG_SERVICE_SHAPING, (void *)&shaping);
struct TLD_handle_t *handle=TLD_create(0);
matched_policy[0].action=0;
matched_policy[0].rule_id=0;
matched_policy[0].service_id=0;
tsg_send_log(g_tsg_log_instance, handle, &a_stream, LOG_TYPE_SESSION_RECORD, &(matched_policy[0]), 1, 0);
int sendlog_cnt=rd_kafka_get_sendlog_cnt();
EXPECT_EQ(1, sendlog_cnt);
// session record
EXPECT_STREQ("{\"common_app_full_path\":\"unknown\",\"common_app_label\":\"unknown\",\"common_server_port\":0,\"common_client_port\":0,\"common_stream_dir\":0,\"common_address_type\":0,\"common_con_duration_ms\":0,\"common_stream_trace_id\":\"5\",\"common_sled_ip\":\"0.0.0.0\",\"common_device_tag\":\"{\\\"tags\\\":[{\\\"tag\\\":\\\"device_id\\\",\\\"value\\\":\\\"device_1\\\"}]}\",\"common_t_vsys_id\":1,\"shaping_profile_ids\":[{\"rule_id\":32,\"profile_ids\":[1,2,3,4,5,6,7,8]}],\"common_shaping_rule_ids\":[32]}", rd_kafka_get_sendlog_payload(0));
session_log_update_data_put(&a_stream, TSG_SERVICE_SHAPING, NULL);
rd_kafka_clean_sendlog_cnt();
session_matched_rules_free(&a_stream, TSG_SERVICE_SHAPING, (void *)hited_shaping);
session_matched_rules_async(&a_stream, TSG_SERVICE_SHAPING, NULL);
EXPECT_EQ(nullptr, session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING));
hited_shaping=session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING);
EXPECT_EQ(nullptr, hited_shaping);
}
int main(int argc, char *argv[])
{
TSG_MASTER_INIT();

268
test/src/gtest_sendlog.cpp
View File

@@ -1,132 +1,136 @@
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "tsg_rule.h"
#include "gtest_common.h"
#include <gtest/gtest.h>
struct maat *g_tsg_maat_feather;
char *tsg_device_tag_get(void)
{
return NULL;
}
char *tsg_data_center_get(void)
{
return NULL;
}
int tsg_location_type_get(void)
{
return 0;
}
int tsg_session_record_switch_get(void)
{
return 0;
}
void *session_mac_linkinfo_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_gather_app_results_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_conn_sketch_notify_data_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_business_data_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_session_flags_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_application_behavior_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_mirrored_and_capture_packets_exec_result_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_lua_user_defined_attribute_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_nat_c2s_linkinfo_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_nat_s2c_linkinfo_get(const struct streaminfo * a_stream)
{
return NULL;
}
int session_matched_rules_async(const struct streaminfo * a_stream, TSG_SERVICE service, void * data)
{
return 0;
}
const struct matched_policy_rules *session_matched_rules_get(const struct streaminfo *a_stream, enum TSG_SERVICE service)
{
return 0;
}
void session_matched_rules_free(const struct streaminfo * a_stream, TSG_SERVICE service, void * data)
{
}
char srt_action_context_get_direction(const struct streaminfo * a_stream)
{
return 0;
}
int tsg_get_app_name_by_id(struct maat *feahter, int app_id, char * app_name, int app_name_len, int is_joint_parent)
{
return 0;
}
const struct session_runtime_attribute *session_runtime_attribute_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *matched_rule_cites_security_compile(struct maat * feather, long long compile_id)
{
return NULL;
}
void plugin_ex_data_security_compile_free(struct maat_compile * maat_compile)
{
}
TEST(MasterTest, SetVlan)
{
//int ret=set_vlan(NULL, NULL, NULL, 0, NULL, LOG_COMMON_TUNNELS_VLAN_SRC_ID);
//EXPECT_EQ(1, ret);
}
int main(int argc, char *argv[])
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "tsg_rule.h"
#include "gtest_common.h"
#include <gtest/gtest.h>
struct maat *g_tsg_maat_feather;
char *tsg_device_tag_get(void)
{
return NULL;
}
char *tsg_data_center_get(void)
{
return NULL;
}
int tsg_location_type_get(void)
{
return 0;
}
int tsg_session_record_switch_get(void)
{
return 0;
}
void *session_mac_linkinfo_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_log_update_data_get(const struct streaminfo *a_stream, enum TSG_SERVICE service)
{
return NULL;
}
void *session_gather_app_results_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_conn_sketch_notify_data_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_business_data_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_session_flags_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_application_behavior_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_mirrored_and_capture_packets_exec_result_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_lua_user_defined_attribute_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_nat_c2s_linkinfo_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *session_nat_s2c_linkinfo_get(const struct streaminfo * a_stream)
{
return NULL;
}
int session_matched_rules_async(const struct streaminfo * a_stream, TSG_SERVICE service, void * data)
{
return 0;
}
const struct matched_policy_rules *session_matched_rules_get(const struct streaminfo *a_stream, enum TSG_SERVICE service)
{
return 0;
}
void session_matched_rules_free(const struct streaminfo * a_stream, TSG_SERVICE service, void * data)
{
}
char srt_action_context_get_direction(const struct streaminfo * a_stream)
{
return 0;
}
int tsg_get_app_name_by_id(struct maat *feahter, int app_id, char * app_name, int app_name_len, int is_joint_parent)
{
return 0;
}
const struct session_runtime_attribute *session_runtime_attribute_get(const struct streaminfo * a_stream)
{
return NULL;
}
void *matched_rule_cites_security_compile(struct maat * feather, long long compile_id)
{
return NULL;
}
void plugin_ex_data_security_compile_free(struct maat_compile * maat_compile)
{
}
TEST(MasterTest, SetVlan)
{
//int ret=set_vlan(NULL, NULL, NULL, 0, NULL, LOG_COMMON_TUNNELS_VLAN_SRC_ID);
//EXPECT_EQ(1, ret);
}
int main(int argc, char *argv[])
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

692
test/src/gtest_sync_state.cpp
View File

@@ -19,6 +19,41 @@ unsigned long long tsg_get_stream_trace_id(const struct streaminfo *a_stream)
return 10;
}
void *session_log_update_data_get(const struct streaminfo *a_stream, enum TSG_SERVICE service)
{
switch (service)
{
case TSG_SERVICE_INTERCEPT:
return stream_bridge_async_data_get(a_stream, BRIDGE_TYPE_LOG_UPDATE_PROXY);
case TSG_SERVICE_CHAINING:
return stream_bridge_async_data_get(a_stream, BRIDGE_TYPE_LOG_UPDATE_SCE);
case TSG_SERVICE_SHAPING:
return stream_bridge_async_data_get(a_stream, BRIDGE_TYPE_LOG_UPDATE_SHAPER);
default:
return NULL;
}
}
int session_log_update_data_put(const struct streaminfo *a_stream, enum TSG_SERVICE service, void *data)
{
switch (service)
{
case TSG_SERVICE_INTERCEPT:
return stream_bridge_async_data_put(a_stream, BRIDGE_TYPE_LOG_UPDATE_PROXY, data);
case TSG_SERVICE_CHAINING:
return stream_bridge_async_data_put(a_stream, BRIDGE_TYPE_LOG_UPDATE_SCE, data);
case TSG_SERVICE_SHAPING:
return stream_bridge_async_data_put(a_stream, BRIDGE_TYPE_LOG_UPDATE_SHAPER, data);
default:
return 0;
}
}
TEST(SESSION_STATE, IllegalPara)
{
struct streaminfo a_stream = {0};
@@ -139,7 +174,6 @@ TEST(POLICY_UPDATE, Sce)
{
test.ids[i] = 100 + i;
}
tsg_sync_policy_update(&a_stream, &test, 1);
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, sizeof(ctrl_pkt_buf));
@@ -157,6 +191,35 @@ TEST(POLICY_UPDATE, Sce)
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(POLICY_UPDATE, SceOverLimitIds)
{
char ctrl_pkt_buf[1024] = {0};
int ctrl_pkt_len = 0;
struct streaminfo a_stream = {0};
struct update_policy test;
memset(&test, 0, sizeof(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;
}
test.n_ids += UPDATE_POLICY_RULE_IDS;
tsg_sync_policy_update(&a_stream, &test, 1);
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, sizeof(ctrl_pkt_buf));
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");
EXPECT_EQ(mpack_node_array_length(mpack_node_map_cstr(sce_map, "rule_ids")), UPDATE_POLICY_RULE_IDS);
EXPECT_EQ(0, mpack_node_i64(mpack_node_array_at(mpack_node_map_cstr(sce_map, "rule_ids"), 5)));
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(POLICY_UPDATE, Shaper)
{
char ctrl_pkt_buf[1024] = {0};
@@ -169,7 +232,6 @@ TEST(POLICY_UPDATE, Shaper)
{
test.ids[i] = 10000 + i;
}
tsg_sync_policy_update(&a_stream, &test, 1);
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, sizeof(ctrl_pkt_buf));
@@ -187,7 +249,36 @@ TEST(POLICY_UPDATE, Shaper)
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(SESSION_STATE, ActiveStateServiceChainingAndShaping0)
TEST(POLICY_UPDATE, ShaperOverLimitIds)
{
char ctrl_pkt_buf[1024] = {0};
int ctrl_pkt_len = 0;
struct streaminfo a_stream = {0};
struct update_policy test;
memset(&test, 0, sizeof(test));
test.type = POLICY_UPDATE_SHAPING;
test.n_ids = 6;
for (int i = 0; i < test.n_ids; i++)
{
test.ids[i] = 10000 + i;
}
test.n_ids += UPDATE_POLICY_RULE_IDS;
tsg_sync_policy_update(&a_stream, &test, 1);
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, sizeof(ctrl_pkt_buf));
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");
EXPECT_EQ(mpack_node_array_length(mpack_node_map_cstr(shaper_map, "rule_ids")), UPDATE_POLICY_RULE_IDS);
EXPECT_EQ(0, mpack_node_i64(mpack_node_array_at(mpack_node_map_cstr(shaper_map, "rule_ids"), 7)));
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(POLICY_UPDATE, ActiveStateServiceChainingAndShaping0)
{
struct streaminfo a_stream = {0};
struct update_policy policy_array[POLICY_UPDATE_MAX];
@@ -238,7 +329,7 @@ TEST(SESSION_STATE, ActiveStateServiceChainingAndShaping0)
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
}
TEST(SESSION_STATE, ActiveStateServiceChainingAndShaping1)
TEST(POLICY_UPDATE, ActiveStateServiceChainingAndShaping1)
{
struct streaminfo a_stream = {0};
struct update_policy policy_array[2];
@@ -349,10 +440,10 @@ static void gtest_cmsg_init(struct proxy_cmsg *cmsg)
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;
cmsg->fqdn_cat_ids.num = 4;
for (size_t i = 0; i < 4; i++)
{
cmsg->fqdn_cat_id_val.value[i] = i + 1;
cmsg->fqdn_cat_ids.value[i] = i + 1;
}
cmsg->tcp_seq_sids.num = 5;
@@ -408,6 +499,7 @@ TEST(POLICY_UPDATE, Proxy)
int ctrl_pkt_len = 0;
struct streaminfo a_stream = {0};
struct update_policy test;
memset(&test, 0, sizeof(test));
struct proxy_cmsg cmsg;
test.type = POLICY_UPDATE_INTERCEPT;
test.n_ids = 6;
@@ -464,20 +556,598 @@ TEST(POLICY_UPDATE, Proxy)
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")));
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
gtest_cmsg_destroy(&cmsg);
}
// // shaper
// EXPECT_EQ(mpack_type_nil, mpack_node_type(mpack_node_map_cstr(params, "shaper")));
TEST(POLICY_UPDATE, ProxyOverLimit)
{
char ctrl_pkt_buf[1024] = {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));
test.cmsg.fqdn_cat_ids.num += FQDN_CAT_ID_VALS;
test.cmsg.tcp_ack_sids.num += TCP_XXX_SIDS;
test.cmsg.tcp_seq_sids.num += TCP_XXX_SIDS;
test.cmsg.tcp_seq_route_ctx.num += TCP_XXX_ROUTE_CTX;
test.cmsg.tcp_ack_route_ctx.num += TCP_XXX_ROUTE_CTX;
tsg_sync_policy_update(&a_stream, &test, 1);
ctrl_pkt_len = get_ctrl_pkt(ctrl_pkt_buf, sizeof(ctrl_pkt_buf));
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");
mpack_node_t tcp_handshake = mpack_node_map_cstr(proxy_map, "tcp_handshake");
mpack_node_t fqdn_cat_id_vals = mpack_node_array_at(tcp_handshake, 31);
EXPECT_EQ(FQDN_CAT_ID_VALS, mpack_node_array_length(fqdn_cat_id_vals));
mpack_node_t tcp_seq_sids = mpack_node_array_at(tcp_handshake, 32);
EXPECT_EQ(TCP_XXX_SIDS, mpack_node_array_length(tcp_seq_sids));
mpack_node_t tcp_ack_sids = mpack_node_array_at(tcp_handshake, 33);
EXPECT_EQ(TCP_XXX_SIDS, mpack_node_array_length(tcp_ack_sids));
mpack_node_t tcp_seq_route_ctxs = mpack_node_array_at(tcp_handshake, 34);
EXPECT_EQ(TCP_XXX_ROUTE_CTX, mpack_node_array_length(tcp_seq_route_ctxs));
mpack_node_t tcp_ack_route_ctxs = mpack_node_array_at(tcp_handshake, 35);
EXPECT_EQ(TCP_XXX_ROUTE_CTX, mpack_node_array_length(tcp_ack_route_ctxs));
EXPECT_EQ(mpack_tree_destroy(&tree), mpack_ok);
gtest_cmsg_destroy(&cmsg);
}
void gtest_get_sce_mpack_date(char **mpack_data, size_t *mpack_size, uint64_t session_id, char *method, int n_ids)
{
mpack_writer_t writer;
mpack_writer_init_growable(&writer, mpack_data, mpack_size);
mpack_build_map(&writer);
// tsync : 2.0
mpack_write_cstr(&writer, "tsync");
mpack_write_cstr(&writer, "2.0");
// session_id
mpack_write_cstr(&writer, "session_id");
mpack_write_u64(&writer, session_id);
// state
mpack_write_cstr(&writer, "state");
mpack_write_cstr(&writer, "active");
// method: log_update
mpack_write_cstr(&writer, "method");
mpack_write_cstr(&writer, method);
// params
mpack_write_cstr(&writer, "params");
mpack_build_map(&writer);
{
mpack_write_cstr(&writer, "sce");
mpack_build_map(&writer);
{
mpack_write_cstr(&writer, "sf_profile_ids");
if (n_ids == 0)
{
mpack_write_nil(&writer);
}
else
{
mpack_build_array(&writer);
for (int i = 0; i < n_ids; i++)
{
mpack_write_u32(&writer, i + 1);
}
mpack_complete_array(&writer);
}
}
mpack_complete_map(&writer);
}
mpack_complete_map(&writer);
mpack_complete_map(&writer);
// printf("mpack_size = %lu\n", (unsigned long)mpack_size);
// for (int i = 0; i < mpack_size; i++)
// {
// printf("%x ", mpack_data[i]);
// }
EXPECT_EQ(mpack_writer_destroy(&writer), mpack_ok);
}
TEST(LOG_UPDATE, SceIllegalLog)
{
char *mpack_data = NULL;
size_t mpack_size = 0;
const struct streaminfo a_stream = {0};
// error session
gtest_get_sce_mpack_date(&mpack_data, &mpack_size, 123456789, (char *)"log_update", 3);
EXPECT_EQ(-1, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result = session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING);
EXPECT_FALSE(result);
free(mpack_data);
mpack_data = NULL;
mpack_size = 0;
// error method
gtest_get_sce_mpack_date(&mpack_data, &mpack_size, 10, (char *)"policy_update", 3);
EXPECT_EQ(-1, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
result = session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING);
EXPECT_FALSE(result);
free(mpack_data);
mpack_data = NULL;
mpack_size = 0;
// n_profile_ids = 0
gtest_get_sce_mpack_date(&mpack_data, &mpack_size, 10, (char *)"log_update", 0);
EXPECT_EQ(-1, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
result = session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING);
EXPECT_FALSE(result);
free(mpack_data);
mpack_data = NULL;
mpack_size = 0;
}
TEST(LOG_UPDATE, SceNormal)
{
char *mpack_data = NULL;
size_t mpack_size = 0;
const struct streaminfo a_stream = {0};
gtest_get_sce_mpack_date(&mpack_data, &mpack_size, 10, (char *)"log_update", 3);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result = session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING);
EXPECT_TRUE(result);
struct sce_log_update *sce = (struct sce_log_update *)result;
EXPECT_EQ(3, sce->n_profile_ids);
for (int i = 0; i < (int)sce->n_profile_ids; i++)
{
EXPECT_EQ(i + 1, sce->profile_ids[i]);
}
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_INTERCEPT));
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_SHAPING));
free(result);
result = NULL;
session_log_update_data_put(&a_stream, TSG_SERVICE_CHAINING, NULL);
free(mpack_data);
mpack_data = NULL;
}
TEST(LOG_UPDATE, SceTwice)
{
char *mpack_data = NULL;
size_t mpack_size = 0;
const struct streaminfo a_stream = {0};
gtest_get_sce_mpack_date(&mpack_data, &mpack_size, 10, (char *)"log_update", 3);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result = session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING);
EXPECT_TRUE(result);
free(mpack_data);
mpack_data = NULL;
mpack_size = 0;
gtest_get_sce_mpack_date(&mpack_data, &mpack_size, 10, (char *)"log_update", 5);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result_2 = session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING);
EXPECT_EQ(result_2, result);
struct sce_log_update *sce = (struct sce_log_update *)result_2;
EXPECT_EQ(5, sce->n_profile_ids);
for (int i = 0; i < (int)sce->n_profile_ids; i++)
{
EXPECT_EQ(i + 1, sce->profile_ids[i]);
}
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_INTERCEPT));
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_SHAPING));
free(result);
result = NULL;
session_log_update_data_put(&a_stream, TSG_SERVICE_CHAINING, NULL);
free(mpack_data);
mpack_data = NULL;
}
TEST(LOG_UPDATE, SceOverLimitProfileIds)
{
char *mpack_data = NULL;
size_t mpack_size = 0;
const struct streaminfo a_stream = {0};
gtest_get_sce_mpack_date(&mpack_data, &mpack_size, 10, (char *)"log_update", 3 + SCE_PROFILE_IDS);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result = session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING);
EXPECT_TRUE(result);
struct sce_log_update *sce = (struct sce_log_update *)result;
EXPECT_EQ(SCE_PROFILE_IDS, sce->n_profile_ids);
for (int i = 0; i < (int)sce->n_profile_ids; i++)
{
EXPECT_EQ(i + 1, sce->profile_ids[i]);
}
free(result);
result = NULL;
session_log_update_data_put(&a_stream, TSG_SERVICE_CHAINING, NULL);
free(mpack_data);
mpack_data = NULL;
}
void gtest_get_shaper_mpack_date(char **mpack_data, size_t *mpack_size, uint64_t session_id, int n_sh_profile_ids, long long *rules, int n_profile_ids)
{
mpack_writer_t writer;
mpack_writer_init_growable(&writer, mpack_data, mpack_size);
mpack_build_map(&writer);
// tsync : 2.0
mpack_write_cstr(&writer, "tsync");
mpack_write_cstr(&writer, "2.0");
// session_id
mpack_write_cstr(&writer, "session_id");
mpack_write_u64(&writer, session_id);
// state
mpack_write_cstr(&writer, "state");
mpack_write_cstr(&writer, "active");
// method: log_update
mpack_write_cstr(&writer, "method");
mpack_write_cstr(&writer, "log_update");
// params
mpack_write_cstr(&writer, "params");
mpack_build_map(&writer);
{
mpack_write_cstr(&writer, "shaper");
mpack_build_array(&writer);
for (int i = 0; i < n_sh_profile_ids; i++)
{
mpack_build_map(&writer);
{
mpack_write_cstr(&writer, "rule_id");
mpack_write_i64(&writer, rules[i]);
mpack_write_cstr(&writer, "profile_ids");
mpack_build_array(&writer);
for (int j = 0; j < n_profile_ids; j++)
{
mpack_write_u32(&writer, j + 1);
}
mpack_complete_array(&writer);
}
mpack_complete_map(&writer);
}
mpack_complete_array(&writer);
}
mpack_complete_map(&writer);
mpack_complete_map(&writer);
// printf("mpack_size = %lu\n", (unsigned long)mpack_size);
// for (int i = 0; i < mpack_size; i++)
// {
// printf("%x ", mpack_data[i]);
// }
EXPECT_EQ(mpack_writer_destroy(&writer), mpack_ok);
}
TEST(LOG_UPDATE, ShaperNormal)
{
char *mpack_data = NULL;
size_t mpack_size = 0;
const struct streaminfo a_stream = {0};
long long rule[4] = {2, 3, 4, 5};
gtest_get_shaper_mpack_date(&mpack_data, &mpack_size, 10, 4, rule, 3);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result = session_log_update_data_get(&a_stream, TSG_SERVICE_SHAPING);
EXPECT_TRUE(result);
struct shaper_log_update *shaper = (struct shaper_log_update *)result;
for (int i = 0; i < (int)shaper->n_shaper_rule; i++)
{
EXPECT_EQ(i + 2, shaper->shaper_rules[i].rule_id);
EXPECT_EQ(3, shaper->shaper_rules[i].n_profile_ids);
for (int j = 0; j < (int)shaper->shaper_rules[i].n_profile_ids; j++)
{
EXPECT_EQ(j + 1, shaper->shaper_rules[i].profile_ids[j]);
}
}
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_INTERCEPT));
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING));
free(result);
result = NULL;
session_log_update_data_put(&a_stream, TSG_SERVICE_SHAPING, NULL);
free(mpack_data);
mpack_data = NULL;
}
TEST(LOG_UPDATE, ShaperTwice)
{
char *mpack_data = NULL;
size_t mpack_size = 0;
const struct streaminfo a_stream = {0};
long long rule[4] = {2, 3, 4, 5};
gtest_get_shaper_mpack_date(&mpack_data, &mpack_size, 10, 4, rule, 3);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result = session_log_update_data_get(&a_stream, TSG_SERVICE_SHAPING);
EXPECT_TRUE(result);
free(mpack_data);
mpack_data = NULL;
mpack_size = 0;
gtest_get_shaper_mpack_date(&mpack_data, &mpack_size, 10, 3, rule, 4);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result_2 = session_log_update_data_get(&a_stream, TSG_SERVICE_SHAPING);
EXPECT_EQ(result_2, result);
struct shaper_log_update *shaper = (struct shaper_log_update *)result;
EXPECT_EQ(3, shaper->n_shaper_rule);
for (int i = 0; i < (int)shaper->n_shaper_rule; i++)
{
EXPECT_EQ(i + 2, shaper->shaper_rules[i].rule_id);
EXPECT_EQ(4, shaper->shaper_rules[i].n_profile_ids);
for (int j = 0; j < (int)shaper->shaper_rules[i].n_profile_ids; j++)
{
EXPECT_EQ(j + 1, shaper->shaper_rules[i].profile_ids[j]);
}
}
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_INTERCEPT));
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING));
free(result);
result = NULL;
session_log_update_data_put(&a_stream, TSG_SERVICE_SHAPING, NULL);
free(mpack_data);
mpack_data = NULL;
}
TEST(LOG_UPDATE, ShaperOverLimitProfileIds)
{
char *mpack_data = NULL;
size_t mpack_size = 0;
const struct streaminfo a_stream = {0};
long long rule[4 + SHAPR_RULE_IDS] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
gtest_get_shaper_mpack_date(&mpack_data, &mpack_size, 10, 4 + SHAPR_RULE_IDS, rule, 3 + SHAPR_PROFILE_IDS);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result = session_log_update_data_get(&a_stream, TSG_SERVICE_SHAPING);
EXPECT_TRUE(result);
struct shaper_log_update *shaper = (struct shaper_log_update *)result;
EXPECT_EQ(shaper->n_shaper_rule, SHAPR_RULE_IDS);
for (int i = 0; i < (int)shaper->n_shaper_rule; i++)
{
EXPECT_EQ(i + 2, shaper->shaper_rules[i].rule_id);
EXPECT_EQ(SHAPR_PROFILE_IDS, shaper->shaper_rules[i].n_profile_ids);
for (int j = 0; j < (int)shaper->shaper_rules[i].n_profile_ids; j++)
{
EXPECT_EQ(j + 1, shaper->shaper_rules[i].profile_ids[j]);
}
}
free(result);
result = NULL;
session_log_update_data_put(&a_stream, TSG_SERVICE_SHAPING, NULL);
free(mpack_data);
mpack_data = NULL;
}
// if flag = 0 nil flag = 1 array flag = 2 ssl_upstream_version = thisisssl_upstream_version_for_test_twice
void gtest_get_proxy_mpack_date(char **mpack_data, size_t *mpack_size, uint64_t session_id, int flag)
{
mpack_writer_t writer;
mpack_writer_init_growable(&writer, mpack_data, mpack_size);
mpack_build_map(&writer);
// tsync : 2.0
mpack_write_cstr(&writer, "tsync");
mpack_write_cstr(&writer, "2.0");
// session_id
mpack_write_cstr(&writer, "session_id");
mpack_write_u64(&writer, session_id);
// state
mpack_write_cstr(&writer, "state");
mpack_write_cstr(&writer, "active");
// method: log_update
mpack_write_cstr(&writer, "method");
mpack_write_cstr(&writer, "log_update");
// params
mpack_write_cstr(&writer, "params");
mpack_build_map(&writer);
{
mpack_write_cstr(&writer, "proxy");
mpack_build_map(&writer);
mpack_write_cstr(&writer, "ssl_intercept_info");
{
if (flag == 0)
{
mpack_write_nil(&writer);
}
else
{
mpack_build_array(&writer);
{
mpack_write_u8(&writer, 1);
mpack_write_u64(&writer, 2);
mpack_write_u64(&writer, 3);
if (flag == 2)
{
mpack_write_cstr(&writer, "thisisssl_upstream_version_for_test_twice");
mpack_write_cstr(&writer, "thisisssl_downstream_version_for_test_twice");
mpack_write_u8(&writer, 7);
}
else
{
mpack_write_cstr(&writer, "thisisssl_upstream_version");
mpack_write_cstr(&writer, "thisisssl_downstream_version");
mpack_write_u8(&writer, 4);
}
mpack_write_u8(&writer, 5);
mpack_write_cstr(&writer, "thisisssl_error");
mpack_write_cstr(&writer, "thisisssl_passthrough_reason");
}
mpack_complete_array(&writer);
}
}
mpack_complete_map(&writer);
}
mpack_complete_map(&writer);
mpack_complete_map(&writer);
// printf("mpack_size = %lu\n", (unsigned long)mpack_size);
// for (int i = 0; i < mpack_size; i++)
// {
// printf("%x ", mpack_data[i]);
// }
EXPECT_EQ(mpack_writer_destroy(&writer), mpack_ok);
}
TEST(LOG_UPDATE, ProxyIllegalLog)
{
char *mpack_data = NULL;
size_t mpack_size = 0;
const struct streaminfo a_stream = {0};
gtest_get_proxy_mpack_date(&mpack_data, &mpack_size, 10, 0);
EXPECT_EQ(-1, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result = session_log_update_data_get(&a_stream, TSG_SERVICE_INTERCEPT);
EXPECT_FALSE(result);
free(mpack_data);
mpack_data = NULL;
}
TEST(LOG_UPDATE, ProxyNormal)
{
char *mpack_data = NULL;
size_t mpack_size = 0;
const struct streaminfo a_stream = {0};
gtest_get_proxy_mpack_date(&mpack_data, &mpack_size, 10, 1);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result = session_log_update_data_get(&a_stream, TSG_SERVICE_INTERCEPT);
EXPECT_TRUE(result);
struct proxy_log_update *proxy = (struct proxy_log_update *)result;
EXPECT_EQ(1, proxy->ssl_intercept_state);
EXPECT_EQ(2, proxy->ssl_upstream_latency);
EXPECT_EQ(3, proxy->ssl_downstream_latency);
EXPECT_STREQ("thisisssl_upstream_version", proxy->ssl_upstream_version);
EXPECT_STREQ("thisisssl_downstream_version", proxy->ssl_downstream_version);
EXPECT_EQ(4, proxy->ssl_pinning_state);
EXPECT_EQ(5, proxy->ssl_cert_verify);
EXPECT_STREQ("thisisssl_error", proxy->ssl_error);
EXPECT_STREQ("thisisssl_passthrough_reason", proxy->ssl_passthrough_reason);
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING));
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_SHAPING));
free(proxy->ssl_downstream_version);
free(proxy->ssl_error);
free(proxy->ssl_passthrough_reason);
free(proxy->ssl_upstream_version);
free(result);
result = NULL;
session_log_update_data_put(&a_stream, TSG_SERVICE_INTERCEPT, NULL);
free(mpack_data);
mpack_data = NULL;
}
TEST(LOG_UPDATE, ProxyTwice)
{
char *mpack_data = NULL;
size_t mpack_size = 0;
const struct streaminfo a_stream = {0};
gtest_get_proxy_mpack_date(&mpack_data, &mpack_size, 10, 1);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result = session_log_update_data_get(&a_stream, TSG_SERVICE_INTERCEPT);
EXPECT_TRUE(result);
free(mpack_data);
mpack_data = NULL;
mpack_size = 0;
struct proxy_log_update *proxy = (struct proxy_log_update *)result;
char *ssl_upstream_version = proxy->ssl_upstream_version;
char *ssl_downstream_version = proxy->ssl_upstream_version;
EXPECT_STREQ("thisisssl_upstream_version", proxy->ssl_upstream_version);
EXPECT_STREQ("thisisssl_downstream_version", proxy->ssl_downstream_version);
EXPECT_EQ(4, proxy->ssl_pinning_state);
// second
gtest_get_proxy_mpack_date(&mpack_data, &mpack_size, 10, 2);
EXPECT_EQ(0, tsg_parse_log_update_payload(&a_stream, mpack_data, mpack_size));
void *result_2 = session_log_update_data_get(&a_stream, TSG_SERVICE_INTERCEPT);
EXPECT_EQ(result_2, result);
proxy = (struct proxy_log_update *)result_2;
char *ssl_upstream_version_2 = proxy->ssl_upstream_version;
char *ssl_downstream_version_2 = proxy->ssl_upstream_version;
EXPECT_NE(ssl_upstream_version_2, ssl_upstream_version);
EXPECT_NE(ssl_downstream_version_2, ssl_downstream_version);
EXPECT_STREQ("thisisssl_upstream_version_for_test_twice", proxy->ssl_upstream_version);
EXPECT_STREQ("thisisssl_downstream_version_for_test_twice", proxy->ssl_downstream_version);
EXPECT_EQ(7, proxy->ssl_pinning_state);
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_CHAINING));
EXPECT_FALSE(session_log_update_data_get(&a_stream, TSG_SERVICE_SHAPING));
free(proxy->ssl_downstream_version);
free(proxy->ssl_error);
free(proxy->ssl_passthrough_reason);
free(proxy->ssl_upstream_version);
free(result);
result = NULL;
session_log_update_data_put(&a_stream, TSG_SERVICE_INTERCEPT, NULL);
free(mpack_data);
mpack_data = NULL;
}
int main(int argc, char *argv[])
{
g_tsg_para.logger = MESA_create_runtime_log_handle("log/tsg_sync_state", 10);
// tsg_bridge_init("tsgconf/main.conf");
testing::InitGoogleTest(&argc, argv);
int ret = RUN_ALL_TESTS();
MESA_destroy_runtime_log_handle(g_tsg_para.logger);