TSG-13778 TSG master支持MAAT4

1 files changed, 406 insertions, 236 deletions

diff --git a/test/src/gtest_master.cpp b/test/src/gtest_master.cpp
index e5b5289..7da2057 100644
--- a/test/src/gtest_master.cpp
+++ b/test/src/gtest_master.cpp
@@ -3,41 +3,46 @@
 #include <unistd.h>
 
 #include "gtest_common.h"
-#include "tsg_rule.h"
 #include "tsg_entry.h"
+#include "tsg_rule_internal.h"
 #include <gtest/gtest.h>
 
 extern int rd_kafka_get_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);;
+
+extern void session_segment_id_free(const struct streaminfo * a_stream, int bridge_id, void * data);
+
 
 TEST(TSGMaster, SetAPPIDHttp)
 {
-	struct streaminfo a_stream={0};
-	struct gather_app_result gather_result[ORIGIN_MAX]={0};
+	const struct streaminfo a_stream={0};
+	struct gather_app_result async_gather_result[ORIGIN_MAX]={0};
 
-	gather_result[ORIGIN_BASIC_PROTOCOL].app_num=1;
-	gather_result[ORIGIN_BASIC_PROTOCOL].origin=ORIGIN_BASIC_PROTOCOL;
-	gather_result[ORIGIN_BASIC_PROTOCOL].attributes[0].app_id=67;	//HTTP
+	async_gather_result[ORIGIN_BASIC_PROTOCOL].app_num=1;
+	async_gather_result[ORIGIN_BASIC_PROTOCOL].origin=ORIGIN_BASIC_PROTOCOL;
+	async_gather_result[ORIGIN_BASIC_PROTOCOL].attributes[0].app_id=67;	//HTTP
 	
-	tsg_set_xxx_to_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_GATHER_APP_RESULT].id, (void *)gather_result);
-	struct gather_app_result *get_result=(struct gather_app_result *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_GATHER_APP_RESULT].id);
-	EXPECT_NE(nullptr, get_result);
-	EXPECT_EQ(1, get_result[ORIGIN_BASIC_PROTOCOL].app_num);
-	EXPECT_EQ(67, get_result[ORIGIN_BASIC_PROTOCOL].attributes[0].app_id);
-	EXPECT_EQ(0, get_result[ORIGIN_BASIC_PROTOCOL].attributes[0].packet_sequence);
-	EXPECT_EQ(0, get_result[ORIGIN_BASIC_PROTOCOL].attributes[0].surrogate_id);
-	EXPECT_EQ(ORIGIN_BASIC_PROTOCOL, get_result[ORIGIN_BASIC_PROTOCOL].origin);
+	session_gather_app_results_async(&a_stream, (void *)async_gather_result);
+	struct gather_app_result *gather_result=(struct gather_app_result *)session_gather_app_results_get(&a_stream);
+	EXPECT_NE(nullptr, gather_result);
+	EXPECT_EQ(1, gather_result[ORIGIN_BASIC_PROTOCOL].app_num);
+	EXPECT_EQ(67, gather_result[ORIGIN_BASIC_PROTOCOL].attributes[0].app_id);
+	EXPECT_EQ(0, gather_result[ORIGIN_BASIC_PROTOCOL].attributes[0].packet_sequence);
+	EXPECT_EQ(0, gather_result[ORIGIN_BASIC_PROTOCOL].attributes[0].surrogate_id);
+	EXPECT_EQ(ORIGIN_BASIC_PROTOCOL, gather_result[ORIGIN_BASIC_PROTOCOL].origin);
 
 	struct TLD_handle_t *handle=TLD_create(0);
 	set_app_id(g_tsg_log_instance, handle, (struct streaminfo *)&a_stream);
 	char app_ids[256]={0};
 	TLD_convert_json(handle, app_ids, sizeof(app_ids));
-	EXPECT_STREQ("{\"common_app_full_path\":\"http\",\"common_app_label\":\"http\"}", app_ids);
+	EXPECT_STREQ("{\"common_app_full_path\":\"http\",\"common_app_label\":\"http\",\"common_app_id\":{\"LPI_L7\":[{\"app_name\":\"http\",\"app_id\":67,\"surrogate_id\":0,\"packet_sequence\":0}]}}", app_ids);
 
 	
-	tsg_set_xxx_to_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_GATHER_APP_RESULT].id, NULL);
-	get_result=(struct gather_app_result *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_GATHER_APP_RESULT].id);
-	EXPECT_EQ(nullptr, get_result);
+	session_gather_app_results_async(&a_stream, NULL);
+	gather_result=(struct gather_app_result *)session_gather_app_results_get(&a_stream);
+	EXPECT_EQ(nullptr, gather_result);
 }
 
 TEST(TSGMaster, SetAPPIDUnknown)
