Merge branch 'master' into push-masterv1.0.2

10 files changed, 388 insertions, 147 deletions

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 3550e0a..a50a260 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -10,10 +10,22 @@ variables:
 
 stages:
   - build
+  - fvt
   - package
   - release
   - docker
-  
+
+.fvt:
+  image:  git.mesalab.cn:7443/mesa_platform/mesa_protocol:master
+  script:
+    - rpm -ivh build/*.rpm
+    - source /etc/profile.d/MESA.sh
+    - cd /home/mesasoft/
+    - git clone https://$USER_NAME:[email protected]/tango/fvt.git
+    - cd fvt/
+    - sh +x ./fvt_verify.sh /home/mesasoft/sapp_run/ /home/mesasoft/sapp_run/tsgconf/tsg_maat.json /home/mesasoft/sapp_run/tsglog/tsglog /home/mesasoft/fvt/master
+
+
 .build_before_script:
   before_script:
     - mkdir -p /tmp/padding_for_CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX/$CI_PROJECT_NAMESPACE/
@@ -55,6 +67,14 @@ build:
   except:
     - tags
 
+fvt:
+  stage: fvt
+  extends:   .fvt
+  tags:
+    - share
+  except:
+    - tags
+
 tsg-master-release:
   stage: package
   extends: .package_master
diff --git a/bin/maat.conf b/bin/maat.conf
index b43e9ac..a6b9da6 100644
--- a/bin/maat.conf
+++ b/bin/maat.conf
@@ -1,5 +1,5 @@
 [STATIC]
-MAAT_MODE=2
+MAAT_MODE=1
 #EFFECTIVE_FLAG=
 STAT_SWITCH=1
 PERF_SWITCH=1
@@ -15,7 +15,7 @@ INC_CFG_DIR=tsgrule/inc/index/
 FULL_CFG_DIR=tsgrule/full/index/
 
 [DYNAMIC]
-MAAT_MODE=2
+MAAT_MODE=1
 #EFFECTIVE_FLAG=
 STAT_SWITCH=1
 PERF_SWITCH=1
diff --git a/bin/main.conf b/bin/main.conf
index 99b2392..4dbfd90 100644
--- a/bin/main.conf
+++ b/bin/main.conf
@@ -6,11 +6,10 @@ CB_SUBSCRIBER_IP_TABLE=TSG_DYN_SUBSCRIBER_IP
 
 [TSG_LOG]
 MODE=1
-NIC_NAME=enp8s0
-MAX_SERVICE=1
+NIC_NAME=lo
 LOG_LEVEL=10
 LOG_PATH=./tsglog/tsglog
-BROKER_LIST=192.168.40.186:9092
+BROKER_LIST=127.0.0.1:9092
 COMMON_FIELD_FILE=tsgconf/tsg_log_field.conf
 
 [STATISTIC]
diff --git a/bin/tsg_master.inf b/bin/tsg_master.inf
index e18e8dd..4cc2f33 100644
--- a/bin/tsg_master.inf
+++ b/bin/tsg_master.inf
@@ -7,3 +7,7 @@ DESTROY_FUNC=TSG_MASTER_UNLOAD
 [TCP]
 FUNC_FLAG=ALL
 FUNC_NAME=TSG_MASTER_TCP_ENTRY
+
+[UDP]
+FUNC_FLAG=ALL
+FUNC_NAME=TSG_MASTER_UDP_ENTRY
diff --git a/src/tsg_entry.cpp b/src/tsg_entry.cpp
index 7612d89..0306e2d 100644
--- a/src/tsg_entry.cpp
+++ b/src/tsg_entry.cpp
@@ -2,6 +2,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
+#include <unistd.h>
 
 #include <MESA/http.h>
 #include <MESA/ftp.h>
@@ -38,7 +39,7 @@ static __attribute__((__used__)) const char * GIT_VERSION_UNKNOWN = NULL;
 #endif
 
 
-char TSG_MASTER_VERSION_20200113=0;
+char TSG_MASTER_VERSION_20200119=0;
 const char *tsg_conffile="tsgconf/main.conf";
 g_tsg_para_t g_tsg_para;
 
@@ -57,6 +58,165 @@ static void free_policy_label(int thread_seq, void *project_req_value)
 	project_req_value=NULL;
 }
 
+static void free_context(void **pme, int thread_seq)
+{
+	struct _master_context *_context=(struct _master_context *)*pme;
+
+	if(_context!=NULL)
+	{
+		if(_context->result!=NULL)
+		{
+			dictator_free(thread_seq, (void *)_context->result);
+			_context->result=NULL;
+		}
+
+		dictator_free(thread_seq, (void *)_context);
+		_context=NULL;
+		*pme=NULL;
+	}
+}
+
+static int init_context(void **pme, tsg_protocol_t proto, struct Maat_rule_t *p_result, int thread_seq)
+{	
+	struct _master_context *_context=(struct _master_context *)*pme;
+
+	*pme=dictator_malloc(thread_seq, sizeof(struct _master_context));
+	_context=(struct _master_context *)*pme;
+	_context->proto=proto;
+	_context->hit_cnt=1;
+	_context->result=(struct Maat_rule_t *)dictator_malloc(thread_seq, sizeof(struct Maat_rule_t));
+	memcpy(_context->result, p_result, sizeof(struct Maat_rule_t));
+
+	return 0;
+}
+
+static int master_method_type(struct streaminfo *a_stream, struct Maat_rule_t *p_result)
+{
+	cJSON *item=NULL;
+	cJSON *object=NULL;
+	char *tmp_buff=NULL;
+	int method_type=-1;
+
+	if(p_result->serv_def_len<128)
+	{
+		object=cJSON_Parse(p_result->service_defined);
+
+		MESA_handle_runtime_log(g_tsg_para.logger, 
+								RLOG_LV_DEBUG,
+								"DO_ACTION",
+								"Hit policy_id: %d service: %d action: %d user_reagion: %s addr: %s",
+								p_result->config_id,
+								p_result->service_id,
+								(unsigned char)p_result->action,
+								p_result->service_defined,
+								printaddr(&a_stream->addr, a_stream->threadnum)
+								);
+	}
+	else
+	{
+		tmp_buff=(char *)calloc(1, p_result->serv_def_len+1);
+		Maat_read_rule(g_tsg_maat_feather, p_result, MAAT_RULE_SERV_DEFINE, tmp_buff, p_result->serv_def_len);
+		object=cJSON_Parse(tmp_buff);
+
+		MESA_handle_runtime_log(g_tsg_para.logger, 
+								RLOG_LV_DEBUG,
+								"DO_ACTION",
+								"Hit policy_id: %d service: %d action: %d user_reagion: %s addr: %s",
+								p_result->config_id,
+								p_result->service_id,
+								(unsigned char)p_result->action,
+								tmp_buff,
+								printaddr(&a_stream->addr, a_stream->threadnum)
+								);
+	}
+
+	if(object==NULL)
+	{
+		MESA_handle_runtime_log(g_tsg_para.logger, 
+								RLOG_LV_FATAL,
+								"DO_ACTION",
+								"Hit policy_id: %d service: %d action: %d user_reagion: %s addr: %s",
+								p_result->config_id,
+								p_result->service_id,
+								(unsigned char)p_result->action,
+								(tmp_buff==NULL) ? p_result->service_defined : tmp_buff,
+								printaddr(&a_stream->addr, a_stream->threadnum)
+								);
+
+		if(tmp_buff!=NULL)
+		{
+			free(tmp_buff);
+			tmp_buff=NULL;
+		}
+		
+		return -1;
+	}
+
+	item=cJSON_GetObjectItem(object, "method");
+	if(item!=NULL)
+	{
+		method_type=tsg_get_method_id(item->valuestring);
+	}
+
+	if(tmp_buff!=NULL)
+	{
+		free(tmp_buff);
+		tmp_buff=NULL;
+	}
+
+	cJSON_Delete(object);
+	object=NULL;
+
+	return method_type;
+}
+
+static int master_do_deny(struct streaminfo *a_stream, struct Maat_rule_t *p_result, int thread_seq)
+{
+	int opt_value=0;	
+	int method_type=-1;
+	struct rst_tcp_para rst_paras;
+
+	method_type=master_method_type(a_stream, p_result);
+	switch(method_type)
+	{
+		case	TSG_METHOD_TYPE_DROP:
+			opt_value=1;
+			MESA_set_stream_opt(a_stream, MSO_DROP_STREAM, (void *)&opt_value, sizeof(opt_value));
+			break;
+		case	TSG_METHOD_TYPE_BLOCK:
+			MESA_handle_runtime_log(g_tsg_para.logger,
+									RLOG_LV_FATAL,
+									"TSG_ACTION_DENY",
+									"Unsupport block of deny, policy_id: %d service: %d action: %d addr: %s",
+									p_result[0].config_id,
+									p_result[0].service_id,
+									(unsigned char)p_result[0].action,
+									printaddr(&a_stream->addr, thread_seq)
+								);
+			//break; // not break
+		case	TSG_METHOD_TYPE_RESET:
+			opt_value=1;
+			MESA_set_stream_opt(a_stream, MSO_TCP_RST_REMEDY, (void *)&opt_value, sizeof(opt_value));
+			
+			rst_paras.dir=DIR_DOUBLE;
+			rst_paras.rst_pkt_num=1;
+			rst_paras.signature_seed1=65535;
+			rst_paras.signature_seed2=13;
+			rst_paras.th_flags=4;
+			rst_paras.__pad_no_use=0;
+			MESA_rst_tcp(a_stream, &rst_paras, sizeof(rst_paras));
+
+			opt_value=1;
+			MESA_set_stream_opt(a_stream, MSO_DROP_STREAM, (void *)&opt_value, sizeof(opt_value));
+			MESA_set_stream_opt(a_stream, MSO_TIMEOUT, (void *)&g_tsg_para.timeout, sizeof(g_tsg_para.timeout));
+			break;
+		default:
+			break;
+	}
+
+	return 0;
+}
+
 static char *schema_index2string(tsg_protocol_t proto)
 {
 	char *schema_field_value=NULL;
@@ -249,13 +409,13 @@ static int identify_application_protocol(struct streaminfo *a_stream, struct _id
 extern "C" char TSG_MASTER_TCP_ENTRY(struct streaminfo *a_tcp, void **pme, int thread_seq,void *a_packet)
 {
 	int ret=0,hit_num=0;
-	int state=APP_STATE_DROPME;
+	int state=APP_STATE_GIVEME;
 	scan_status_t mid=NULL;
 	Maat_rule_t *p_result=NULL;
 	Maat_rule_t *q_result=NULL;
 	struct _identify_info identify_info;
 	Maat_rule_t all_result[MAX_RESULT_NUM];
-	policy_priority_label_t *priority_label=NULL;
+	policy_priority_label_t *priority_label=NULL;	
 	struct _master_context *_context=(struct _master_context *)*pme;
 	
 	switch(a_tcp->opstate)
@@ -283,12 +443,11 @@ extern "C" char TSG_MASTER_TCP_ENTRY(struct streaminfo *a_tcp, void **pme, int t
 											RLOG_LV_DEBUG,
 											"SCAN_FQDN",
 											"Hit %s: %s policy_id: %d service: %d action: %d addr: %s",
-
 											(identify_info.proto==PROTO_HTTP) ? "host" : "sni",
 											identify_info.domain,
 											all_result[hit_num].config_id,
 											all_result[hit_num].service_id,
-											all_result[hit_num].action,
+											(unsigned char)all_result[hit_num].action,
 											printaddr(&a_tcp->addr, thread_seq)
 										);
 
@@ -307,48 +466,45 @@ extern "C" char TSG_MASTER_TCP_ENTRY(struct streaminfo *a_tcp, void **pme, int t
 											printaddr(&a_tcp->addr, thread_seq)
 										);
 			}
+
+			if(mid!=NULL)
+			{
+				Maat_clean_status(&mid);
+				mid=NULL;
+			}
 			
 			p_result=tsg_policy_decision_criteria(all_result, hit_num);
 			
 			if(p_result!=NULL)
-			{	
+			{
 				switch((unsigned char)p_result->action)
 				{
 					case	TSG_ACTION_DENY:
-						MESA_kill_tcp(a_tcp, a_packet);
-						FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_DENY], 0, FS_OP_ADD, 1);
-
+						master_do_deny(a_tcp, p_result, thread_seq);
 						master_send_log(a_tcp, p_result, 1, &identify_info, thread_seq);
-						state|=APP_STATE_DROPPKT|APP_STATE_KILL_OTHER;
+						FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_DENY], 0, FS_OP_ADD, 1);
 
 						MESA_handle_runtime_log(g_tsg_para.logger,
 												RLOG_LV_DEBUG,
 												"DENY",
-												"Hit deny policy, policy_id: %d action: %d addr: %s",
+												"Hit deny policy, policy_id: %d service: %d action: %d addr: %s",
 												p_result[0].config_id,
-												p_result[0].action,
+												p_result[0].service_id,
+												(unsigned char)p_result[0].action,
 												printaddr(&a_tcp->addr, thread_seq)
 												);
+
+						return APP_STATE_DROPPKT|APP_STATE_KILL_OTHER;
 						break;
 					case	TSG_ACTION_MONITOR:
 						if(q_result!=NULL && (p_result==q_result))
 						{
-							*pme=dictator_malloc(thread_seq, sizeof(struct _master_context));
-							_context=(struct _master_context *)*pme;
-							_context->hit_cnt=1;
-							_context->result=(struct Maat_rule_t *)dictator_malloc(thread_seq, sizeof(struct Maat_rule_t));
-							memcpy(_context->result, p_result, sizeof(struct Maat_rule_t));
-
+							init_context(pme, identify_info.proto, p_result, thread_seq);
 							state=APP_STATE_GIVEME;
 						}
 						break;
 					case	TSG_ACTION_BYPASS:
-						*pme=dictator_malloc(thread_seq, sizeof(struct _master_context));
-						_context=(struct _master_context *)*pme;
-						_context->hit_cnt=1;
-						_context->result=(struct Maat_rule_t *)dictator_malloc(thread_seq, sizeof(struct Maat_rule_t));
-						memcpy(_context->result, p_result, sizeof(struct Maat_rule_t));
-							
+						init_context(pme, identify_info.proto, p_result, thread_seq);
 						state=APP_STATE_GIVEME|APP_STATE_KILL_OTHER;
 						FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_BYPASS], 0, FS_OP_ADD, 1);
 						break;
@@ -370,46 +526,129 @@ extern "C" char TSG_MASTER_TCP_ENTRY(struct streaminfo *a_tcp, void **pme, int t
 						if(ret<0)
 						{
 							free_policy_label(thread_seq, (void *)priority_label);
-							MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_FATAL, "PROJECT_ADD", "Add policy_priority_label failed ...");
+							MESA_handle_runtime_log(g_tsg_para.logger,
+													RLOG_LV_FATAL,
+													"PROJECT_ADD",
+													"Add policy_priority_label failed, intercept policy, policy_id: %d action: %d addr: %s",
+													priority_label->result[0].config_id,
+													(unsigned char)priority_label->result[0].action,
+													printaddr(&a_tcp->addr, thread_seq)
+													);
 						}
 						
-						MESA_handle_runtime_log(g_tsg_para.logger, RLOG_LV_DEBUG, "INTERCEPT", "Hit intercept policy, policy_id: %d action: %d addr: %s",
-
-															priority_label->result[0].config_id, priority_label->result[0].action, printaddr(&a_tcp->addr, thread_seq));
+						MESA_handle_runtime_log(g_tsg_para.logger, 
+												RLOG_LV_DEBUG,
+												"INTERCEPT",
+												"Hit intercept policy, policy_id: %d action: %d addr: %s",
+												priority_label->result[0].config_id,
+												(unsigned char)priority_label->result[0].action,
+												printaddr(&a_tcp->addr, thread_seq)
+												);
+						return APP_STATE_DROPME;
 						break;
 					case	TSG_ACTION_NONE:
 					default:
-						assert(0);
+						return APP_STATE_DROPME;
 						break;
 				}
 			}
 
+			break;
+		case	OP_STATE_DATA:
+			break;
+		case	OP_STATE_CLOSE:
+			if(_context!=NULL)
+			{
+				if(_context->hit_cnt>0 && _context->result!=NULL)
+				{
+					memset(&identify_info, 0, sizeof(identify_info));
+					identify_info.proto=_context->proto;
+					
+					master_send_log(a_tcp, _context->result, _context->hit_cnt, &identify_info, thread_seq);
+					free_context(pme, thread_seq);
+				}
+			}
+		default:
+			break;
+	}
+
+	return state;
+}
+
+extern "C" char TSG_MASTER_UDP_ENTRY(struct streaminfo *a_udp, void **pme, int thread_seq,void *a_packet)
+{
+	int ret=0,opt_value=0;
+	scan_status_t mid=NULL;
+	int state=APP_STATE_GIVEME;
+	Maat_rule_t *p_result=NULL;
+	Maat_rule_t result[MAX_RESULT_NUM];
+	struct _identify_info identify_info;
+	struct _master_context *_context=(struct _master_context *)*pme;
+
+	switch(a_udp->opstate)
+	{
+		case	OP_STATE_PENDING:
+			memset(&identify_info, 0, sizeof(identify_info));
+			identify_application_protocol(a_udp, &identify_info);
+
+			ret=tsg_scan_nesting_addr(g_tsg_maat_feather, a_udp, identify_info.proto, &mid, result, MAX_RESULT_NUM);
+
 			if(mid!=NULL)
 			{
 				Maat_clean_status(&mid);
 				mid=NULL;
 			}
-		break;
+			p_result=tsg_policy_decision_criteria(result, ret);
+			if(p_result!=NULL)
+			{
+				switch((unsigned char)p_result->action)
+				{
+					case	TSG_ACTION_DENY:
+						opt_value=1;
+						MESA_set_stream_opt(a_udp, MSO_DROP_STREAM, (void *)&opt_value, sizeof(opt_value));
+						FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_DENY], 0, FS_OP_ADD, 1);
+						
+						return APP_STATE_DROPME|APP_STATE_DROPPKT;
+						break;
+					case	TSG_ACTION_BYPASS:
+						init_context(pme, identify_info.proto, p_result, thread_seq);
+						FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_BYPASS], 0, FS_OP_ADD, 1);
+						state=APP_STATE_GIVEME|APP_STATE_KILL_OTHER;
+						break;
+					case	TSG_ACTION_MONITOR:
+						init_context(pme, identify_info.proto, p_result, thread_seq);
+						state=APP_STATE_GIVEME;
+						break;
+					case	TSG_ACTION_INTERCEPT:
+					case	TSG_ACTION_MANIPULATE:
+					default:
+						return APP_STATE_DROPME;
+						break;
+				}
+			}
+			break;
 		case	OP_STATE_DATA:
+			break;
 		case	OP_STATE_CLOSE:
 			if(_context!=NULL)
 			{
 				if(_context->hit_cnt>0 && _context->result!=NULL)
 				{
-					master_send_log(a_tcp, _context->result, _context->hit_cnt, NULL, thread_seq);
-					dictator_free(thread_seq, (void *)_context->result);
-					_context->result=NULL;
+					memset(&identify_info, 0, sizeof(identify_info));
+					identify_info.proto=_context->proto;
+					
+					master_send_log(a_udp, _context->result, _context->hit_cnt, &identify_info, thread_seq);
+					free_context(pme, thread_seq);
 				}
 			}
+			break;
 		default:
 			break;
 	}
-
+	
 	return state;
 }
 
-
-
 extern "C" int TSG_MASTER_INIT()
 {
 	int i=0,ret=0,cycle=0;
@@ -424,7 +663,7 @@ extern "C" int TSG_MASTER_INIT()
 	memset(&g_tsg_para, 0, sizeof(g_tsg_para));
 	
 	MESA_load_profile_int_def(tsg_conffile, "SYSTEM","LOG_LEVEL", &level, 30);
-	MESA_load_profile_string_def(tsg_conffile, "SYSTEM","LOG_PATH", log_path, sizeof(log_path), NULL);
+	MESA_load_profile_string_def(tsg_conffile, "SYSTEM","LOG_PATH", log_path, sizeof(log_path), "tsglog/tsg_master");
 
 	g_tsg_para.logger=MESA_create_runtime_log_handle(log_path, level);
 	if(g_tsg_para.logger==NULL)
@@ -434,6 +673,7 @@ extern "C" int TSG_MASTER_INIT()
 	}
 
 	MESA_load_profile_int_def(tsg_conffile, "SYSTEM", "DEVICE_ID", &g_tsg_para.device_id, 0);
+	MESA_load_profile_short_def(tsg_conffile, "SYSTEM", "TIMEOUT", (short *)&g_tsg_para.timeout, 300);
 
 	MESA_load_profile_string_def(tsg_conffile, "SYSTEM", "POLICY_PRIORITY_LABEL", label_buff, sizeof(label_buff), "POLICY_PRIORITY");
 	g_tsg_para.priority_project_id=project_producer_register(label_buff, PROJECT_VAL_TYPE_STRUCT, free_policy_label);
@@ -502,6 +742,7 @@ extern "C" int TSG_MASTER_INIT()
 
 extern "C" int TSG_MASTER_UNLOAD()
 {
+	sleep(5);
 	return 0;
 }
 
diff --git a/src/tsg_entry.h b/src/tsg_entry.h
index 90d77df..8daf3ac 100644
--- a/src/tsg_entry.h
+++ b/src/tsg_entry.h
@@ -51,6 +51,7 @@ typedef	struct _policy_priority_label
 
 struct _master_context
 {
+	tsg_protocol_t proto;
 	int hit_cnt;
 	struct Maat_rule_t *result;
 };
@@ -58,6 +59,7 @@ struct _master_context
 #define	_MAX_TABLE_NAME_LEN	64
 typedef	struct _tsg_para
 {
+	unsigned short timeout;
 	int device_id;	
 	int table_id[TABLE_MAX];
 	int dyn_subscribe_ip_table_id; //TSG_DYN_SUBSCRIBER_IP
diff --git a/src/tsg_rule.cpp b/src/tsg_rule.cpp
index 2e62ff2..e4d96a6 100644
--- a/src/tsg_rule.cpp
+++ b/src/tsg_rule.cpp
@@ -432,7 +432,7 @@ int tsg_scan_nesting_addr(Maat_feather_t maat_feather, const struct streaminfo *
 											maat_ret,
 											result[hit_num].config_id,
 											result[hit_num].service_id,
-											result[hit_num].action
+											(unsigned char)result[hit_num].action
 										);
 
 				hit_num+=maat_ret;
@@ -476,7 +476,7 @@ int tsg_scan_nesting_addr(Maat_feather_t maat_feather, const struct streaminfo *
 									maat_ret,
 									result[hit_num].config_id,
 									result[hit_num].service_id,
-									result[hit_num].action,
+									(unsigned char)result[hit_num].action,
 									printaddr(&a_stream->addr, a_stream->threadnum)
 									);
 
@@ -522,7 +522,7 @@ int tsg_scan_nesting_addr(Maat_feather_t maat_feather, const struct streaminfo *
 											maat_ret,
 											result[hit_num].config_id,
 											result[hit_num].service_id,
-											result[hit_num].action,
+											(unsigned char)result[hit_num].action,
 											printaddr(&a_stream->addr, a_stream->threadnum)
 										);
 
@@ -565,7 +565,7 @@ int tsg_scan_nesting_addr(Maat_feather_t maat_feather, const struct streaminfo *
 											maat_ret,
 											result[hit_num].config_id,
 											result[hit_num].service_id,
-											result[hit_num].action,
+											(unsigned char)result[hit_num].action,
 											printaddr(&a_stream->addr, a_stream->threadnum)
 										);
 
diff --git a/src/tsg_send_log.cpp b/src/tsg_send_log.cpp
index e21a822..3c6513a 100644
--- a/src/tsg_send_log.cpp
+++ b/src/tsg_send_log.cpp
@@ -19,7 +19,7 @@
 #include "tsg_send_log.h"
 #include "tsg_send_log_internal.h"
 
-char TSG_SEND_LOG_VERSION_20191129=0;
+char TSG_SEND_LOG_VERSION_20200119=0;
 struct tsg_log_instance_t *g_tsg_log_instance;
 
 
@@ -238,7 +238,7 @@ int TLD_append_streaminfo(struct tsg_log_instance_t *instance, struct TLD_handle
 	return 0;
 }
 
-int load_log_common_field(const char *filename, id2field_t *id2field, id2field_t *service2topic)
+int load_log_common_field(const char *filename, id2field_t *id2field, id2field_t **service2topic, int *max_service)
 {
 	int i=0;
 	int ret=0,id=0;
@@ -246,7 +246,8 @@ int load_log_common_field(const char *filename, id2field_t *id2field, id2field_t
 	char line[1024]={0};
 	char field_name[64]={0};
 	char type_name[32]={0};
-		
+	id2field_t *_service2topic=NULL;
+	
 	fp=fopen(filename, "r");
 	if(fp==NULL)
 	{
@@ -282,9 +283,36 @@ int load_log_common_field(const char *filename, id2field_t *id2field, id2field_t
 					default:
 						if((strncasecmp("TOPIC", type_name, strlen("TOPIC")))==0)
 						{
-							service2topic[id].type = TLD_TYPE_MAX;
-							service2topic[id].id = id;
-							memcpy(service2topic[id].name, field_name, strlen(field_name));
+							if(_service2topic==NULL)
+							{
+								_service2topic=(id2field_t *)calloc(1, sizeof(id2field_t)*(id+1));
+								_service2topic[id].type = TLD_TYPE_MAX;
+								_service2topic[id].id = id;
+								memcpy(_service2topic[id].name, field_name, strlen(field_name));
+
+								*max_service=id+1;
+							}
+							else
+							{
+								if(*max_service<=id)
+								{
+									_service2topic=(id2field_t *)realloc(_service2topic, sizeof(id2field_t)*(id+1));
+									memset(&_service2topic[id], 0, sizeof(id2field_t));
+									_service2topic[id].type = TLD_TYPE_MAX;
+									_service2topic[id].id = id;
+									memcpy(_service2topic[id].name, field_name, strlen(field_name));
+
+									*max_service=id+1;
+								}
+								else
+								{
+									memset(&_service2topic[id], 0, sizeof(id2field_t));
+									_service2topic[id].type = TLD_TYPE_MAX;
+									_service2topic[id].id = id;
+									memcpy(_service2topic[id].name, field_name, strlen(field_name));
+								}
+							}
+							
 						}
 						break;
 				}
@@ -296,6 +324,8 @@ int load_log_common_field(const char *filename, id2field_t *id2field, id2field_t
 	fclose(fp);
 	fp=NULL;
 
+	*service2topic=_service2topic;
+
 	return 0;
 }
 
@@ -314,7 +344,7 @@ struct tsg_log_instance_t *tsg_sendlog_init(const char *conffile)
 	_instance=(struct tsg_log_instance_t *)calloc(1, sizeof(struct tsg_log_instance_t));
 
 	MESA_load_profile_int_def(conffile, "TSG_LOG", "LOG_LEVEL",&(level), 30);	
-	MESA_load_profile_string_def(conffile, "TSG_LOG", "LOG_PATH", log_path, sizeof(log_path), NULL);
+	MESA_load_profile_string_def(conffile, "TSG_LOG", "LOG_PATH", log_path, sizeof(log_path), "./tsglog/tsglog");
 
 	_instance->logger=MESA_create_runtime_log_handle(log_path, level);
 	if(_instance->logger==NULL)
@@ -358,23 +388,26 @@ struct tsg_log_instance_t *tsg_sendlog_init(const char *conffile)
 		MESA_handle_runtime_log(_instance->logger, RLOG_LV_FATAL, "KAFKA_INIT", "rd_kafka_brokers_add is error, broker_list: %s", _instance->broker_list);
 		return NULL;
 	}
-
-	MESA_load_profile_int_def(conffile, "TSG_LOG", "MAX_SERVICE",&(_instance->max_service), 0);
-	//(_instance->topic_rkt)=(rd_kafka_topic_t **)calloc(1, sizeof(void *));
-	(_instance->topic_rkt)=(rd_kafka_topic_t **)calloc(1, (1+_instance->max_service)*sizeof(rd_kafka_topic_t*));
 	
-	_instance->service2topic=(id2field_t *)calloc(1, (1+_instance->max_service)*sizeof(id2field_t));
-	
-	load_log_common_field(_instance->common_field_file, _instance->id2field, _instance->service2topic);
+	load_log_common_field(_instance->common_field_file, _instance->id2field, &(_instance->service2topic), &(_instance->max_service));
 
-	for(i=0; i<_instance->max_service+1; i++)
+	if(_instance->service2topic!=NULL)
 	{
-		if(_instance->service2topic[i].type==TLD_TYPE_MAX)
+		_instance->topic_rkt=(rd_kafka_topic_t **)calloc(1, (_instance->max_service)*sizeof(rd_kafka_topic_t*));
+
+		for(i=0; i<_instance->max_service+1; i++)
 		{
-			topic_conf=rd_kafka_topic_conf_new();
-			_instance->topic_rkt[_instance->service2topic[i].id]=rd_kafka_topic_new(kafka_handle, _instance->service2topic[i].name, topic_conf);
+			if(_instance->service2topic[i].type==TLD_TYPE_MAX)
+			{
+				topic_conf=rd_kafka_topic_conf_new();
+				_instance->topic_rkt[_instance->service2topic[i].id]=rd_kafka_topic_new(kafka_handle, _instance->service2topic[i].name, topic_conf);
+			}
 		}
 	}
+	else
+	{
+		MESA_handle_runtime_log(_instance->logger, RLOG_LV_FATAL, "KAFKA_INIT", "load_log_common_field is error, please check %s", _instance->common_field_file);		
+	}
 	
 	return _instance;
 }
@@ -382,7 +415,7 @@ struct tsg_log_instance_t *tsg_sendlog_init(const char *conffile)
 
 int tsg_send_log(struct tsg_log_instance_t *instance, struct TLD_handle_t *handle, tsg_log_t *log_msg, int thread_id)
 {
-	int i=0,ret=0,status=0;
+	int i=0,status=0;
 	char *payload=NULL;
 	struct TLD_handle_t *_handle=handle;
 	struct tsg_log_instance_t *_instance=instance;
@@ -400,37 +433,10 @@ int tsg_send_log(struct tsg_log_instance_t *instance, struct TLD_handle_t *handl
 		MESA_handle_runtime_log(_instance->logger, RLOG_LV_INFO, "TSG_SEND_LOG", "Disable tsg_send_log.");
 		return 0;
 	}
-
-	//TODO
-	//common_user_tags
-	//common_isp
-	//common_app_label
-	//common_app_id
-	//common_protocol_id
-	//common_has_dup_traffic
-	//common_stream_error
 	
 	TLD_append_streaminfo(instance, handle, log_msg->a_stream);
 	TLD_append(_handle, _instance->id2field[LOG_COMMON_SLED_IP].name, (void *)(_instance->local_ip_str), TLD_TYPE_STRING);
 
-#if 0
-	struct vxlan_info vinfo;
-	int opt_val_len = sizeof(vinfo);
-	status=MESA_get_stream_opt(log_msg->a_stream, MSO_STREAM_VXLAN_INFO, &vinfo, &opt_val_len);
-	if(status < 0)
-	{
-		MESA_handle_runtime_log(_instance->logger, RLOG_LV_DEBUG, "TSG_SEND_LOG", "tsg log: get vxlan info error, tuple4: %s",  printaddr(&log_msg->a_stream->addr, thread_id));
-	}
-	else
-	{
-		TLD_append((TLD_handle_t)_handle, _instance->id2field[LOG_COMMON_LINK_ID].name, (void *)(long)vinfo.link_id, TLD_TYPE_LONG);	
-		TLD_append((TLD_handle_t)_handle, _instance->id2field[LOG_COMMON_DIRECTION].name, (void *)(long)vinfo.link_dir, TLD_TYPE_LONG);	
-		TLD_append((TLD_handle_t)_handle, _instance->id2field[LOG_COMMON_DEVICE_ID].name, (void *)(long)vinfo.dev_id, TLD_TYPE_LONG);		
-		TLD_append((TLD_handle_t)_handle, _instance->id2field[LOG_COMMON_ENTRANCE_ID].name, (void *)(long)vinfo.entrance_id, TLD_TYPE_LONG);	
-		TLD_append((TLD_handle_t)_handle, _instance->id2field[LOG_COMMON_ENCAPSULATION].name, (void *)(long)vinfo.encap_type, TLD_TYPE_LONG);
-	}
-#endif
-
 	for(i=0;i<log_msg->result_num; i++)
 	{
 		switch(log_msg->result[i].do_log)
@@ -457,33 +463,6 @@ int tsg_send_log(struct tsg_log_instance_t *instance, struct TLD_handle_t *handl
 		TLD_append(_handle, _instance->id2field[LOG_COMMON_SERVICE].name, (void *)(long)(log_msg->result[i].service_id), TLD_TYPE_LONG);
 		TLD_append(_handle, _instance->id2field[LOG_COMMON_ACTION].name, (void *)(long)((unsigned char)log_msg->result[i].action), TLD_TYPE_LONG);
 
-		if(log_msg->result[i].serv_def_len<128)
-		{
-			TLD_append(_handle, _instance->id2field[LOG_COMMON_USER_REGION].name, (void *)(log_msg->result[i].service_defined), TLD_TYPE_STRING);
-		}
-		else
-		{
-			char *service_defined=(char *)calloc(1, log_msg->result[i].serv_def_len+1);
-			ret=Maat_read_rule(g_tsg_maat_feather, &log_msg->result[i], MAAT_RULE_SERV_DEFINE, service_defined, log_msg->result[i].serv_def_len);
-			if(ret==log_msg->result[i].serv_def_len)
-			{
-				TLD_append(_handle, _instance->id2field[LOG_COMMON_USER_REGION].name, (void *)service_defined, TLD_TYPE_STRING);			
-			}
-			else
-			{
-				MESA_handle_runtime_log(_instance->logger,
-										RLOG_LV_FATAL, 
-										"TSG_SEND_LOG",
-										"Fetch service_defined failed, policy_id: %d service: %d action: %d addr: %s",
-										log_msg->result[i].config_id,
-										log_msg->result[i].service_id,
-										log_msg->result[i].action,
-										printaddr(&log_msg->a_stream->addr, thread_id));
-			}
-			free((void *)service_defined);
-			service_defined=NULL;
-		}
-
 		payload = cJSON_PrintUnformatted(_handle->object);
 
 		status = rd_kafka_produce(_instance->topic_rkt[log_msg->result[i].service_id], RD_KAFKA_PARTITION_UA, RD_KAFKA_MSG_F_COPY, payload, strlen(payload), NULL, 0, NULL);			
@@ -506,7 +485,6 @@ int tsg_send_log(struct tsg_log_instance_t *instance, struct TLD_handle_t *handl
 		TLD_delete(_handle, _instance->id2field[LOG_COMMON_POLICY_ID].name);
 		TLD_delete(_handle, _instance->id2field[LOG_COMMON_SERVICE].name);
 		TLD_delete(_handle, _instance->id2field[LOG_COMMON_ACTION].name);
-		TLD_delete(_handle, _instance->id2field[LOG_COMMON_USER_REGION].name);
 
 		FS_operate(g_tsg_para.fs2_handle, g_tsg_para.fs2_field_id[TSG_FS2_LOG], 0, FS_OP_ADD, 1);
 	}
diff --git a/src/tsg_statistic.cpp b/src/tsg_statistic.cpp
index f835776..b369091 100644
--- a/src/tsg_statistic.cpp
+++ b/src/tsg_statistic.cpp
@@ -60,6 +60,15 @@ static int _get_traffic_info(struct _traffic_info *total, struct _traffic_info *
 		out->in_packets=total->in_packets-policy->in_packets;
 		out->out_bytes=total->out_bytes-policy->out_bytes;
 		out->out_packets=total->out_packets-policy->out_packets;
+
+		if(out->con_num<0 || out->in_bytes<0 || out->in_packets<0 || out->out_bytes<0 || out->out_packets<0)
+		{
+			out->con_num=total->con_num;
+			out->in_bytes=total->in_bytes;
+			out->in_packets=total->in_packets;
+			out->out_bytes=total->out_bytes;
+			out->out_packets=total->out_packets;
+		}
 	}
 	return 0;
 }
@@ -130,25 +139,13 @@ static int _set_traffic_info(struct _traffic_info *from, struct _traffic_info *t
 			in_packets_id=STATIS_DEFAULT_IN_PACKETS;
 			out_bytes_id=STATIS_DEFAULT_OUT_BYTES;
 			out_packets_id=STATIS_DEFAULT_OUT_PACKETS;
-
-			con_num_sum+=from->con_num;
-			in_bytes_sum+=from->in_bytes;
-			in_packets_sum+=from->in_packets;
-			out_bytes_sum+=from->out_bytes;
-			out_packets_sum+=from->out_packets;
 			break;
 		case	-1:
-			con_num_id=STATIS_TOTAL_CON_NUM;
+			con_num_id=STATIS_NEW_CON_NUM;
 			in_bytes_id=STATIS_TOTAL_IN_BYTES;
 			in_packets_id=STATIS_TOTAL_IN_PACKETS;
 			out_bytes_id=STATIS_TOTAL_OUT_BYTES;
 			out_packets_id=STATIS_TOTAL_OUT_PACKETS;
-			
-			con_num_sum+=from->con_num;
-			in_bytes_sum+=from->in_bytes;
-			in_packets_sum+=from->in_packets;
-			out_bytes_sum+=from->out_bytes;
-			out_packets_sum+=from->out_packets;
 			break;
 		default:
 			return 0;
@@ -180,21 +177,25 @@ static void *tsg_statistic_thread(void *arg)
 		memset(&total_traffic_info, 0, sizeof(total_traffic_info));
 		memset(&default_traffic_info, 0, sizeof(default_traffic_info));
 
-		value=0;
-		sapp_get_platform_opt(SPO_TCP_STREAM_NEW, (void *)&value, &value_len);
-		total_traffic_info.con_num+=value;
-		FS_operate(g_tsg_statis_para.fs2_handle, g_tsg_statis_para.fs_line_id, g_tsg_statis_para.fs_field_id[STATIS_NEW_CON_NUM], FS_OP_SET, value);
+		_set_traffic_info(g_tsg_statis_para.traffic_info[TSG_ACTION_BYPASS], &policy_traffic_info, TSG_ACTION_BYPASS, thread_num);
+		_set_traffic_info(g_tsg_statis_para.traffic_info[TSG_ACTION_DENY], &policy_traffic_info, TSG_ACTION_DENY, thread_num);
+		_set_traffic_info(g_tsg_statis_para.traffic_info[TSG_ACTION_MONITOR], &policy_traffic_info, TSG_ACTION_MONITOR, thread_num);
+		_set_traffic_info(g_tsg_statis_para.traffic_info[TSG_ACTION_INTERCEPT], &policy_traffic_info, TSG_ACTION_INTERCEPT, thread_num);
 		
 		value=0;
 		sapp_get_platform_opt(SPO_TCP_STREAM_ESTAB, (void *)&value, &value_len);
-		total_traffic_info.con_num+=value;
 		FS_operate(g_tsg_statis_para.fs2_handle, g_tsg_statis_para.fs_line_id, g_tsg_statis_para.fs_field_id[STATIS_ESTABLISHED_CON_NUM], FS_OP_SET, value);
 		
 		value=0;
 		sapp_get_platform_opt(SPO_TCP_STREAM_CLOSE, (void *)&value, &value_len);
-		total_traffic_info.con_num+=value;
 		FS_operate(g_tsg_statis_para.fs2_handle, g_tsg_statis_para.fs_line_id, g_tsg_statis_para.fs_field_id[STATIS_CLOSE_CON_NUM], FS_OP_SET, value);
 
+		value=0;
+		sapp_get_platform_opt(SPO_TCP_STREAM_NEW, (void *)&value, &value_len);
+		FS_operate(g_tsg_statis_para.fs2_handle, g_tsg_statis_para.fs_line_id, g_tsg_statis_para.fs_field_id[STATIS_NEW_CON_NUM], FS_OP_SET, value);
+
+		total_traffic_info.con_num+=value;
+
 		value_len=sizeof(total_traffic_info.in_bytes);
 		sapp_get_platform_opt(SPO_TOTAL_INBOUND_BYTE, (void *)&total_traffic_info.in_bytes, &value_len);
 		value_len=sizeof(total_traffic_info.in_packets);
@@ -204,16 +205,11 @@ static void *tsg_statistic_thread(void *arg)
 		sapp_get_platform_opt(SPO_TOTAL_OUTBOUND_BYTE, (void *)&total_traffic_info.out_bytes, &value_len);
 		value_len=sizeof(total_traffic_info.out_packets);
 		sapp_get_platform_opt(SPO_TOTAL_OUTBOUND_PKT, (void *)&total_traffic_info.out_packets, &value_len);
-		
-		_set_traffic_info(g_tsg_statis_para.traffic_info[TSG_ACTION_BYPASS], &policy_traffic_info, TSG_ACTION_BYPASS, thread_num);
-		_set_traffic_info(g_tsg_statis_para.traffic_info[TSG_ACTION_DENY], &policy_traffic_info, TSG_ACTION_DENY, thread_num);
-		_set_traffic_info(g_tsg_statis_para.traffic_info[TSG_ACTION_MONITOR], &policy_traffic_info, TSG_ACTION_MONITOR, thread_num);
-		_set_traffic_info(g_tsg_statis_para.traffic_info[TSG_ACTION_INTERCEPT], &policy_traffic_info, TSG_ACTION_INTERCEPT, thread_num);
 
-		_set_traffic_info(&total_traffic_info, NULL, -1, 0);
+		_set_traffic_info(&total_traffic_info, NULL, -1, 1);
 		
 		_get_traffic_info(&total_traffic_info, &policy_traffic_info, &default_traffic_info);
-		_set_traffic_info(&default_traffic_info, NULL, TSG_ACTION_NONE, 0);
+		_set_traffic_info(&default_traffic_info, NULL, TSG_ACTION_NONE, 1);
 
 		FS_passive_output(g_tsg_statis_para.fs2_handle);
 		
diff --git a/src/version.map b/src/version.map
index ceb1542..fbc44bc 100644
--- a/src/version.map
+++ b/src/version.map
@@ -4,6 +4,7 @@ global:
 		g_*;
 		*TSG_MASTER_INIT*;
 		*TSG_MASTER_TCP_ENTRY*;
+		*TSG_MASTER_UDP_ENTRY*;
 		*TSG_MASTER_UNLOAD*;
   		*tsg_scan_nesting_addr*;
 		*tsg_pull_policy_result*;