@@ -55,45 +60,53 @@ TEST(TSGMaster, SetAPPIDUnknown)
 TEST(TSGMaster, ShapingSetRuleIds)
 {
 	const struct streaminfo a_stream={0};
-	struct Maat_rule_t shaping_result[MAX_RESULT_NUM]={0};
+	struct maat_rule shaping_result[MAX_RESULT_NUM]={0};
 
 	for(int i=0; i<MAX_RESULT_NUM; i++)
 	{
 		shaping_result[i].action=TSG_ACTION_SHAPING;
-		shaping_result[i].config_id=TSG_ACTION_SHAPING+i;
+		shaping_result[i].rule_id=TSG_ACTION_SHAPING+i;
 	}
 	
-	tsg_notify_hited_shaping_result(&a_stream, shaping_result, MAX_RESULT_NUM, 0);
+	matched_shaping_rules_deal(&a_stream, shaping_result, MAX_RESULT_NUM, 0);
 
 	struct TLD_handle_t *handle=TLD_create(0);
-	set_shaping_rule_ids(g_tsg_log_instance, handle, (struct streaminfo *)&a_stream);
+	set_shaping_rule_ids(g_tsg_log_instance, handle, &a_stream);
 	char shaping_rule_ids[256]={0};
 	TLD_convert_json(handle, shaping_rule_ids, sizeof(shaping_rule_ids));
 	EXPECT_STREQ("{\"common_shaping_rule_ids\":[32,33,34,35,36,37,38,39]}", shaping_rule_ids);
 
-	struct notify_shaping_policy *shaping_label=(struct notify_shaping_policy *)stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id);
-	EXPECT_NE(nullptr, shaping_label);
-	EXPECT_EQ(MAX_RESULT_NUM, shaping_label->shaping_result_num);
-	for(int i=0; i<shaping_label->shaping_result_num; i++)
+	const struct matched_policy_rules *hited_shaping=session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING);
+	EXPECT_NE(nullptr, hited_shaping);
+	EXPECT_EQ(MAX_RESULT_NUM, hited_shaping->n_rules);
+	for(size_t i=0; i<hited_shaping->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_label->shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_label->shaping_result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_SHAPING, hited_shaping->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_SHAPING+i, hited_shaping->rules[i].rule_id);
 	}
-	
-	free_shaping_result(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, (void *)shaping_label);
-	stream_bridge_async_data_put(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, NULL);
-	EXPECT_EQ(nullptr, stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].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);
+
+	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));
 }
 
 int shaping_policy_notify_cb(const struct streaminfo *stream, int bridge_id, void *data)
 {
-	struct notify_shaping_policy *shaping_label=(struct notify_shaping_policy *)data;
-	EXPECT_NE(nullptr, shaping_label);
-	EXPECT_EQ(MAX_RESULT_NUM, shaping_label->shaping_result_num);
-	for(int i=0; i<shaping_label->shaping_result_num; i++)
+	struct matched_policy_rules *hited_shaping=(struct matched_policy_rules *)data;
+	EXPECT_NE(nullptr, hited_shaping);
+	EXPECT_EQ(MAX_RESULT_NUM, hited_shaping->n_rules);
+	for(size_t i=0; i<hited_shaping->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_label->shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_label->shaping_result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_SHAPING, hited_shaping->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_SHAPING+i, hited_shaping->rules[i].rule_id);
 	}
 	
 	return 0;
@@ -102,37 +115,38 @@ int shaping_policy_notify_cb(const struct streaminfo *stream, int bridge_id, voi
 TEST(TSGMaster, ShapingPolicyNotify)
 {
 	const struct streaminfo a_stream={0};
-	struct Maat_rule_t shaping_result[MAX_RESULT_NUM]={0};
+	struct maat_rule shaping_result[MAX_RESULT_NUM]={0};
 
 	for(int i=0; i<MAX_RESULT_NUM; i++)
 	{
 		shaping_result[i].action=TSG_ACTION_SHAPING;
-		shaping_result[i].config_id=TSG_ACTION_SHAPING+i;
+		shaping_result[i].rule_id=TSG_ACTION_SHAPING+i;
 	}
 
-	stream_bridge_register_data_sync_cb(g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, shaping_policy_notify_cb);
+	stream_bridge_register_data_sync_cb(stream_bridge_build("NOTIFY_SHAPING_RESULT", "w"), shaping_policy_notify_cb);
 	
-	tsg_notify_hited_shaping_result(&a_stream, shaping_result, MAX_RESULT_NUM, 0);
-	int shaping_result_num=tsg_pull_shaping_result((struct streaminfo *)&a_stream, shaping_result, MAX_RESULT_NUM);
-	EXPECT_EQ(MAX_RESULT_NUM, shaping_result_num);
-	for(int i=0; i<shaping_result_num; i++)
-	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_result[i].config_id);
-	}
-	
-	struct notify_shaping_policy *shaping_label=(struct notify_shaping_policy *)stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id);
-	EXPECT_NE(nullptr, shaping_label);
-	EXPECT_EQ(MAX_RESULT_NUM, shaping_label->shaping_result_num);
-	for(int i=0; i<shaping_label->shaping_result_num; i++)
+	matched_shaping_rules_deal(&a_stream, shaping_result, MAX_RESULT_NUM, 0);
+
+	const struct matched_policy_rules *hited_shaping=session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING);
+	EXPECT_NE(nullptr, hited_shaping);
+	EXPECT_EQ(MAX_RESULT_NUM, hited_shaping->n_rules);
+	for(size_t i=0; i<hited_shaping->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_label->shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_label->shaping_result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_SHAPING, hited_shaping->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_SHAPING+i, hited_shaping->rules[i].rule_id);
 	}
 
-	free_shaping_result(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, (void *)shaping_label);
-	stream_bridge_async_data_put(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, NULL);
-	EXPECT_EQ(nullptr, stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].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);
+
+	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));
 }
 
 int shaping_policy_notify_null_cb(const struct streaminfo *stream, int bridge_id, void *data)
@@ -144,24 +158,24 @@ int shaping_policy_notify_null_cb(const struct streaminfo *stream, int bridge_id
 TEST(TSGMaster, ShapingPolicyNotifyNULL)
 {
 	const struct streaminfo a_stream={0};
-	struct Maat_rule_t shaping_result[MAX_RESULT_NUM]={0};
+	struct maat_rule shaping_result[MAX_RESULT_NUM]={0};
 
-	stream_bridge_register_data_sync_cb(g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, shaping_policy_notify_null_cb);
+	stream_bridge_register_data_sync_cb(stream_bridge_build("NOTIFY_SHAPING_RESULT", "w"), shaping_policy_notify_cb);
 	
-	tsg_notify_hited_shaping_result(&a_stream, shaping_result, 0, 0);
-	struct notify_shaping_policy *shaping_label=(struct notify_shaping_policy *)stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id);
-	EXPECT_EQ(nullptr, shaping_label);
+	matched_shaping_rules_deal(&a_stream, shaping_result, 0, 0);
+	const struct matched_policy_rules *hited_shaping=session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING);
+	EXPECT_EQ(nullptr, hited_shaping);
 }
 
 int shaping_duplicate_policy_notify_cb(const struct streaminfo *stream, int bridge_id, void *data)
 {
-	struct notify_shaping_policy *shaping_label=(struct notify_shaping_policy *)data;
-	EXPECT_NE(nullptr, shaping_label);
-	EXPECT_EQ(MAX_RESULT_NUM/2, shaping_label->shaping_result_num);
-	for(int i=0; i<shaping_label->shaping_result_num; i++)
+	struct matched_policy_rules *hited_shaping=(struct matched_policy_rules *)data;
+	EXPECT_NE(nullptr, hited_shaping);
+	EXPECT_EQ(MAX_RESULT_NUM/2, hited_shaping->n_rules);
+	for(size_t i=0; i<hited_shaping->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_label->shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_label->shaping_result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_SHAPING, hited_shaping->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_SHAPING+i, hited_shaping->rules[i].rule_id);
 	}
 
 	return 0;
@@ -170,126 +184,120 @@ int shaping_duplicate_policy_notify_cb(const struct streaminfo *stream, int brid
 TEST(TSGMaster, ShapingDuplicatePolicyNotify)
 {
 	const struct streaminfo a_stream={0};
-	struct Maat_rule_t shaping_result[MAX_RESULT_NUM]={0};
+	struct maat_rule shaping_result[MAX_RESULT_NUM]={0};
 
 	for(int i=0; i<MAX_RESULT_NUM; i++)
 	{
 		shaping_result[i].action=TSG_ACTION_SHAPING;
-		shaping_result[i].config_id=TSG_ACTION_SHAPING+(i%4);
+		shaping_result[i].rule_id=TSG_ACTION_SHAPING+(i%4);
 	}
 
-	stream_bridge_register_data_sync_cb(g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, shaping_duplicate_policy_notify_cb);
+	stream_bridge_register_data_sync_cb(stream_bridge_build("NOTIFY_SHAPING_RESULT", "w"), shaping_policy_notify_cb);
 	
-	tsg_notify_hited_shaping_result(&a_stream, shaping_result, MAX_RESULT_NUM, 0);
-	int shaping_result_num=tsg_pull_shaping_result((struct streaminfo *)&a_stream, shaping_result, MAX_RESULT_NUM);
-	EXPECT_EQ(MAX_RESULT_NUM/2, shaping_result_num);
-	for(int i=0; i<shaping_result_num; i++)
-	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_result[i].config_id);
-	}
+	matched_shaping_rules_deal(&a_stream, shaping_result, MAX_RESULT_NUM, 0);
 	
-	struct notify_shaping_policy *shaping_label=(struct notify_shaping_policy *)stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id);
-	EXPECT_NE(nullptr, shaping_label);
-	EXPECT_EQ(MAX_RESULT_NUM/2, shaping_label->shaping_result_num);
-	for(int i=0; i<shaping_label->shaping_result_num; i++)
+	const struct matched_policy_rules *hited_shaping=session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING);
+	EXPECT_NE(nullptr, hited_shaping);
+	EXPECT_EQ(MAX_RESULT_NUM/2, hited_shaping->n_rules);
+	for(size_t i=0; i<hited_shaping->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_label->shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_label->shaping_result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_SHAPING, hited_shaping->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_SHAPING+i, hited_shaping->rules[i].rule_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]);
 
-	free_shaping_result(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, (void *)shaping_label);
-	stream_bridge_async_data_put(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, NULL);
-	EXPECT_EQ(nullptr, stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id));
+	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_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));
 }
 
 TEST(TSGMaster, ShapingDuplicatePolicyMultipleNotify)
 {
 	const struct streaminfo a_stream={0};
-	struct Maat_rule_t shaping_result[MAX_RESULT_NUM]={0};
+	struct maat_rule shaping_result[MAX_RESULT_NUM]={0};
 
 	for(int i=0; i<MAX_RESULT_NUM/2; i++)
 	{
 		shaping_result[i].action=TSG_ACTION_SHAPING;
-		shaping_result[i].config_id=TSG_ACTION_SHAPING+i;
+		shaping_result[i].rule_id=TSG_ACTION_SHAPING+i;
 	}
 
-	stream_bridge_register_data_sync_cb(g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, shaping_duplicate_policy_notify_cb);
+	stream_bridge_register_data_sync_cb(stream_bridge_build("NOTIFY_SHAPING_RESULT", "w"), shaping_policy_notify_cb);
 
 	// First notify
-	tsg_notify_hited_shaping_result(&a_stream, shaping_result, MAX_RESULT_NUM/2, 0);
-	int shaping_result_num=tsg_pull_shaping_result((struct streaminfo *)&a_stream, shaping_result, MAX_RESULT_NUM);
-	EXPECT_EQ(MAX_RESULT_NUM/2, shaping_result_num);
-	for(int i=0; i<shaping_result_num; i++)
-	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_result[i].config_id);
-	}
+	matched_shaping_rules_deal(&a_stream, shaping_result, MAX_RESULT_NUM/2, 0);
 	
-	struct notify_shaping_policy *shaping_label=(struct notify_shaping_policy *)stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id);
-	EXPECT_NE(nullptr, shaping_label);
-	EXPECT_EQ(MAX_RESULT_NUM/2, shaping_label->shaping_result_num);
-	for(int i=0; i<shaping_label->shaping_result_num; i++)
+	const struct matched_policy_rules *hited_shaping=session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING);
+	EXPECT_NE(nullptr, hited_shaping);
+	EXPECT_EQ(MAX_RESULT_NUM/2, hited_shaping->n_rules);
+	for(size_t i=0; i<hited_shaping->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_label->shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_label->shaping_result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_SHAPING, hited_shaping->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_SHAPING+i, hited_shaping->rules[i].rule_id);
 	}
 
 	// Second notify
-	tsg_notify_hited_shaping_result(&a_stream, shaping_result, MAX_RESULT_NUM/2, 0);
-	shaping_result_num=tsg_pull_shaping_result((struct streaminfo *)&a_stream, shaping_result, MAX_RESULT_NUM);
-	EXPECT_EQ(MAX_RESULT_NUM/2, shaping_result_num);
-	for(int i=0; i<shaping_result_num; i++)
-	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_result[i].config_id);
-	}
-	
-	shaping_label=(struct notify_shaping_policy *)stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id);
-	EXPECT_NE(nullptr, shaping_label);
-	EXPECT_EQ(MAX_RESULT_NUM/2, shaping_label->shaping_result_num);
-	for(int i=0; i<shaping_label->shaping_result_num; i++)
+	matched_shaping_rules_deal(&a_stream, shaping_result, MAX_RESULT_NUM/2, 0);
+
+	hited_shaping=session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING);
+	EXPECT_NE(nullptr, hited_shaping);
+	EXPECT_EQ(MAX_RESULT_NUM/2, hited_shaping->n_rules);
+	for(size_t i=0; i<hited_shaping->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_SHAPING, shaping_label->shaping_result[i].action);
-		EXPECT_EQ(TSG_ACTION_SHAPING+i, shaping_label->shaping_result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_SHAPING, hited_shaping->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_SHAPING+i, hited_shaping->rules[i].rule_id);
 	}
 
-	free_shaping_result(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, (void *)shaping_label);
-	stream_bridge_async_data_put(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].id, NULL);
-	EXPECT_EQ(nullptr, stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_NOTIFY_SHAPING_RESULT].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);
+
+	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));
 }
 
 TEST(TSGMaster, SecurityPolicySendlog)
 {
 	const struct streaminfo a_stream={0};
-	struct Maat_rule_t security_result[MAX_RESULT_NUM]={0};
+	struct maat_rule matched_policy[MAX_RESULT_NUM]={0};
 
 	for(int i=0; i<MAX_RESULT_NUM; i++)
 	{
-		security_result[i].do_log=1;
-		security_result[i].action=TSG_ACTION_MONITOR;
-		security_result[i].config_id=TSG_ACTION_MONITOR+i;
+		matched_policy[i].do_log=1;
+		matched_policy[i].action=TSG_ACTION_MONITOR;
+		matched_policy[i].rule_id=TSG_ACTION_MONITOR+i;
 	}
 
 	// First notify
-	tsg_notify_hited_security_result(&a_stream, security_result, MAX_RESULT_NUM, 0);
+	session_matched_rules_notify(&a_stream, TSG_SERVICE_SECURITY, matched_policy, MAX_RESULT_NUM, 0);
 	
-	struct policy_priority_label *priority_label=(struct policy_priority_label *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_POLICY_PRIORITY].id);
-	EXPECT_NE(nullptr, priority_label);
-	EXPECT_EQ(MAX_RESULT_NUM, priority_label->security_result_num);
-	for(int i=0; i<priority_label->security_result_num; i++)
+	const struct matched_policy_rules *hited_security=session_matched_rules_get(&a_stream, TSG_SERVICE_SECURITY);
+	EXPECT_NE(nullptr, hited_security);
+	EXPECT_EQ(MAX_RESULT_NUM, hited_security->n_rules);
+	for(size_t i=0; i<hited_security->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_MONITOR, priority_label->security_result[i].action);
-		EXPECT_EQ(TSG_ACTION_MONITOR+i, priority_label->security_result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_MONITOR, hited_security->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_MONITOR+i, hited_security->rules[i].rule_id);
 	}
 
 	struct TLD_handle_t * handle=TLD_create(0);
-	struct Maat_rule_t session_record={0, 2, 1, 0, 0, 0, 0, {0}};
-	tsg_log_t log_msg={1, &session_record, (struct streaminfo*)&a_stream};
-	tsg_send_log(g_tsg_log_instance, handle, &log_msg, 0);
+	struct maat_rule session_record={0, 0, 2, 1, 0};
+	tsg_send_log(g_tsg_log_instance, handle, &a_stream, LOG_TYPE_SESSION_RECORD, &session_record, 1, 0);
 
 	int sendlog_cnt=rd_kafka_get_sendlog_cnt();
-	EXPECT_EQ(8, 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));
@@ -300,169 +308,331 @@ TEST(TSGMaster, SecurityPolicySendlog)
 	//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(7));
 	//EXPECT_STREQ("{}", rd_kafka_get_sendlog_payload(8));
 
-	priority_label=(struct policy_priority_label *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_POLICY_PRIORITY].id);
-	EXPECT_EQ(nullptr, priority_label);
+	hited_security=session_matched_rules_get(&a_stream, TSG_SERVICE_SECURITY);
+	EXPECT_EQ(nullptr, hited_security);
 }
 
-TEST(TSGMaster, SecurityDuplicatePolicyMultipleNotify)
+TEST(TSGMaster, ServiceChainingPolicyNotify)
 {
 	const struct streaminfo a_stream={0};
-	struct Maat_rule_t security_result[MAX_RESULT_NUM]={0};
-
+	struct maat_rule s_chaining_result[MAX_RESULT_NUM]={0};
+	
 	for(int i=0; i<MAX_RESULT_NUM/2; i++)
 	{
-		security_result[i].action=TSG_ACTION_MONITOR;
-		security_result[i].config_id=TSG_ACTION_MONITOR+i;
+		s_chaining_result[i].action=TSG_ACTION_S_CHAINING;
+		s_chaining_result[i].rule_id=TSG_ACTION_S_CHAINING+i;
 	}
-
-	// First notify
-	tsg_notify_hited_security_result(&a_stream, security_result, MAX_RESULT_NUM/2, 0);
 	
-	struct policy_priority_label *priority_label=(struct policy_priority_label *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_POLICY_PRIORITY].id);
-	EXPECT_NE(nullptr, priority_label);
-	EXPECT_EQ(MAX_RESULT_NUM/2, priority_label->security_result_num);
-	for(int i=0; i<priority_label->security_result_num; i++)
+	matched_service_chaining_rules_deal(&a_stream, s_chaining_result, MAX_RESULT_NUM/2, 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(MAX_RESULT_NUM/2, hited_s_chaining->n_rules);
+	for(size_t i=0; i<hited_s_chaining->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_MONITOR, priority_label->security_result[i].action);
-		EXPECT_EQ(TSG_ACTION_MONITOR+i, priority_label->security_result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hited_s_chaining->rules[i].rule_id);
 	}
 
-	// Second notify
-	tsg_notify_hited_security_result(&a_stream, security_result, MAX_RESULT_NUM/2, 0);
-	
-	priority_label=(struct policy_priority_label *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_POLICY_PRIORITY].id);
-	EXPECT_NE(nullptr, priority_label);
-	EXPECT_EQ(MAX_RESULT_NUM/2, priority_label->security_result_num);
-	for(int i=0; i<priority_label->security_result_num; i++)
-	{	
-		EXPECT_EQ(TSG_ACTION_MONITOR, priority_label->security_result[i].action);
-		EXPECT_EQ(TSG_ACTION_MONITOR+i, priority_label->security_result[i].config_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]);
 
-	free_shaping_result(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_POLICY_PRIORITY].id, (void *)priority_label);
-	stream_bridge_async_data_put(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_POLICY_PRIORITY].id, NULL);
-	EXPECT_EQ(nullptr, stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_POLICY_PRIORITY].id));
-}
+	session_segment_id_free(&a_stream, 0, (void *)segment_ids);
+	session_control_segment_ids_async(&a_stream, NULL);
 
-extern void set_s_chaining_result_to_bridge(const struct streaminfo * a_stream, struct Maat_rule_t * p_result, int p_result_num, int thread_seq);
+	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));
+}
 
-TEST(TSGMaster, ServiceChainingPolicyNotify)
+TEST(TSGMaster, ServiceChainingDuplicatePolicyMultipleNotify)
 {
 	const struct streaminfo a_stream={0};
-	struct Maat_rule_t s_chaining_result[MAX_RESULT_NUM]={0};
+	struct maat_rule s_chaining_result[MAX_RESULT_NUM]={0};
+
+	// first
+	for(int i=0; i<MAX_RESULT_NUM/2; i++)
+	{
+		s_chaining_result[i].action=TSG_ACTION_S_CHAINING;
+		s_chaining_result[i].rule_id=TSG_ACTION_S_CHAINING+i;
+	}
 	
+	matched_service_chaining_rules_deal(&a_stream, s_chaining_result, MAX_RESULT_NUM/2, 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(MAX_RESULT_NUM/2, hited_s_chaining->n_rules);
+	for(size_t i=0; i<hited_s_chaining->n_rules; i++)
+	{	
+		EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hited_s_chaining->rules[i].rule_id);
+	}
+
+	// second
 	for(int i=0; i<MAX_RESULT_NUM/2; i++)
 	{
 		s_chaining_result[i].action=TSG_ACTION_S_CHAINING;
-		s_chaining_result[i].config_id=TSG_ACTION_S_CHAINING+i;
+		s_chaining_result[i].rule_id=TSG_ACTION_S_CHAINING+i;
 	}
 	
-	set_s_chaining_result_to_bridge(&a_stream, s_chaining_result, MAX_RESULT_NUM/2, 0);
-	struct tm_hited_result *hited_s_chaining=(struct tm_hited_result *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id);
+	matched_service_chaining_rules_deal(&a_stream, s_chaining_result, MAX_RESULT_NUM/2, 0);
+	hited_s_chaining=session_matched_rules_get(&a_stream, TSG_SERVICE_CHAINING);
 	EXPECT_NE(nullptr, hited_s_chaining);
-	EXPECT_EQ(g_tsg_para.service_chaining_sid, hited_s_chaining->sid);
-	EXPECT_EQ(MAX_RESULT_NUM/2, hited_s_chaining->result_num);
-	for(int i=0; i<hited_s_chaining->result_num; i++)
+	EXPECT_EQ(MAX_RESULT_NUM/2, hited_s_chaining->n_rules);
+	for(size_t i=0; i<hited_s_chaining->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->result[i].action);
-		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hited_s_chaining->result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hited_s_chaining->rules[i].rule_id);
 	}
 
-	free_shaping_result(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id, (void *)hited_s_chaining);
-	stream_bridge_async_data_put(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id, NULL);
-	EXPECT_EQ(nullptr, stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].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);
+
+	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));
 }
 
-TEST(TSGMaster, ServiceChainingDuplicatePolicyMultipleNotify)
+TEST(TSGMaster, ServiceChainingPolicyMultipleNotify)
 {
 	const struct streaminfo a_stream={0};
-	struct Maat_rule_t s_chaining_result[MAX_RESULT_NUM]={0};
+	struct maat_rule s_chaining_result[MAX_RESULT_NUM]={0};
 
 	// first
 	for(int i=0; i<MAX_RESULT_NUM/2; i++)
 	{
 		s_chaining_result[i].action=TSG_ACTION_S_CHAINING;
-		s_chaining_result[i].config_id=TSG_ACTION_S_CHAINING+i;
+		s_chaining_result[i].rule_id=TSG_ACTION_S_CHAINING+i;
 	}
 	
-	set_s_chaining_result_to_bridge(&a_stream, s_chaining_result, MAX_RESULT_NUM/2, 0);
-	struct tm_hited_result *hited_s_chaining=(struct tm_hited_result *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id);
+	matched_service_chaining_rules_deal(&a_stream, s_chaining_result, MAX_RESULT_NUM/2, 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(g_tsg_para.service_chaining_sid, hited_s_chaining->sid);
-	EXPECT_EQ(MAX_RESULT_NUM/2, hited_s_chaining->result_num);
-	for(int i=0; i<hited_s_chaining->result_num; i++)
+	EXPECT_EQ(MAX_RESULT_NUM/2, hited_s_chaining->n_rules);
+	for(size_t i=0; i<hited_s_chaining->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->result[i].action);
-		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hited_s_chaining->result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hited_s_chaining->rules[i].rule_id);
 	}
 
 	// second
-	for(int i=0; i<MAX_RESULT_NUM/2; i++)
+	for(int i=MAX_RESULT_NUM/2; i<MAX_RESULT_NUM; i++)
 	{
 		s_chaining_result[i].action=TSG_ACTION_S_CHAINING;
-		s_chaining_result[i].config_id=TSG_ACTION_S_CHAINING+i;
+		s_chaining_result[i].rule_id=TSG_ACTION_S_CHAINING+i;
 	}
-	
-	tsg_notify_hited_s_chaining_result(&a_stream, s_chaining_result, MAX_RESULT_NUM/2, 1);
-	hited_s_chaining=(struct tm_hited_result *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id);
+
+	matched_service_chaining_rules_deal(&a_stream, s_chaining_result, MAX_RESULT_NUM/2, 0);
+	hited_s_chaining=session_matched_rules_get(&a_stream, TSG_SERVICE_CHAINING);
 	EXPECT_NE(nullptr, hited_s_chaining);
-	EXPECT_EQ(g_tsg_para.service_chaining_sid, hited_s_chaining->sid);
-	EXPECT_EQ(MAX_RESULT_NUM/2, hited_s_chaining->result_num);
-	for(int i=0; i<hited_s_chaining->result_num; i++)
+	EXPECT_EQ(MAX_RESULT_NUM/2, hited_s_chaining->n_rules);
+	for(size_t i=0; i<hited_s_chaining->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->result[i].action);
-		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hited_s_chaining->result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hited_s_chaining->rules[i].rule_id);
 	}
 
-	free_shaping_result(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id, (void *)hited_s_chaining);
-	stream_bridge_async_data_put(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id, NULL);
-	EXPECT_EQ(nullptr, stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].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);
+
+	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));
 }
 
-TEST(TSGMaster, ServiceChainingPolicyMultipleNotify)
+TEST(TSGMaster, SecurityDuplicatePolicyMultipleNotify)
 {
 	const struct streaminfo a_stream={0};
-	struct Maat_rule_t s_chaining_result[MAX_RESULT_NUM]={0};
+	struct maat_rule matched_policy[MAX_RESULT_NUM]={0};
 
-	// first
 	for(int i=0; i<MAX_RESULT_NUM/2; i++)
 	{
-		s_chaining_result[i].action=TSG_ACTION_S_CHAINING;
-		s_chaining_result[i].config_id=TSG_ACTION_S_CHAINING+i;
+		matched_policy[i].action=TSG_ACTION_MONITOR;
+		matched_policy[i].rule_id=TSG_ACTION_MONITOR+i;
 	}
+
+	// First notify
+	session_matched_rules_notify(&a_stream, TSG_SERVICE_SECURITY, matched_policy, MAX_RESULT_NUM/2, 0);
 	
-	set_s_chaining_result_to_bridge(&a_stream, s_chaining_result, MAX_RESULT_NUM/2, 0);
-	struct tm_hited_result *hited_s_chaining=(struct tm_hited_result *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id);
-	EXPECT_NE(nullptr, hited_s_chaining);
-	EXPECT_EQ(g_tsg_para.service_chaining_sid, hited_s_chaining->sid);
-	EXPECT_EQ(MAX_RESULT_NUM/2, hited_s_chaining->result_num);
-	for(int i=0; i<hited_s_chaining->result_num; i++)
+	const struct matched_policy_rules *hited_security=session_matched_rules_get(&a_stream, TSG_SERVICE_SECURITY);
+	EXPECT_NE(nullptr, hited_security);
+	EXPECT_EQ(MAX_RESULT_NUM/2, hited_security->n_rules);
+	for(size_t i=0; i<hited_security->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->result[i].action);
-		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hited_s_chaining->result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_MONITOR, hited_security->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_MONITOR+i, hited_security->rules[i].rule_id);
 	}
 
-	// second
-	for(int i=MAX_RESULT_NUM/2; i<MAX_RESULT_NUM; i++)
+	// Second notify
+	session_matched_rules_notify(&a_stream, TSG_SERVICE_SECURITY, matched_policy, MAX_RESULT_NUM/2, 0);
+	
+	hited_security=session_matched_rules_get(&a_stream, TSG_SERVICE_SECURITY);
+	EXPECT_NE(nullptr, hited_security);
+	EXPECT_EQ(MAX_RESULT_NUM/2, hited_security->n_rules);
+	for(size_t i=0; i<hited_security->n_rules; i++)
+	{	
+		EXPECT_EQ(TSG_ACTION_MONITOR, hited_security->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_MONITOR+i, hited_security->rules[i].rule_id);
+	}
+
+	session_matched_rules_free(&a_stream, TSG_SERVICE_SECURITY, (void *)hited_security);
+	session_matched_rules_async(&a_stream, TSG_SERVICE_SECURITY, NULL);
+	EXPECT_EQ(nullptr, session_matched_rules_get(&a_stream, TSG_SERVICE_SECURITY));
+}
+
+extern int session_packet_capture_notify(const struct streaminfo *a_stream, struct maat_rule *rules, size_t n_rules, int thread_seq);
+
+TEST(TSGMaster, SecurityPolicyIntercept)
+{
+	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;
+
+	// Set Intercept
+	session_matched_rules_notify(&a_stream, TSG_SERVICE_SECURITY, &matched_policy[1], 1, 0);
+
+	const struct matched_policy_rules *hited_security=session_matched_rules_get(&a_stream, TSG_SERVICE_SECURITY);
+	EXPECT_NE(nullptr, hited_security);
+	EXPECT_EQ(1, hited_security->n_rules);
+	EXPECT_EQ(TSG_ACTION_INTERCEPT, hited_security->rules[0].action);
+	EXPECT_EQ(TSG_ACTION_INTERCEPT, hited_security->rules[0].rule_id);
+
+	session_matched_rules_free(&a_stream, TSG_SERVICE_SECURITY, (void *)hited_security);
+	session_matched_rules_async(&a_stream, TSG_SERVICE_SECURITY, NULL);
+	EXPECT_EQ(nullptr, session_matched_rules_get(&a_stream, TSG_SERVICE_SECURITY));
+}
+
+
+TEST(TSGMaster, SecurityMultiplePolicyMonitorToIntercept)
+{
+	const struct streaminfo a_stream={0};
+	struct maat_rule matched_policy[MAX_RESULT_NUM]={0};
+
+	matched_policy[0].action=TSG_ACTION_MONITOR;
+	matched_policy[0].rule_id=TSG_ACTION_MONITOR;
+
+	matched_policy[1].action=TSG_ACTION_INTERCEPT;
+	matched_policy[1].rule_id=TSG_ACTION_INTERCEPT;
+
+	// First Monitor, second Intercpt
+	session_matched_rules_notify(&a_stream, TSG_SERVICE_SECURITY, &matched_policy[0], 1, 0);
+
+	int ret=session_matched_rules_copy(&a_stream, TSG_SERVICE_INTERCEPT, &(matched_policy[2]), 1);
+	EXPECT_EQ(0, ret);
+	
+	ret=session_matched_rules_copy(&a_stream, TSG_SERVICE_SECURITY, &(matched_policy[2]), 1);
+	EXPECT_EQ(1, ret);
+	EXPECT_EQ(TSG_ACTION_MONITOR, matched_policy[2].action);
+	EXPECT_EQ(TSG_ACTION_MONITOR, matched_policy[2].rule_id);
+
+	ret=session_matched_rules_copy(&a_stream, TSG_SERVICE_SECURITY, &(matched_policy[2]), 1);
+	EXPECT_EQ(1, ret);
+	EXPECT_EQ(TSG_ACTION_MONITOR, matched_policy[2].action);
+	EXPECT_EQ(TSG_ACTION_MONITOR, matched_policy[2].rule_id);
+
+	const struct matched_policy_rules *hited_security=session_matched_rules_get(&a_stream, TSG_SERVICE_SECURITY);
+	EXPECT_NE(nullptr, hited_security);
+	EXPECT_EQ(1, hited_security->n_rules);
+	EXPECT_EQ(TSG_ACTION_MONITOR, hited_security->rules[0].action);
+	EXPECT_EQ(TSG_ACTION_MONITOR, hited_security->rules[0].rule_id);
+
+	session_matched_rules_free(&a_stream, TSG_SERVICE_SECURITY, (void *)hited_security);
+	session_matched_rules_async(&a_stream, TSG_SERVICE_SECURITY, NULL);
+	EXPECT_EQ(nullptr, session_matched_rules_get(&a_stream, TSG_SERVICE_SECURITY));
+
+	// Set Intercept
+	session_matched_rules_notify(&a_stream, TSG_SERVICE_INTERCEPT, &matched_policy[1], 1, 0);
+
+	ret=session_matched_rules_copy(&a_stream, TSG_SERVICE_INTERCEPT, &(matched_policy[2]), 1);
+	EXPECT_EQ(1, ret);
+	EXPECT_EQ(TSG_ACTION_INTERCEPT, matched_policy[2].action);
+	EXPECT_EQ(TSG_ACTION_INTERCEPT, matched_policy[2].rule_id);
+	
+	ret=session_matched_rules_copy(&a_stream, TSG_SERVICE_INTERCEPT, &(matched_policy[2]), 1);
+	EXPECT_EQ(1, ret);
+	EXPECT_EQ(TSG_ACTION_INTERCEPT, matched_policy[2].action);
+	EXPECT_EQ(TSG_ACTION_INTERCEPT, matched_policy[2].rule_id);
+
+	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);
+
+	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, ShapingAndServiceChainingPolicyNotify)
+{
+	const struct streaminfo a_stream={0};
+
+	// service chaining notify
+	struct maat_rule service_chaining_result[MAX_RESULT_NUM]={0};
+	for(int i=0; i<MAX_RESULT_NUM/2; i++)
 	{
-		s_chaining_result[i].action=TSG_ACTION_S_CHAINING;
-		s_chaining_result[i].config_id=TSG_ACTION_S_CHAINING+i;
+		service_chaining_result[i].action=TSG_ACTION_S_CHAINING;
+		service_chaining_result[i].rule_id=TSG_ACTION_S_CHAINING+i;
+	}
+	matched_service_chaining_rules_deal(&a_stream, service_chaining_result, MAX_RESULT_NUM/2, 0);
+
+	const struct matched_policy_rules *hitted_service_chaining=session_matched_rules_get(&a_stream, TSG_SERVICE_CHAINING);
+	EXPECT_NE(nullptr, hitted_service_chaining);
+	EXPECT_EQ(MAX_RESULT_NUM/2, hitted_service_chaining->n_rules);
+	for(size_t i=0; i<hitted_service_chaining->n_rules; i++)
+	{	
+		EXPECT_EQ(TSG_ACTION_S_CHAINING, hitted_service_chaining->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hitted_service_chaining->rules[i].rule_id);
+	}
+
+	// shping notify
+	struct maat_rule shaping_result[MAX_RESULT_NUM]={0};
+	for(int i=0; i<MAX_RESULT_NUM/2; i++)
+	{
+		shaping_result[i].action=TSG_ACTION_SHAPING;
+		shaping_result[i].rule_id=TSG_ACTION_SHAPING+i;
 	}
 	
-	tsg_notify_hited_s_chaining_result(&a_stream, &(s_chaining_result[MAX_RESULT_NUM/2]), MAX_RESULT_NUM/2, 1);
-	hited_s_chaining=(struct tm_hited_result *)tsg_get_xxx_from_bridge(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id);
-	EXPECT_NE(nullptr, hited_s_chaining);
-	EXPECT_EQ(g_tsg_para.service_chaining_sid, hited_s_chaining->sid);
-	EXPECT_EQ(MAX_RESULT_NUM, hited_s_chaining->result_num);
-	for(int i=0; i<hited_s_chaining->result_num; i++)
+	matched_shaping_rules_deal(&a_stream, shaping_result, MAX_RESULT_NUM/2, 0);
+	const struct matched_policy_rules *hitted_shaping=session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING);
+	EXPECT_NE(nullptr, hitted_shaping);
+	EXPECT_EQ(MAX_RESULT_NUM/2, hitted_shaping->n_rules);
+	for(size_t i=0; i<hitted_shaping->n_rules; i++)
 	{	
-		EXPECT_EQ(TSG_ACTION_S_CHAINING, hited_s_chaining->result[i].action);
-		EXPECT_EQ(TSG_ACTION_S_CHAINING+i, hited_s_chaining->result[i].config_id);
+		EXPECT_EQ(TSG_ACTION_SHAPING, hitted_shaping->rules[i].action);
+		EXPECT_EQ(TSG_ACTION_SHAPING+i, hitted_shaping->rules[i].rule_id);
 	}
 
-	free_shaping_result(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id, (void *)hited_s_chaining);
-	stream_bridge_async_data_put(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].id, NULL);
-	EXPECT_EQ(nullptr, stream_bridge_async_data_get(&a_stream, g_tsg_para.bridge[BRIDGE_TYPE_SERVICE_CHAINING].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(2, segment_ids->sz_sidlist);
+	EXPECT_EQ(g_tsg_para.service_chaining_sid, segment_ids->sid_list[0]);
+	EXPECT_EQ(g_tsg_para.shaping_sid, segment_ids->sid_list[1]);
+
+	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_SHAPING, (void *)hitted_shaping);
+	session_matched_rules_async(&a_stream, TSG_SERVICE_SHAPING, NULL);
+	EXPECT_EQ(nullptr, session_matched_rules_get(&a_stream, TSG_SERVICE_SHAPING));
+
+	session_matched_rules_free(&a_stream, TSG_SERVICE_CHAINING, (void *)hitted_service_chaining);
+	session_matched_rules_async(&a_stream, TSG_SERVICE_CHAINING, NULL);
+	EXPECT_EQ(nullptr, session_matched_rules_get(&a_stream, TSG_SERVICE_CHAINING));
 }
 
 int main(int argc, char *argv[])