支持cmake, 与并联版本部分同步.

author: lijia <[email protected]> 2018-11-16 17:57:27 +0800
committer: lijia <[email protected]> 2018-11-16 17:57:27 +0800
commit: 26edec5e1555f30006af50b3fbba364bdd58b88f (patch)
tree: c4247091bb361fda4cb0e3edb5d0d1e2adb496ba
parent: ff19403215eae57355ee6cb19c565557c32e433c (diff)
48 files changed, 2487 insertions, 397 deletions
diff --git a/.gitignore b/.gitignore
index 8a2ff4e..4ea2af1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,12 @@
-*.a
+SI/
+*.log
+*.o
 *.so
+*.si4project/
+*.a
 *.o
-*.log
-\ No newline at end of file
+*.d
+build/
+.idea/
+run/log/
+run/sapp
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..0b98ce9
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,83 @@
+
+cmake_minimum_required(VERSION 2.8)
+
+set(CMAKE_MACOSX_RPATH 0)
+
+# MESA SDK Root
+set(MESA_SDK_PREFIX "/opt/MESA/" CACHE STRING "MESA Framework Prefix")
+# Capture Mode
+option(OPT_IOMODE_PCAP "Capture network traffic with libpcap" ON)
+option(OPT_IOMODE_PAG "Capture network traffic with libpag" OFF)
+option(OPT_IOMODE_PPF "Capture network traffic with libppf" OFF)
+option(OPT_IOMODE_PFRING "Capture network traffic with PF-RING" OFF)
+option(OPT_IOMODE_DPDK "Capture network traffic with DPDK" OFF)
+option(OPT_IOMODE_PAG_N95 "Capture network traffic with N95" OFF)
+
+if(OPT_IOMODE_PCAP)
+	set(CAPTURE_MODE "PCAP")	
+endif()
+
+if(OPT_IOMODE_PAG)
+	set(CAPTURE_MODE "PAG")
+endif()
+
+if(OPT_IOMODE_PPF)
+	set(CAPTURE_MODE "PPF")
+endif()
+
+if(OPT_IOMODE_PFRING)
+	set(CAPTURE_MODE "PFRING")
+endif()
+
+if(OPT_IOMODE_DPDK)
+	set(CAPTURE_MODE "DPDK")
+endif()
+
+if(OPT_IOMODE_PAG_N95)
+	set(CAPTURE_MODE "PAG_N95")
+endif()
+
+if(CAPTURE_MODE MATCHES "PCAP")
+    set(CAPTURE_DEFINITIONS -DONLY_PCAP -DIOMODE_PCAP)
+endif()
+
+if(CAPTURE_MODE MATCHES "PAG")
+	set(CAPTURE_DEFINITIONS -DCAPTURE_MODE_PAG)
+endif()
+
+if(CAPTURE_MODE MATCHES "PPF")
+	set(CAPTURE_DEFINITIONS -DCAPTURE_MODE_PPF)
+endif()
+
+if(CAPTURE_MODE MATCHES "PFRING")
+	set(CAPTURE_DEFINITIONS -DCAPTURE_MODE_PFRING)
+endif()
+
+if(CAPTURE_MODE MATCHES "DPDK")
+	set(CAPTURE_DEFINITIONS -DCAPTURE_MODE_DPDK)
+endif()
+
+# Memory Allocator
+option(OPT_USE_DICTATOR	"Use Dictator2 memory allocator" OFF)
+option(OPT_USE_TXMEM "Use Dictator2 for TileGX memory allocator" OFF)
+option(OPT_USE_TCMALLOC "Use TCmalloc memory allocator" OFF)
+option(OPT_USE_JEMALLOC "Use JEmalloc memory allocator" OFF)
+
+if(OPT_USE_DICTATOR)
+	set(MEM_POOL_DEFINITIONS -DUSE_MEM_POOL=1)
+endif()
+
+add_definitions(${CAPTURE_DEFINITIONS} ${MEM_POOL_DEFINITIONS} -D__FAVOR_BSD=1
+    -D__USE_BSD=1 -D_GNU_SOURCE=1  -DMESA_SAPP_PLATFORM=1)
+
+set(SAPP_DEPEND_DYN_LIB  MESA_handle_logger MESA_htable pthread MESA_field_stat2)
+
+#set(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG -fno-inline")
+
+add_subdirectory(support)
+add_subdirectory(dealpkt)
+add_subdirectory(packet_io)
+add_subdirectory(plugin)
+add_subdirectory(project)
+add_subdirectory(inner_plug)
+add_subdirectory(entry)
diff --git a/Makefile b/Makefile
index 4f2fcff..b3e8932 100644
--- a/Makefile
+++ b/Makefile
@@ -260,6 +260,7 @@ all:
 	cd entry; $(MAKE);
 
 clean:
+	rm -rf build;
 	rm -f run/sapp;
 	rm -f run/MESA_IP_PLUG.so;
 	rm -f lib/*.a;
diff --git a/cmake-makefile b/cmake-makefile
new file mode 100644
index 0000000..c8aae2e
--- /dev/null
+++ b/cmake-makefile
@@ -0,0 +1,41 @@
+BUILD_DIR = $(CURDIR)/build
+LOCAL_DIR = $(CURDIR)
+DEBUG_FLAGS = -DCMAKE_BUILD_TYPE=Debug
+REL_FLAGS = -DCMAKE_BUILD_TYPE=RelWithDebInfo
+
+ifneq ($(INSTALL_PREFIX),)
+DEBUG_FLAGS += -DCMAKE_INSTALL_PREFIX=$(INSTALL_PREFIX)
+REL_FLAGS += -DCMAKE_INSTALL_PREFIX=$(INSTALL_PREFIX)
+endif
+
+all: _make_build_dir _compile_rel
+
+PHONY: all _make_build_dir _compile_debug _compile_rel _install \
+	   build_release build_debug install
+
+_make_build_dir:
+	mkdir -p $(BUILD_DIR)
+
+_compile_debug:
+	cd $(BUILD_DIR) && cmake $(LOCAL_DIR) $(DEBUG_FLAGS) && make
+
+_compile_rel:
+	cd $(BUILD_DIR) && cmake $(LOCAL_DIR) $(REL_FLAGS) && make
+
+_install:
+	cd $(BUILD_DIR) && make install
+_package:
+	cd $(BUILD_DIR) && make package
+_clean:
+	rm -rf $(BUILD_DIR)
+	
+# Release Version, No Debug Symbol and Optimized with -O2
+release: _make_build_dir _compile_rel
+# Debug Version, Optimized with -O0
+debug: _make_build_dir _compile_debug _install
+# Install
+install: _install
+# Package
+package: _package
+# Clean
+clean: _clean
diff --git a/dealpkt/CMakeLists.txt b/dealpkt/CMakeLists.txt
new file mode 100644
index 0000000..cf83ef9
--- /dev/null
+++ b/dealpkt/CMakeLists.txt
@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 2.8)
+
+include_directories(${MESA_SDK_PREFIX}/include)
+include_directories(${MESA_SDK_PREFIX}/include/MESA)
+include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+include_directories(${CMAKE_SOURCE_DIR}/project)
+include_directories(${CMAKE_SOURCE_DIR}/include)
+include_directories(${CMAKE_SOURCE_DIR}/include/net)
+include_directories(${CMAKE_SOURCE_DIR}/include/stream_inc)
+include_directories(${CMAKE_SOURCE_DIR}/include/support)
+include_directories(${CMAKE_SOURCE_DIR}/dealpkt)
+
+add_definitions(-D_BSD_SOURCE -D_BSD_SOURCE -D__BSD_SOURCE -D__FAVOR_BSD -DHAVE_NET_ETHERNET_H)
+add_definitions(-DPLATFORM_NSDPF_PAPP=1)
+
+add_library(dealpkt STATIC callapp.c deal_ipv4.c deal_mpls.c deal_tcp.c  hash.c plug_support.c
+deal_arp.c       deal_ipv6.c        deal_ppp.c    deal_teredo.c  ip_reassembly.c       stream_addr_inet.c
+deal_ethernet.c  deal_isakmp.c      deal_pppoe.c  deal_udp.c     linux_kernel_jhash.c  stream_manage.c
+deal_gre.c       deal_l2tp.c        deal_pptp.c   deal_vlan.c    MESA_stream_hash.c    synflood_detect.c
+deal_icmp.c      deal_mac_in_mac.c  deal_proxy.c  g_device.c     net_common.c
+deal_gprs_tunnel.c)
diff --git a/dealpkt/callapp.c b/dealpkt/callapp.c
index 0010b8c..bd38662 100644
--- a/dealpkt/callapp.c
+++ b/dealpkt/callapp.c
@@ -72,11 +72,11 @@ extern int G_TCP_FLOW_STAT_PROJECT_ID;
 #ifdef IIEFD_DUAL_STACK
 static int judge_pure_ipv4_stack(const struct streaminfo *pstream, const void *a_packet);
 /* iiefd�����е��ܻص�����, ֻ�д�IPv4�İ��Ŵ��� */
-extern "C" char calltcpApp_old(struct streaminfo *pstream,void **pme, int thread_seq,void *a_packet);
-extern "C" char callIpApp_old(struct streaminfo *pstream,int routedir, int thread_seq,void *a_packet);
+extern  char calltcpApp_old(struct streaminfo *pstream,void **pme, int thread_seq,void *a_packet);
+extern  char callIpApp_old(struct streaminfo *pstream,int routedir, int thread_seq,void *a_packet);
 #endif
 
-extern "C" void timestamp_record(enum timestamp_level level, const raw_pkt_t *raw_pkt, int thread_seq);
+extern  void timestamp_record(enum timestamp_level level, const raw_pkt_t *raw_pkt, int thread_seq);
 
 /* 2014-12-31 lqy add */
 int stream_register_funtoArray(int funtype,char (*x)(void),stFunArray *pArrary,int *pNum)
diff --git a/dealpkt/deal_gprs_tunnel.c b/dealpkt/deal_gprs_tunnel.c
new file mode 100644
index 0000000..99862f4
--- /dev/null
+++ b/dealpkt/deal_gprs_tunnel.c
@@ -0,0 +1,188 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "stream_internal.h" 
+#include "stream_manage.h"
+#include "mesa_net.h"
+#include "sysinfo.h"
+#include "MESA_htable.h"
+
+#define GPRS_TUNNEL_PORT (2152)
+
+
+MESA_htable_handle g_gtp_info_hash[MAX_THREAD_NUM];
+
+extern int ipv4_entry(struct streaminfo_private *pfstream, const void *this_layer_data, int thread_num,
+                      unsigned char routedir, const raw_pkt_t *raw_pkt, int);
+
+extern int ipv6_entry(struct streaminfo_private *pfstream, const void *this_layer_data, int thread_num,
+                      unsigned char routedir, const raw_pkt_t *raw_pkt, int);
+
+int gtp_entry(struct streaminfo_private *pfstream_pr,void *this_layer_data,int thread_num, 
+		unsigned char routedir, const raw_pkt_t *raw_pkt, int offset_to_raw_pkt_hdr)
+{
+	/*
+		����gtp��ṹ, �ֱ��¼C2S, S2C����ĵ�ַ, 
+	*/
+    struct streamindex tmp_index;
+    struct streamindex *ptmp=&tmp_index;
+    struct streaminfo_private *pstream_pr = &ptmp->stream;
+    struct streaminfo *pstream = &pstream_pr->stream_public;
+    struct layer_addr_gtp gtpaddr;
+    const struct gtp_hdr *p_gtd_hdr;
+    int ret = PASS;
+    char *next_layer_hdr;
+    int next_layer_offset;
+    unsigned int cur_seq = 0, seq_offset = 0;
+
+
+    /* ֮ǰ�Ѿ�ͨ��Э��ʶ����ʶ���, ������entry()�ﲻ���ٴ��ж� */
+    p_gtd_hdr = (const struct gtp_hdr *)((char *)this_layer_data + sizeof(struct mesa_udp_hdr));
+
+    /* ������T-PDU���͵���������Ϣ�������治��Ϊ��GTP����*/
+    if(p_gtd_hdr->msg_type != GTP_MSG_TYPE_T_PDU)
+    {
+        sapp_runtime_log(10, "GTP layer msg_type not T_PDU, %x !\n", p_gtd_hdr->msg_type);
+        return PASS;
+    }
+    if(p_gtd_hdr->flags != 0x30 && p_gtd_hdr->flags != 0x32)
+    {
+        sapp_runtime_log(20, "GTP layer flag not 0x30, %x !\n", p_gtd_hdr->flags);
+        return PASS;
+    }
+
+    if(p_gtd_hdr->flags == 0x32)
+    {
+        cur_seq = ntohl(*(unsigned int *)(p_gtd_hdr + 1));
+        seq_offset = sizeof(unsigned int);
+    }
+
+    g_SysInputInfo[thread_num][TUNNEL_GTP]++;
+
+    memset(&tmp_index, 0, sizeof(struct streamindex));
+    memset(&gtpaddr, 0, sizeof(struct layer_addr_gtp));
+    /* GTP��ַC2S, S2C�������, �޷�����ǰ����ַ����dir, ÿ��ջ��ı������洢��source����, ��C2S����,  
+       ������ʱ, �����Ҫreverse����, ��source, dest�ߵ�, ����ֱ��memcpy�������addr.
+     */
+    memcpy(&gtpaddr.source, p_gtd_hdr, sizeof(struct gtp_hdr));
+    gtpaddr.src_seq = cur_seq;
+    pstream->curdir = DIR_C2S;
+
+    
+    pstream->addr.paddr = &gtpaddr;
+    pstream->addr.addrtype = ADDR_TYPE_GPRS_TUNNEL;
+    pstream->addr.addrlen = sizeof(struct layer_addr_gtp); /* �˴�ʹ�ýṹ�峤�� */
+
+    pstream_pr->addr_use_as_hash = 0;//��ַ������hash�ȶԣ��������
+    pstream_pr->need_update_opposite_addr = 1;//��Ҫ���¶Բ���Ϣ
+
+    pstream_pr->offset_to_raw_pkt_hdr = (unsigned short)offset_to_raw_pkt_hdr;
+    pstream_pr->raw_pkt = raw_pkt;
+    pstream_pr->layer_dir = pfstream_pr->layer_dir;  
+
+    pstream->pfather=&pfstream_pr->stream_public;
+    pstream->type=STREAM_TYPE_NON;
+    pstream->routedir=routedir;
+    pstream->threadnum=(UCHAR)thread_num;
+
+    next_layer_hdr = (char *)p_gtd_hdr + sizeof(struct gtp_hdr) + seq_offset;
+    next_layer_offset = offset_to_raw_pkt_hdr + sizeof(struct gtp_hdr) + seq_offset;
+
+    if((*next_layer_hdr & 0xF0) == 0x40)
+    {
+        ret = ipv4_entry(pstream_pr,next_layer_hdr,thread_num,routedir,raw_pkt, next_layer_offset);
+    }
+    else if((*next_layer_hdr & 0xF0) == 0x60)
+    {
+        ret = ipv6_entry(pstream_pr,next_layer_hdr,thread_num,routedir,raw_pkt, next_layer_offset);
+    }
+    else
+    {
+        sapp_runtime_log(20, "GTP next layer not IPv4 or IPv6, drop pkt !\n");
+        return PASS;
+    }
+    return ret;
+}
+
+
+static int identify_gtp(const struct streaminfo *pstream,const char *payload, unsigned int payload_len)
+{
+    if (payload_len >= sizeof(struct gtp_hdr))
+    {
+        unsigned int gtp_u = (2152);
+        unsigned int gtp_c = (2123);
+        unsigned int gtp_v0 = (3386);
+
+        unsigned short dest = 0, source = 0;
+
+        if (pstream->addr.addrtype == __ADDR_TYPE_IP_PAIR_V6
+            || pstream->addr.addrtype == ADDR_TYPE_IPV6) {
+            dest = ntohs(pstream->addr.ipv6->dest);
+            source = ntohs(pstream->addr.ipv6->source);
+        } else {
+            dest = ntohs(pstream->addr.ipv4->dest);
+            source = ntohs(pstream->addr.ipv4->source);
+        }
+
+        if ((source == gtp_u) || (dest == gtp_u) || (source == gtp_c)
+            || (dest == gtp_c) || (source == gtp_v0) || (dest == gtp_v0)) {
+            struct gtp_hdr *gtp =
+                    (struct gtp_hdr *) payload;
+            unsigned short gtp_version = (gtp->flags & 0xE0) >> 5;
+
+            if ((gtp_version == 0) || (gtp_version == 1) || (gtp_version == 2)) {
+                unsigned short message_len = ntohs(gtp->len);
+
+                if (message_len == (payload_len - sizeof(struct gtp_hdr))) {
+                    return 1;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+/*
+	���ò��, 
+	����ʶ��ǰUDP���Ƿ�������.
+	���������, ��streaminfo_private->stream_carry_up_layer_tunnel_type�����ñ��.
+*/
+char udp_gtp_identify_entry(const struct streaminfo *pstream, const void *this_hdr, const void *raw_pkt, void **pme)
+{
+#if 0
+	if(pstream->addr.addrtype == ADDR_TYPE_IPV4)
+	{
+		if(ntohs(pstream->addr.tuple4_v4->dest) == GPRS_TUNNEL_PORT && ntohs(pstream->addr.tuple4_v4->source) == GPRS_TUNNEL_PORT)
+        {
+            struct streaminfo_private *pstream_pr = (struct streaminfo_private *)pstream;
+            pstream_pr->stream_carry_up_layer_tunnel_type |= STREAM_TUNNEL_GPRS_TUNNEL;
+        }
+	}
+    else if(pstream->addr.addrtype == ADDR_TYPE_IPV6)
+    {
+        if(ntohs(pstream->addr.tuple4_v6->dest) == GPRS_TUNNEL_PORT && ntohs(pstream->addr.tuple4_v6->source) == GPRS_TUNNEL_PORT)
+        {
+            struct streaminfo_private *pstream_pr = (struct streaminfo_private *)pstream;
+            pstream_pr->stream_carry_up_layer_tunnel_type |= STREAM_TUNNEL_GPRS_TUNNEL;
+        }
+    }
+    else
+        ;
+#else
+    struct streaminfo_private *pstream_pr = (struct streaminfo_private *)pstream;
+    if(1 == identify_gtp(pstream, (char *)this_hdr+sizeof(struct mesa_udp_hdr), 
+    					pstream_pr->raw_pkt->raw_pkt_len - ((const char *)this_hdr - (const char*)pstream_pr->raw_pkt->raw_pkt_data) - sizeof(struct mesa_udp_hdr)))
+    {
+        pstream_pr->stream_carry_up_layer_tunnel_type |= STREAM_TUNNEL_GPRS_TUNNEL;
+    }
+#endif
+	return APP_STATE_DROPME; /* ÿ����ֻ����һ����, �����Ƿ�GTP����, ���������ٴ����� */
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
diff --git a/dealpkt/deal_ipv4.h b/dealpkt/deal_ipv4.h
index a815d12..cc7168f 100644
--- a/dealpkt/deal_ipv4.h
+++ b/dealpkt/deal_ipv4.h
@@ -60,7 +60,7 @@ extern "C" {
 #endif
 
 /* �Ƿ�ΪIPv4˽�е�ַ */
-inline int is_private_addr_v4(u_int ip_add)
+static inline int is_private_addr_v4(u_int ip_add)
 {
 /* 10/8 */
 #define IPV4_LOCAL_CLASS_A(_add) (((_add&0xFF000000)==0x0A000000)?1:0) 
@@ -80,7 +80,7 @@ inline int is_private_addr_v4(u_int ip_add)
 }
 
 /* �Ƿ�ΪIPv4�鲥��ַ */
-inline int is_multicast_addr_v4(u_int ip_add)
+static inline int is_multicast_addr_v4(u_int ip_add)
 {
 /* 224~239 */
 #define IPV4_MULTICAST_ADDR(_add) (((_add&0xF0000000)==0xE0000000)?1:0) 
diff --git a/dealpkt/deal_mac_in_mac.c b/dealpkt/deal_mac_in_mac.c
new file mode 100644
index 0000000..ed5feb2
--- /dev/null
+++ b/dealpkt/deal_mac_in_mac.c
@@ -0,0 +1,111 @@
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "stream_internal.h"
+#include "sendpacket.h"
+#include "stream_manage.h"
+#include "packet_io.h"	
+#include "packet_io_internal.h"	
+#include <linux/if_ether.h>
+
+
+extern int g_skip_ethernet_layer_sw;
+
+static void set_mac_in_mac_addr(const struct mesa_ethernet_hdr *outer_ether_hdr,
+    const struct mesa_ethernet_hdr *inner_ether_hdr, struct layer_addr_mac_in_mac *mim_addr)
+{
+	memcpy(mim_addr->outer_dst_mac, outer_ether_hdr->ether_dhost, ETHER_ADDR_LEN);
+	memcpy(mim_addr->outer_src_mac, outer_ether_hdr->ether_shost, ETHER_ADDR_LEN);
+	
+	memcpy(mim_addr->inner_dst_mac, inner_ether_hdr->ether_dhost, ETHER_ADDR_LEN);
+	memcpy(mim_addr->inner_src_mac, inner_ether_hdr->ether_shost, ETHER_ADDR_LEN);
+}
+
+
+/* 2018-08-19 lijia add, for PanGu��Ŀ��������������ʽ, ������ETH_P_8021AD�ֶ�, ʵ����MAC-IN-MAC��ʽ���ݰ�,
+	outer_mac--inner_mac--ipv4/6--tcp/udp---layer7.
+*/
+int mac_in_mac_entry(struct streaminfo_private *fstream_pr, const void *this_layer_hdr,int thread_num, 
+			unsigned char dir, const raw_pkt_t *raw_pkt, int offset_to_raw_pkt_hdr)
+{
+	struct layer_addr_mac_in_mac mim_addr;
+	struct streamindex tmp_index;
+	struct streamindex *ptmp;
+	struct streaminfo_private *pstream_pr;
+	struct streaminfo *pstream;
+	const struct mesa_ethernet_hdr *outer_ether_hdr;
+	const struct mesa_ethernet_hdr *inner_ether_hdr;
+	//const struct mesa_vlan_detail_hdr *vlan_hdr;
+	const  unsigned char *next_layer_data;
+	int next_layer_offset,  ret;
+
+	memset(&tmp_index, 0, sizeof(struct streamindex));
+	ptmp = &tmp_index;
+	pstream_pr = &ptmp->stream;
+	pstream = &pstream_pr->stream_public;
+
+	if(unlikely(0 == g_skip_ethernet_layer_sw)){
+		outer_ether_hdr = (struct mesa_ethernet_hdr *)raw_pkt->raw_pkt_data;
+		inner_ether_hdr = (struct mesa_ethernet_hdr *)((char *)raw_pkt->raw_pkt_data + sizeof(struct mesa_ethernet_hdr));
+		////vlan_hdr = (struct mesa_vlan_detail_hdr *)((char *)outer_ether_hdr + sizeof(struct mesa_ethernet_hdr));
+		
+		next_layer_data = (unsigned char *)inner_ether_hdr + sizeof(struct mesa_ethernet_hdr);
+		next_layer_offset = sizeof(struct mesa_ethernet_hdr) + sizeof(struct mesa_ethernet_hdr);
+		
+		set_mac_in_mac_addr(outer_ether_hdr, inner_ether_hdr, &mim_addr);
+
+		pstream->addr.addrtype = ADDR_TYPE_MAC_IN_MAC;
+		pstream->addr.addrlen = sizeof(struct layer_addr_mac_in_mac);
+		pstream->addr.paddr = &mim_addr;
+		pstream_pr->addr_use_as_hash = 0;
+	}else{
+		pstream_pr = NULL; /* ʹ�ϲ����Э���pfatherΪNULL */
+		next_layer_offset = 0;
+		if((int)CAP_LEVEL_MAC == (int)raw_pkt->low_layer_type){
+			((raw_pkt_t *)raw_pkt)->raw_pkt_data = (char *)raw_pkt->__lib_raw_pkt_data + sizeof(struct mesa_ethernet_hdr);
+			((raw_pkt_t *)raw_pkt)->raw_pkt_len = raw_pkt->__lib_raw_pkt_len - sizeof(struct mesa_ethernet_hdr);
+		}
+	}
+
+	switch(ntohs(inner_ether_hdr->ether_type)){
+		case ETHERTYPE_IP:	
+			if(g_skip_ethernet_layer_sw){
+				((raw_pkt_t *)raw_pkt)->low_layer_type = (enum addr_type_t)CAP_LEVEL_IPV4;
+			}
+			((raw_pkt_t *)raw_pkt)->offset_to_raw_pkt_hdr = next_layer_offset;
+			ret = ipv4_entry(pstream_pr, (const void *)next_layer_data, thread_num, dir, raw_pkt, next_layer_offset);
+		break;
+
+		case ETHERTYPE_IPv6:
+			if(g_skip_ethernet_layer_sw){
+				((raw_pkt_t *)raw_pkt)->low_layer_type = (enum addr_type_t)CAP_LEVEL_IPV6;
+			}
+			((raw_pkt_t *)raw_pkt)->offset_to_raw_pkt_hdr = next_layer_offset;
+			ret = ipv6_entry(pstream_pr, (const void *)next_layer_data, thread_num, dir, raw_pkt, next_layer_offset);
+		break;
+
+		case ETH_P_MPLS_UC: 
+			((raw_pkt_t *)raw_pkt)->offset_to_raw_pkt_hdr = next_layer_offset;
+			ret = mpls_uc_entry(pstream_pr, (const void *)next_layer_data, thread_num, dir, raw_pkt, next_layer_offset);
+		break;
+		
+		default:
+			/* unknown protocol */	
+			g_SysInputInfo[thread_num][PKT_UNKNOWN]++;
+			g_SysInputInfo[thread_num][PKT_UNKNOWN_LEN] += raw_pkt->raw_pkt_len;		
+			sapp_runtime_log(20, "MAC-IN-MAC unknown protocol: 0x%x\n", ntohs(inner_ether_hdr->ether_type));
+			ret = PASS;
+		break;
+	}
+
+	return ret;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
diff --git a/dealpkt/deal_mpls.c b/dealpkt/deal_mpls.c
index 4991e8e..1792f30 100644
--- a/dealpkt/deal_mpls.c
+++ b/dealpkt/deal_mpls.c
@@ -35,7 +35,7 @@ int mpls_uc_entry(struct streaminfo_private *pfstream_pr,const void *this_layer_
 	char *next_layer_hdr = (char *)this_layer_data+ sizeof(struct mesa_mpls_hdr);
 	int next_layer_offset = offset_to_raw_pkt_hdr + sizeof(struct mesa_mpls_hdr);
 
-	this_mpls_hdr.mpls_label = (ntohl(*mpls_pkt_data) & MPLS_LABEL_MASK) >> 12;
+	//this_mpls_hdr.mpls_label = (ntohl(*mpls_pkt_data) & MPLS_LABEL_MASK) >> 12;
 	this_mpls_hdr.mpls_exp = (ntohl(*mpls_pkt_data) & MPLS_EXP_MASK) >> 9;
 	this_mpls_hdr.mpls_bls = (ntohl(*mpls_pkt_data) & MPLS_BLS_MASK) >> 8;
 	this_mpls_hdr.mpls_ttl = (ntohl(*mpls_pkt_data) & MPLS_TTL_MASK);
@@ -46,7 +46,7 @@ int mpls_uc_entry(struct streaminfo_private *pfstream_pr,const void *this_layer_
 		pstream->addr.paddr=&addr;
 		pstream->addr.addrtype = ADDR_TYPE_MPLS;
 		pstream->addr.addrlen = sizeof(struct layer_addr_mpls);
-		pstream_pr->addr_use_as_hash = 1;	
+		pstream_pr->addr_use_as_hash = 0;	/* MPLS��ַ������HASH�Ƚ�, ��Ϊ˫����ܲ�һ�� */
 		//ptmp->stream.p_layer_header = this_layer_data;
 		//ptmp->stream.offset_to_raw_pkt_hdr = (char *)this_layer_data - (char *)raw_pkt->raw_pkt_data;
 		pstream_pr->offset_to_raw_pkt_hdr = offset_to_raw_pkt_hdr;
diff --git a/dealpkt/net_common.c b/dealpkt/net_common.c
index 42910d0..d227883 100644
--- a/dealpkt/net_common.c
+++ b/dealpkt/net_common.c
@@ -124,9 +124,74 @@ static int arp_jump_to_layer(const char *raw_data,  int raw_layer_type, int expe
 }
 
 
+static int gtp_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
+{
+	const struct gtp_hdr *gh = (struct gtp_hdr *)raw_data;
+	int opt_len = 0; /* ��ѡ��� */
+	const unsigned char *next_ip_layer_hdr;
+	int skip_len;
+
+	if(ADDR_TYPE_GPRS_TUNNEL == expect_layer_type){
+		return 0;
+	}
+	
+	if(gh->flags & 0x2){
+		opt_len += sizeof(int);  /* sequence */
+	}
+
+	next_ip_layer_hdr = (unsigned char *)raw_data + opt_len + sizeof(struct gtp_hdr);
+
+	if((*next_ip_layer_hdr & 0x40) == 0x40){
+		skip_len = ipv4_jump_to_layer((char *)next_ip_layer_hdr, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
+	}else if((*next_ip_layer_hdr & 0x60) == 0x60){
+		skip_len = ipv6_jump_to_layer((char *)next_ip_layer_hdr, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
+	}else{
+		sapp_runtime_log(20, "TODO: jmp unsupport type in GTP, 0x%x!\n", (*next_ip_layer_hdr));
+		return -1;
+	}
+
+	return opt_len + sizeof(struct gtp_hdr) + skip_len;
+}
+
+static int udp_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
+{
+	const struct mesa_udp_hdr *uh = (const struct mesa_udp_hdr *)raw_data;
+	unsigned short usport, udport;
+	int skip_len;
+
+	if(ADDR_TYPE_UDP == expect_layer_type){
+		return 0;
+	}
+
+	usport = ntohs(uh->uh_sport);
+	udport = ntohs(uh->uh_dport);
+
+	if((2152 == usport) && (2152 == udport)){
+		skip_len = gtp_jump_to_layer(raw_data+sizeof(struct mesa_udp_hdr), ADDR_TYPE_UDP, expect_layer_type);
+	}else if(4789 == udport){
+		/* vxlanģʽ��ʱֻ֧��ethernet. TODO: �����hdlc, ppp��װ, ��Ҫʵ��һ��������vxlan_jump_to_layer()���� */
+		skip_len = eth_jump_to_layer(raw_data+sizeof(struct mesa_udp_hdr)+8, ADDR_TYPE_MAC, expect_layer_type);
+		if(skip_len < 0){
+			return -1;
+		}
+		skip_len += 8; /* skip vxlan header */
+	}else if((3544 == usport) || (3544 == udport)){
+		/* teredoʵ��û�����ݰ�ͷ, ֱ����ת��ipv6�㼴�� */
+		skip_len = ipv6_jump_to_layer(raw_data+sizeof(struct mesa_udp_hdr), __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
+		if(skip_len < 0){
+			return -1;
+		}
+	}else{
+		/* ����UDP���Ͳ�֧������ת */
+		return -1;
+	}
+
+	return skip_len + sizeof(struct mesa_udp_hdr);
+}
+
 static int ipv4_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
 {
-	struct ip *p_ip_hdr = (struct ip *)raw_data;
+	struct mesa_ip4_hdr *p_ip_hdr = (struct mesa_ip4_hdr *)raw_data;
 	int skip_len = 0;
 	int ip_hdr_len = p_ip_hdr->ip_hl * 4;
 	//const char *next_layer_data = raw_data + ip_hdr_len;
@@ -134,7 +199,12 @@ static int ipv4_jump_to_layer(const char *raw_data,  int raw_layer_type, int exp
 	if(raw_layer_type == expect_layer_type){
 		return 0;
 	}
-	
+
+	if((ntohs(p_ip_hdr->ip_off) & IP_MF ) || (ntohs(p_ip_hdr->ip_off) & IP_OFFMASK)){
+		/* IP��Ƭ���ټ������ڲ���ת */
+		return -1;
+	}
+				
 	switch(p_ip_hdr->ip_p){
 		case IPPROTO_TCP:
 			if(ADDR_TYPE_TCP == expect_layer_type){
@@ -150,13 +220,12 @@ static int ipv4_jump_to_layer(const char *raw_data,  int raw_layer_type, int exp
 				skip_len = 0;
 				break;
 			}else{
-				/* TODO: teredo����ģʽ */
-				skip_len = -1; 
+				skip_len = udp_jump_to_layer(raw_data+ip_hdr_len, ADDR_TYPE_UDP, expect_layer_type); 
 			}
 		break;
 
 		case IPPROTO_IPV6:
-			if(__ADDR_TYPE_IP_PAIR_V4 == expect_layer_type){
+			if(__ADDR_TYPE_IP_PAIR_V6 == expect_layer_type){
 				skip_len = 0;
 				break;
 			}else{
@@ -236,13 +305,16 @@ static int ipv6_jump_to_layer(const char *raw_data,  int raw_layer_type, int exp
 				if(ADDR_TYPE_UDP == expect_layer_type){
 					skip_len = next_hdr_ptr - (UINT8 *)raw_data;
 				}else{
+					/* TODO: IPv6����������ģʽ */
 					skip_len = -1;
 				}
 				goto done;
 			break;
 
-			case NEXTHDR_FRAGMENT:		
-				offset_to_ip6 = sizeof(struct ipv6_frag_hdr);
+			case NEXTHDR_FRAGMENT:	
+				/* IP��Ƭ���ټ������ڲ���ת */
+				skip_len = -1;
+				goto done;
 			break;
 
 			case NEXTHDR_ESP:
@@ -322,6 +394,34 @@ static int ppp_jump_to_layer(const char *raw_data,  int raw_layer_type, int expe
 	return skip_len + sizeof(struct mesa_pppoe_session_hdr);
 }
 
+
+static int mpls_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
+{
+	int skip_len = 0;
+	const struct mesa_mpls_hdr *mpls_hdr = (const struct mesa_mpls_hdr *)raw_data;
+	const char *next_layer_data = raw_data + sizeof(struct mesa_mpls_hdr);
+
+	if(raw_layer_type == expect_layer_type){
+		return 0;
+	}
+
+	if(0 == mpls_hdr->mpls_bls){ /* ��MPLSջ��, �ݹ�������� */
+		return mpls_jump_to_layer(next_layer_data, ADDR_TYPE_MPLS, expect_layer_type) + sizeof(struct mesa_mpls_hdr);
+	}
+
+	/* MPLSû���ֶα�ʶ��һ����ʲô, ���²���һ���IP���� */
+	if((*next_layer_data & 0x40) == 0x40){
+		skip_len = ipv4_jump_to_layer(next_layer_data, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
+	}else if((*next_layer_data & 0x60) == 0x60){
+		skip_len = ipv6_jump_to_layer(next_layer_data, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
+	}else{
+		sapp_runtime_log(20, "TODO: jmp unsupport type in MPLS, 0x%x!\n",  (unsigned char)(*next_layer_data));
+		return -1;
+	}
+
+	return skip_len + sizeof(struct mesa_mpls_hdr); /* mpls header is 4 byte */
+}
+
 static int __common_eth_type_dispatch(UINT16 eth_type, const char *next_layer_data, int raw_layer_type, int expect_layer_type)
 {
 	int skip_len = 0;
@@ -339,7 +439,11 @@ static int __common_eth_type_dispatch(UINT16 eth_type, const char *next_layer_da
 			if(ADDR_TYPE_VLAN == expect_layer_type){
 				break;
 			}else{
-				skip_len = vlan8021q_jump_to_layer(next_layer_data, ADDR_TYPE_VLAN, expect_layer_type);
+				if(sapp_global_single.treat_vlan_as_mac_in_mac_sw){
+					skip_len = eth_jump_to_layer(next_layer_data, ADDR_TYPE_MAC, expect_layer_type);
+				}else{
+					skip_len = vlan8021q_jump_to_layer(next_layer_data, ADDR_TYPE_VLAN, expect_layer_type);
+				}
 			}
 		break;
 		
@@ -366,6 +470,14 @@ static int __common_eth_type_dispatch(UINT16 eth_type, const char *next_layer_da
 				skip_len = ppp_jump_to_layer(next_layer_data, ADDR_TYPE_PPPOE_SES, expect_layer_type);
 			}
 		break;		
+
+		case 0x88A8: /* MAC_IN_MAC */
+			skip_len = eth_jump_to_layer(next_layer_data, ADDR_TYPE_MAC, expect_layer_type);
+		break;
+
+		case 0x8847: /* MPLS, ETH_P_MPLS_UC */
+			skip_len = mpls_jump_to_layer(next_layer_data, ADDR_TYPE_MPLS, expect_layer_type);
+		break;
 		
 		default:
 			skip_len = -1;
@@ -422,7 +534,7 @@ static int vlan8021q_jump_to_layer(const char *raw_data,  int raw_layer_type, in
 			skip_len = -1;
 		break;
 
-		case 0x8200: /* TODO: XinJing�������ִ�����, δ֪ʲô�� */
+		case 0x8200: /* XinJing�������ִ�����, δ֪ʲô�� */
 			skip_len = -1;
 		break;
 		
@@ -458,6 +570,27 @@ static int eth_jump_to_layer(const char *raw_data,  int raw_layer_type, int expe
 	return layer_skip_len + sizeof(struct ethhdr);
 }
 
+
+static int mac_in_mac_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
+{
+	struct ethhdr *inner_eth_hdr = (struct ethhdr *)(raw_data + sizeof(struct ethhdr ));
+	unsigned short inner_eth_type = ntohs(inner_eth_hdr->h_proto);
+	//int skip_len = -1;
+	const char *next_layer_data = raw_data + sizeof(struct ethhdr);
+	int layer_skip_len;
+
+	if(raw_layer_type == expect_layer_type){
+		return 0;
+	}
+	
+	layer_skip_len =  __common_eth_type_dispatch(inner_eth_type, next_layer_data, raw_layer_type, expect_layer_type);
+	if(layer_skip_len < 0){
+		return -1;
+	}
+
+	return layer_skip_len + sizeof(struct ethhdr) * 2;
+}
+
 /*
 	return value:
 		Non-NULL: the pointer to expect layer;
@@ -498,7 +631,11 @@ const void *MESA_net_jump_to_layer(const void *raw_data,  int raw_layer_type, in
 			ret = arp_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
 		break;
 		case ADDR_TYPE_VLAN:
-			ret = vlan8021q_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
+			if(sapp_global_single.treat_vlan_as_mac_in_mac_sw){
+				ret = mac_in_mac_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
+			}else{
+				ret = vlan8021q_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
+			}
 		break;
 		
 		case __ADDR_TYPE_IP_PAIR_V4:
@@ -508,10 +645,18 @@ const void *MESA_net_jump_to_layer(const void *raw_data,  int raw_layer_type, in
 		case __ADDR_TYPE_IP_PAIR_V6:
 			ret = ipv6_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
 		break;
+
+		case ADDR_TYPE_MAC_IN_MAC:
+			ret = mac_in_mac_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
+		break;
+
+		case ADDR_TYPE_UDP:
+			ret = udp_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
+		break;
+				
 		case ADDR_TYPE_PPPOE_SES:
 		case ADDR_TYPE_MPLS:		
 		case ADDR_TYPE_GRE:
-		/* TODO */
 		default:
 			printf("TODO: jmp unsupport raw_layer_type:%d in MESA_net_jump_to_layer()!\n", raw_layer_type);
 			return NULL;
@@ -524,6 +669,63 @@ const void *MESA_net_jump_to_layer(const void *raw_data,  int raw_layer_type, in
 	return ((const char *)raw_data + ret);
 }
 
+/*
+	��MESA_net_jump_to_layer()������:
+		MESA_net_jump_to_layer()������㿪ʼ, �ҵ���һ�����������Ĳ���˳�;
+		MESA_net_jump_to_layer_greedy()��һֱ���������ڲ�Э��ͷ, �ʺ�����ģʽ.
+	
+	return value:
+		Non-NULL: the pointer to expect layer;
+		NULL: not found expect layer.
+*/
+const void *MESA_net_jump_to_layer_greedy(const void *raw_data, int raw_layer_type, int expect_layer_type)
+{
+	const void *expect_layer;
+	const void *success_layer = NULL; /* ���һ�γɹ��ҵ��Ĳ� */
+	int new_raw_layer_type = raw_layer_type; /* ����ת������, ���ܻ�����м����Ϣ */
+	const char *new_next_layer_data = (char *)raw_data;
+
+	expect_layer = MESA_net_jump_to_layer(new_next_layer_data, new_raw_layer_type, expect_layer_type);
+	while(expect_layer){
+		success_layer = expect_layer;
+
+		switch(expect_layer_type){
+			case __ADDR_TYPE_IP_PAIR_V4:
+			{
+				const struct mesa_ip4_hdr *ip4hdr = (const struct mesa_ip4_hdr *)expect_layer;
+				if((ntohs(ip4hdr->ip_off) & IP_MF ) || (ntohs(ip4hdr->ip_off) & IP_OFFMASK)){
+					/* IP��Ƭ���ټ������ڲ���ת */
+					goto done;
+				}				
+				if(IPPROTO_UDP == ip4hdr->ip_p){
+					new_next_layer_data = (char *)expect_layer + ip4hdr->ip_hl * 4;
+					new_raw_layer_type = ADDR_TYPE_UDP; /* IP�������������һ��ƫ��, ֻ֧��UDP, IPIP, GRE, L2TPv3. */
+				}else{
+					//TODO 2, GRE, IPIP, L2TPv3
+					goto done;
+				}
+			}
+			break;
+
+			case __ADDR_TYPE_IP_PAIR_V6:
+			{
+				//TODO2,
+				goto done;		
+			}
+			break;
+
+			default:
+				sapp_runtime_log(20, "MESA_net_jump_to_layer_greedy() not support layer type:%d\n", expect_layer_type);
+				goto done;
+		}
+
+		expect_layer = MESA_net_jump_to_layer(new_next_layer_data, new_raw_layer_type, expect_layer_type);
+	}
+
+done:
+	return success_layer;
+}
+
 UINT8 net_layer_to_ipv4_protocol(int addr_type)
 {
 	UINT8 proto = 0;
@@ -793,7 +995,7 @@ int MESA_stream_list_cmp(struct streaminfo_private *stream1_pr, struct streaminf
 	}
 #endif
 
-	/* TODO, to do: 
+	/* TODO 2, to do:
 		if(isreverse), ��ת��ַ�Ƚ�, ����÷����ַ�ȽϺ��� 
 	*/
 
@@ -856,15 +1058,15 @@ int get_pkt_len_from_eth_hdr(const struct mesa_ethernet_hdr *ehdr)
 {
 	int raw_pkt_len = -1;
 
-	switch(ehdr->ether_type){
-		case ETHERTYPE_IP_NET:
+	switch(ntohs(ehdr->ether_type)){
+		case ETHERTYPE_IP:
 		{
 			struct mesa_ip4_hdr *ip4hdr = (struct mesa_ip4_hdr *)((char *)ehdr + sizeof(struct mesa_ethernet_hdr));
-			raw_pkt_len = ntohs(ip4hdr->ip_len) + sizeof(mesa_ethernet_hdr);
+			raw_pkt_len = ntohs(ip4hdr->ip_len) + sizeof(struct mesa_ethernet_hdr);
 		}
 		break;
 
-		case ETHERTYPE_IPv6_NET:
+		case ETHERTYPE_IPv6:
 		{
 			struct mesa_ip6_hdr *ip6hdr = (struct mesa_ip6_hdr *)((char *)ehdr + sizeof(struct mesa_ethernet_hdr));
 			raw_pkt_len = ntohs(ip6hdr->ip6_payload_len) + sizeof(struct mesa_ip6_hdr) + sizeof(struct mesa_ethernet_hdr);	
diff --git a/dealpkt/stream_addr_inet.c b/dealpkt/stream_addr_inet.c
index 9c2a2ac..dcedda2 100644
--- a/dealpkt/stream_addr_inet.c
+++ b/dealpkt/stream_addr_inet.c
@@ -21,6 +21,10 @@
 #include "deal_ipv6.h"
 
 #ifdef __cplusplus
+extern "C" const addr_convert_t G_ADDR_CONVERT_HANDLE[];
+#endif
+
+#ifdef __cplusplus
 extern "C" {
 #endif
 
@@ -51,6 +55,9 @@ static int __addr_ppp_n2p_fun(const struct layer_addr *paddr, char *buf, int buf
 static int __addr_pptp_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len);
 static int __addr_socks_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len);
 static int __addr_openvpn_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len);
+static int __addr_mac_in_mac_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len);
+static int __addr_gtp_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len);
+
 
 static int __addr_ipv4_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val);
 static int __addr_ipv6_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val);
@@ -71,11 +78,13 @@ static int __addr_ppp_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val);
 static int __addr_pptp_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val);
 static int __addr_sockv4_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val);
 static int __addr_openvpn_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val);
-
+static int __addr_mac_in_mac_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val);
 static const char *__layer_addr_ntop (const struct streaminfo *stream, int thread_index);
+static int __addr_gtp_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val);
 
 
-extern "C" const addr_convert_t G_ADDR_CONVERT_HANDLE[] = 
+
+const addr_convert_t G_ADDR_CONVERT_HANDLE[] = 
 {
 	{__ADDR_TYPE_INIT,			STREAM_TYPE_NON,NULL, 	NULL,	NULL,	NULL},
 #if (0 == IP_PORT_UNION_VERSION) /* ��IP-PORT�ϲ��İ汾��, û�д�IP��ַ�� */
@@ -104,9 +113,11 @@ extern "C" const addr_convert_t G_ADDR_CONVERT_HANDLE[] =
 	{ADDR_TYPE_IPV4,			STREAM_TYPE_SOCKS4,"ADDR_TYPE_SOCKS",	"SOCKS",		"SOCKS<",__addr_socks_n2p_fun,__addr_sockv4_pton},/* 14 */
 	{ADDR_TYPE_IPV4,			STREAM_TYPE_SOCKS5,"ADDR_TYPE_SOCKS",	"SOCKS",		"SOCKS<",__addr_socks_n2p_fun,__addr_sockv4_pton},/* 14 */
 	{ADDR_TYPE_PPTP,			STREAM_TYPE_PPTP,"ADDR_TYPE_PPPTP",		"PPTP", 		"PPTP<",__addr_pptp_n2p_fun, __addr_pptp_pton}, /* 15 */
+	{ADDR_TYPE_MAC_IN_MAC,	STREAM_TYPE_NON, "ADDR_TYPE_MAC_IN_MAC",		"MAC_IN_MAC",		"MAC_IN_MAC<",__addr_mac_in_mac_n2p_fun,__addr_mac_in_mac_pton}, /* 4 */
 	{ADDR_TYPE_IPV4,			STREAM_TYPE_OPENVPN,"ADDR_TYPE_OPENVPN",	"OpenVPN",	"OpenVPN<",__addr_openvpn_n2p_fun,__addr_openvpn_pton},/* 2017-02-10 lijia add */
 	{ADDR_TYPE_IPV6,			STREAM_TYPE_OPENVPN,"ADDR_TYPE_OPENVPN",	"OpenVPN",	"OpenVPN<",__addr_openvpn_n2p_fun,__addr_openvpn_pton},/* 2017-02-10 lijia add */
-	{__ADDR_TYPE_MAX,		STREAM_TYPE_NON,NULL, 	NULL,	NULL,	NULL} /* EOF */
+    {ADDR_TYPE_GPRS_TUNNEL,			STREAM_TYPE_NON,"ADDR_TYPE_GTP",		"GTP",		"GTP<",__addr_gtp_n2p_fun,__addr_gtp_pton},	/*  */
+    {__ADDR_TYPE_MAX,		STREAM_TYPE_NON,NULL, 	NULL,	NULL,	NULL} /* EOF */
 };
 
 
@@ -587,6 +598,113 @@ static int __addr_mac_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val)
 	return 0;
 }	
 
+/*MAC_IN_MAC<000100032202-00e0fc030007,000100032202-00e0fc030007>*/
+static int __addr_mac_in_mac_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val)
+{
+	int i;
+	char *str_val = addr_str;
+	//char *bin_val = addr_bin_val->addr_value;
+	unsigned char tmp_bin_val;
+	struct layer_addr_mac_in_mac *macaddr = (struct layer_addr_mac_in_mac *)addr_bin_val->addr_value;
+	addr_bin_val->stream.addr.addrtype = ADDR_TYPE_MAC_IN_MAC;
+	addr_bin_val->stream.type = STREAM_TYPE_NON;
+	addr_bin_val->stream.addr.addrlen = sizeof(struct layer_addr_mac_in_mac);
+
+	for(i = 0; i < MAC_ADDR_LEN; i++){
+		tmp_bin_val = 0; /* ������, ������ֵ��䶼�ǻ���� */
+		if(isxdigit(*str_val)==0){
+			printf("MAC string type error!\n");
+			return -1;
+		}
+		tmp_bin_val |= MESA_ascii_to_hex(*str_val) << 4;
+		str_val++;
+		
+		if(isxdigit(*str_val)==0)	{
+			printf("MAC string type error!\n");
+			return -1;
+		}
+		tmp_bin_val |= MESA_ascii_to_hex(*str_val);
+		str_val++;
+		macaddr->inner_src_mac[i] = tmp_bin_val;
+	}
+
+	if(*str_val != '-'){
+		printf("MAC string type error!\n");
+		return -1;		
+	}
+	str_val++;
+	
+	for(i = 0; i < MAC_ADDR_LEN; i++){
+		tmp_bin_val = 0; /* ������, ������ֵ��䶼�ǻ���� */
+		if(isxdigit(*str_val)==0){
+			printf("MAC string type error!\n");
+			return -1;
+		}
+		tmp_bin_val |= MESA_ascii_to_hex(*str_val) << 4;
+		str_val++;
+		
+		if(isxdigit(*str_val)==0)	{
+			printf("MAC string type error!\n");
+			return -1;
+		}
+		tmp_bin_val |= MESA_ascii_to_hex(*str_val);
+		str_val++;
+		macaddr->inner_dst_mac[i] = tmp_bin_val;
+	}
+
+	if(*str_val != ','){
+		printf("MAC_IN_MAC string type error!\n");
+		return -1;		
+	}
+	str_val++;
+	
+	for(i = 0; i < MAC_ADDR_LEN; i++){
+		tmp_bin_val = 0; /* ������, ������ֵ��䶼�ǻ���� */
+		if(isxdigit(*str_val)==0){
+			printf("MAC string type error!\n");
+			return -1;
+		}
+		tmp_bin_val |= MESA_ascii_to_hex(*str_val) << 4;
+		str_val++;
+		
+		if(isxdigit(*str_val)==0)	{
+			printf("MAC string type error!\n");
+			return -1;
+		}
+		tmp_bin_val |= MESA_ascii_to_hex(*str_val);
+		str_val++;
+		macaddr->outer_src_mac[i] = tmp_bin_val;
+	}
+
+	if(*str_val != '-'){
+		printf("MAC_IN_MAC string type error!\n");
+		return -1;		
+	}
+	str_val++;
+	
+	for(i = 0; i < MAC_ADDR_LEN; i++){
+		tmp_bin_val = 0; /* ������, ������ֵ��䶼�ǻ���� */
+		if(isxdigit(*str_val)==0){
+			printf("MAC string type error!\n");
+			return -1;
+		}
+		tmp_bin_val |= MESA_ascii_to_hex(*str_val) << 4;
+		str_val++;
+		
+		if(isxdigit(*str_val)==0)	{
+			printf("MAC string type error!\n");
+			return -1;
+		}
+		tmp_bin_val |= MESA_ascii_to_hex(*str_val);
+		str_val++;
+		macaddr->outer_dst_mac[i] = tmp_bin_val;
+	}
+	
+	addr_bin_val->stream.addr.paddr = addr_bin_val->addr_value;
+
+	return 0;
+}
+
 static int __addr_arp_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val)
 {
 	addr_bin_val->stream.addr.addrtype = ADDR_TYPE_ARP;
@@ -681,6 +799,15 @@ static int __addr_l2tp_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val)
 	return 0;
 }
 
+static int __addr_gtp_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val)
+{
+    addr_bin_val->stream.addr.addrtype = ADDR_TYPE_GPRS_TUNNEL;
+    addr_bin_val->stream.type = STREAM_TYPE_NON;
+    addr_bin_val->stream.addr.paddr = addr_bin_val->addr_value;
+
+    return 0;
+}
+
 static int __addr_sockv4_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val)
 {
 	char *save_ptr;
@@ -739,7 +866,7 @@ err:
 	return -1;
 }
 
-/* TODO, ����IPv6��openvpnЭ�����? */
+/* How TODO 2, ����IPv6��openvpnЭ�����? */
 static int __addr_openvpn_pton(char *addr_str, addr_continuous_bin_t *addr_bin_val)
 {
 	addr_bin_val->stream.addr.addrtype = ADDR_TYPE_IPV4; 
@@ -1016,6 +1143,7 @@ int stream_addr_list_pton(const char *addr_list_str, void *dst, int size, int th
 			return -1;
 		}
 		real_stream_item = (addr_continuous_bin_t *)stream_addr;
+		real_stream_item->stream.threadnum = thread_index;
 		memcpy(save_dst, real_stream_item, sizeof(addr_continuous_bin_t));
 		stream_addr = stream_addr->pfather;
 		tot_len += sizeof(addr_continuous_bin_t);
@@ -1205,6 +1333,48 @@ static int __addr_mac_n2p_fun(const struct layer_addr *paddr, char *buf, int buf
 	return MAC_ADDR_STR_LEN;	
 }
 
+static int __addr_mac_in_mac_n2p_fun(const struct layer_addr *paddr, char *in_buf, int buf_len)
+{
+#define MACINMAC_ADDR_STR_LEN		(strlen("00e0fc030007")*4 + 3) /* �ĸ�MAC�ַ���, �����ָ���, ��С���泤�� */
+	int i;
+	char *buf = in_buf;
+	//unsigned char *mac_addr = (unsigned char *)stream->addr.paddr;
+	const struct layer_addr_mac_in_mac *macaddr = (const struct layer_addr_mac_in_mac *)paddr->paddr;
+
+	if(buf_len <= (int)MACINMAC_ADDR_STR_LEN){
+		buf[0]= '\0';
+		return -1;
+	}
+
+	/* ���MAC������ */
+	for(i = 0; i < 6; i++, buf+=2){
+		sprintf(buf, "%02x", macaddr->inner_src_mac[i]);
+	}
+	*buf = '-';
+	buf++;
+	//mac_addr += MAC_ADDR_LEN;
+	for(i = 0; i < 6; i++,buf+=2){
+		sprintf(buf, "%02x", macaddr->inner_dst_mac[i]);
+	}
+	
+	*buf = ','; /* �ָ��� */
+	buf++;
+	
+	for(i = 0; i < 6; i++, buf+=2){
+		sprintf(buf, "%02x", macaddr->outer_src_mac[i]);
+	}
+	*buf = '-';
+	buf++;
+	//mac_addr += MAC_ADDR_LEN;
+	for(i = 0; i < 6; i++,buf+=2){
+		sprintf(buf, "%02x", macaddr->outer_dst_mac[i]);
+	}	
+	*buf = '\0';
+	buf++;
+	
+	return strlen(in_buf) + 1;	
+}
+
 static int __addr_gre_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len)
 {
 #define __GRE_ADDR_STRING		"NULL"
@@ -1257,6 +1427,17 @@ static int __addr_l2tp_n2p_fun(const struct layer_addr *paddr, char *buf, int bu
 	return addr_len + 1;
 }
 
+static int __addr_gtp_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len)
+{
+	int addr_len;
+	const struct gtp_hdr *src_net_hdr = (struct gtp_hdr *)&paddr->gtp->source;
+	const struct gtp_hdr *dst_net_hdr = (struct gtp_hdr *)&paddr->gtp->dest;
+	
+	addr_len = snprintf(buf, buf_len, "%u-%u", ntohl(src_net_hdr->teid), ntohl(dst_net_hdr->teid));
+
+	return addr_len + 1;
+}
+
 static int __addr_arp_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len)
 {
 #define __ARP_ADDR_STRING		"NULL"
@@ -1272,11 +1453,12 @@ static int __addr_arp_n2p_fun(const struct layer_addr *paddr, char *buf, int buf
 
 static int __addr_ppp_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len)
 {
-#define __PPP_ADDR_STRING		"NULL"
 
+#define __PPP_ADDR_STRING               "NULL"
+	
 	int addr_len = strlen(__PPP_ADDR_STRING);
 	if(buf_len <= addr_len + 1){
-		return -1;
+			return -1;
 	}
 	strncpy(buf, __PPP_ADDR_STRING, addr_len + 1);
 
@@ -1454,7 +1636,7 @@ const char *__layer_addr_ntop_r (const struct streaminfo *stream, char *dst, int
 }
 
 
-/* ��������(ƽ̨Ĭ��ģʽ), "TCP:12345-80<IP4:10.0.6.1-10.0.6.2<MAC:0x112233445566-0xAABBCCDDEEFF" */
+/* ��������(ƽ̨Ĭ��ģʽ), "IPv4_TCP<2196-80-222.75.165.42-209.34.91.23>|MAC<000100032101-00e0fc030002>" */
 const char *stream_addr_list_ntop_outward(const struct streaminfo *pstream)
 {
 	const struct streaminfo *ptmp = pstream;;
diff --git a/dealpkt/stream_manage.c b/dealpkt/stream_manage.c
index e0af337..c210889 100644
--- a/dealpkt/stream_manage.c
+++ b/dealpkt/stream_manage.c
@@ -44,8 +44,8 @@
 extern "C" {
 #endif
 
-int Stream_Analyse_Process_Platform_version_VERSION_20181108; /* nm sapp | grep version */
-int sapp_args_v = 20181108; /* ./sapp -v */
+int Stream_Analyse_Process_Platform_version_VERSION_20181116; /* nm sapp | grep version */
+int sapp_args_v = 20181116; /* ./sapp -v */
 
 /* 
 	����İ汾������packet_io_libУ��, ��ֹƽ̨��dl.so��ƥ�䵼�������쳣, �����޸���BUGδ����.
diff --git a/entry/CMakeLists.txt b/entry/CMakeLists.txt
new file mode 100644
index 0000000..92d3833
--- /dev/null
+++ b/entry/CMakeLists.txt
@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 2.8)
+
+include_directories(${MESA_SDK_PREFIX}/include)
+include_directories(${MESA_SDK_PREFIX}/include/MESA)
+include_directories(${CMAKE_SOURCE_DIR}/include)
+include_directories(${CMAKE_SOURCE_DIR}/include/support)
+include_directories(${CMAKE_SOURCE_DIR}/include/net)
+include_directories(${CMAKE_SOURCE_DIR}/include/stream_inc)
+include_directories(${CMAKE_SOURCE_DIR}/dealpkt)
+include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+
+add_executable(sapp sapp_init.c sapp_main.c sapp_global_val.c)
+target_link_libraries(sapp nsl pthread dl m pcap)
+target_link_libraries(sapp MESA_handle_logger MESA_prof_load sapp_assistant gdev_assistant)
+
+set(SAPP_MODULES -Wl,--whole-archive iknow timestamp_record dictator2 md5 symbol_check MESA_sleep MESA_socket_wrap packet_io dealpkt project plugctrl -Wl,--no-whole-archive)
+target_link_libraries(sapp ${SAPP_MODULES} ${SAPP_DEPEND_DYN_LIB})
+
+if(CAPTURE_MODE MATCHES "PAG")
+	target_link_libraries(sapp pag)
+endif()
+
+if(CAPTURE_MODE MATCHES "PPF")
+	target_link_libraries(psapp ppf)
+endif()
+
+if(CAPTURE_MODE MATCHES "PFRING")
+	target_link_libraries(sapp pfring)
+endif()
+
+if(CAPTURE_MODE MATCHES "DPDK")
+	target_link_libraries(sapp nl2fwd)
+endif()
+
+# Target Install
+install(TARGETS sapp DESTINATION ${CMAKE_SOURCE_DIR}/run/)
+install(FILES ${CMAKE_SOURCE_DIR}/build/inner_plug/libsapp_assistant.so DESTINATION /opt/MESA/lib)
+#install(DIRECTORY conf/ DESTINATION ${CMAKE_SOURCE_DIR}/run/conf)
+#install(DIRECTORY log/ DESTINATION ${CMAKE_SOURCE_DIR}/run/log)
+
+# SDK Headers Install
+#install(DIRECTORY ${CMAKE_SOURCE_DIR}/include/stream_inc DESTINATION ${MESA_SDK_PREFIX}/include/MESA)
+#install(FILES ${CMAKE_SOURCE_DIR}/include/stream.h DESTINATION ${MESA_SDK_PREFIX}/include/MESA)
diff --git a/include/dealpkt.h b/include/dealpkt.h
index 7d2bffc..88bba55 100644
--- a/include/dealpkt.h
+++ b/include/dealpkt.h
@@ -5,6 +5,7 @@
 extern "C" {
 #endif
 
+#include "stream.h"
 
 #define TCP_FLOOD_DETECT_OFF 0x0
 #define TCP_SYNFLOOD_DETECT_ON 0x01
diff --git a/include/net/mesa_net.h b/include/net/mesa_net.h
index a132b6a..69f52a2 100644
--- a/include/net/mesa_net.h
+++ b/include/net/mesa_net.h
@@ -39,6 +39,9 @@ extern "C"
 #define ETHERTYPE_VLAN          		0x8100  /* IEEE 802.1Q VLAN tagging */
 #define ETHERTYPE_LOOPBACK      	0x9000  /* used to test interfaces */
 
+#define ETH_P_MAC_IN_MAC			0x88A8 /* pangu��Ŀ����88a8����, ���ڻ���MAC_IN_MAC���ݰ� */
+
+#define ETHERTYPE_PANGU_MAC_IN_MAC 0x88A8 /* 2018-08-16 lijia add, for pangu MAC-in-MAC */
 #define ETHERTYPE_IP_NET            	0x0008  /* IP protocol network order */
 #define ETHERTYPE_IPv6_NET          	0xdd86  /* IPv6 protocol network order */
 #define ETHERTYPE_VLAN_NET         	0x0081  /* IEEE 802.1Q VLAN tagging network order*/
@@ -513,6 +516,24 @@ struct mesa_vlan_hdr{
 	unsigned short type;
 };
 
+struct mesa_vlan_detail_hdr{
+	unsigned int priority:3;
+	unsigned int del_flag:1;
+	unsigned int vlan_id:12;
+	unsigned short type;
+};
+
+/* 2018-08-28 lijia add, for pangu ��Ŀmac_in_mac���� */
+struct mesa_mac_in_mac_net_hdr{
+	unsigned int route_dir:1;
+	unsigned int link_id:3;
+	unsigned int dev_id:6;
+	unsigned int region_id:5;
+	unsigned int __pad1:1;
+	unsigned int encap_type:4;
+	unsigned int __pad2:20;
+	unsigned int __pad3:8;
+};
 struct mesa_gre_base_hdr_v0{
 #if __BYTE_ORDER == __LITTLE_ENDIAN 
 	unsigned char recur:3;
@@ -603,15 +624,17 @@ struct mesa_gre_hdr{
 #define MPLS_TTL_MASK		(0x000000FF)
 struct mesa_mpls_hdr{
 #if __BYTE_ORDER == __LITTLE_ENDIAN 
-	unsigned int mpls_label:20;
-	unsigned int mpls_exp:3;
-	unsigned int mpls_bls:1;	/* bottom of label stack */
-	unsigned int mpls_ttl:8;
+	unsigned short mpls_label_low;
+	unsigned char mpls_bls:1;	/* bottom of label stack */
+	unsigned char mpls_exp:3;
+	unsigned char mpls_label_high:4;
+	unsigned char mpls_ttl;
 #elif __BYTE_ORDER == __BIG_ENDIAN
-	unsigned int mpls_ttl:8;
-	unsigned int mpls_bls:1;	/* bottom of label stack */
-	unsigned int mpls_exp:3;
-	unsigned int mpls_label:20;
+	unsigned char mpls_ttl;
+	unsigned char mpls_label_high:4;
+	unsigned char mpls_exp:3;
+	unsigned char mpls_bls:1;	/* bottom of label stack */
+	unsigned short mpls_label_low;
 #else
 #error "Please check <endian.h>"
 #endif
@@ -734,6 +757,23 @@ struct mesa_isakmp_payload_hdr{ /* RFC2408-Page22 */
 };
 
 #define ADDR_PREFIX_LEN			(3) /* "U4T", "IP4", "GRE", etc. */
+#define GTP_MSG_TYPE_T_PDU (0xFF)
+
+struct gtp_hdr{
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+	unsigned char flags;
+	unsigned char msg_type;
+    unsigned short len;
+	unsigned int teid;
+#elif __BYTE_ORDER == __BIG_ENDIAN
+	unsigned int teid;
+    unsigned short len;
+	unsigned char msg_type;
+	unsigned char flags;
+#else
+#error "Please check <endian.h>"
+#endif
+};
 #define MAX_ADDR_TYPE_STRING_LEN	(64)
 #define MAX_ADDR_LIST_STRING_LEN	(2048)
 #define MAX_ADDR_EMBED_LAYER_NUM (20) /* ����ַǶ�ײ��� */
@@ -752,6 +792,7 @@ unsigned short net_layer_to_ethernet_protocol(int addr_type);
 int net_common_build_send_mac(unsigned char *buf, const struct mesa_ethernet_hdr *raw_eth_hdr, int addr_type, int dir_reverse, int net_topology_mode);
 int net_common_adjust_forward_mac(struct mesa_ethernet_hdr *raw_eth_hdr,int net_topology_mode);
 const void *MESA_net_jump_to_layer(const void *raw_data,  int raw_layer_type, int expect_layer_type);
+const void *MESA_net_jump_to_layer_greedy(const void *raw_data, int raw_layer_type, int expect_layer_type);
 char MESA_ascii_to_hex(char ascii);
 
 #ifdef __cplusplus
diff --git a/include/stream_inc/stream_base.h b/include/stream_inc/stream_base.h
index c33d9d9..f24b3a6 100644
--- a/include/stream_inc/stream_base.h
+++ b/include/stream_inc/stream_base.h
@@ -69,7 +69,9 @@ enum addr_type_t{
 	__ADDR_TYPE_IP_PAIR_V6,		/* 13, ipv6 layer in tunnel mode */
 	ADDR_TYPE_PPP,				/* 14 */
 	ADDR_TYPE_PPTP,			/* 15 */
-	__ADDR_TYPE_MAX,			/* 16 */
+	ADDR_TYPE_MAC_IN_MAC,		/* 16 */
+	ADDR_TYPE_GPRS_TUNNEL,      /* 17 */
+	__ADDR_TYPE_MAX,			/* 18 */
 };
 
 #define TCP_TAKEOVER_STATE_FLAG_OFF	0
@@ -121,6 +123,7 @@ enum stream_carry_tunnel_t{
 	STREAM_TUNNLE_PPTP		= 1 << 4,
 	STREAM_TUNNLE_L2TP		= 1 << 5,
 	STREAM_TUNNLE_TEREDO		= 1 << 6,
+	STREAM_TUNNEL_GPRS_TUNNEL = 1 << 7,
 };
 
 typedef struct raw_ipfrag_list{
@@ -196,9 +199,8 @@ struct layer_addr_pppoe_session
 {
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 	unsigned int ver:4;   
-	unsigned int type:4;  
-#endif
-#if __BYTE_ORDER == __BIG_ENDIAN
+	unsigned int type:4;
+#elif __BYTE_ORDER == __BIG_ENDIAN
 	unsigned int type:4; 
 	unsigned int ver:4; 
 #endif
@@ -287,6 +289,23 @@ struct layer_addr_pptp
 	UINT16 S2C_call_id;	/* S2Ck�Դ����Э�鷽��Ϊ׼, TCP SYN/ACKΪS2C, UDPĿ�Ķ˿ڴ��ΪS2C, callid, network order */
 };
 
+struct layer_addr_gtp
+{
+    unsigned long long source;  /* From Client */
+    unsigned int src_seq;
+    unsigned long long dest;	/* From Server */
+    unsigned int dest_seq;
+}__attribute__ ((aligned (1)));
+
+#define MAC_IN_MAC_HDR_LEN	(sizeof(struct mesa_ethernet_hdr) +  sizeof(struct mesa_ethernet_hdr))
+struct layer_addr_mac_in_mac
+{
+	UCHAR outer_dst_mac[MAC_ADDR_LEN]; /* �����mac��ַ, network order */
+	UCHAR outer_src_mac[MAC_ADDR_LEN]; /* �����mac��ַ, network order */
+	UCHAR inner_dst_mac[MAC_ADDR_LEN]; /* �ڲ�mac��ַ, network order */
+	UCHAR inner_src_mac[MAC_ADDR_LEN]; /* �ڲ�mac��ַ, network order */
+};
+
 struct layer_addr
 {
 	UCHAR addrtype; /*  definition in enum addr_type_t */
@@ -309,6 +328,8 @@ struct layer_addr
 		struct layer_addr_pppoe_session *pppoe_ses;		
 		struct layer_addr_l2tp	*l2tp;
 		struct layer_addr_pptp	*pptp;
+		struct layer_addr_mac_in_mac *mimac;
+        struct layer_addr_gtp *gtp;
 		void 					*paddr;
 	};
 
diff --git a/include/stream_inc/stream_control.h b/include/stream_inc/stream_control.h
index 0a6d02f..45ec1a4 100644
--- a/include/stream_inc/stream_control.h
+++ b/include/stream_inc/stream_control.h
@@ -5,7 +5,7 @@
 extern "C" {
 #endif
 
-#define STREAM_CONTROL_H_VERSION		(20170904)
+#define STREAM_CONTROL_H_VERSION		(20181024)
 
 #define TCP_CTEAT_LINK_BYSYN   			0x01
 #define TCP_CTEAT_LINK_BYDATA 			0x02
@@ -30,6 +30,7 @@ enum MESA_stream_opt{
 	MSO_TCP_SYNACK_OPT, /* opt_val must be struct tcp_option **, opt_val_len [OUT} is struct tcp_option number, valid only if SYN/ACK packet is captured */
 	MSO_STREAM_TUNNEL_TYPE,  /* opt_val must be unsigned short, refer to enum stream_carry_tunnel_t */
 	MSO_STREAM_CLOSE_REASON, /* opt_val type must be unsigned char, refer to stream_close_reason_t */
+	MSO_STREAM_VXLAN_INFO, /* opt_val type must be struct vxlan_info */
 	__MSO_MAX,
 };
 
@@ -58,6 +59,16 @@ enum sapp_platform_opt{
 	SPO_INDEPENDENT_THREAD_ID, /* plug independent thread which is created by pthread_create(), opt_val type must be int */
 };
 
+/*
+	option of device, 
+*/
+enum sapp_device_opt{
+	__SDO_PAD			=	0,    /* placeholder */
+	SDO_MAC_ADDR,				/* device mac addr, opt_val type must be at least char[6] */
+	SDO_IPV4_ADDR,				/* device ipv4 addr in network order,  opt_val type must be int */
+	SDO_MTU,					/* device MTU, opt_val type must be int */
+	__SDO_MAX,
+};
 /* for MSO_MAX_UNORDER  */
 struct max_unorder_opt{
 	unsigned short stream_dir; /* refer to stream_base.h, DIR_C2S, DIR_S2C, DIR_DOUBLE */
@@ -110,6 +121,22 @@ struct tcp_option_ext{
 		struct tcp_option_ts opt_ts_val;
 	};	
 } __attribute__((packed, aligned(1)));
+/* 2018-10-24 lijia add, for pangu ��Ŀmac_in_mac����.
+   ������, sappƽ̨��Ӧ�ù��ĺ�ҵ��������صĶ���, ����mac���ĸ��ֶ���link_id, �ĸ���dev_id,
+   ���������̫�ײ���, ƽ̨����GDEV����RST��ҲҪ�����Щֵ, ����ƽ̨����!!
+*/
+/* Ϊ�˷���ҵ������ȡmac_in_mac��ַ��ľ�����Ϣ, ����ʹ��ԭʼ��bitλ��, ת���ɱ�����ʽ */
+struct vxlan_info{
+	unsigned char encap_type; /* ԭʼ�����װ��ʽ */
+	unsigned char entrance_id; /* �豸���ڳ����ID */
+	unsigned char dev_id; /* �豸ID */
+	unsigned char link_id; /* ��·ID */
+	unsigned char link_dir; /* ��·����, ָ��ǰ��Ԫ���IP������ʱ�Ĵ��䷽��, ����TCP, SYN���Ĵ��䷽��; ����UDP, �˿ڴ�IP�Ĵ��䷽�� */
+	unsigned char inner_smac[18]; /* �ڲ���ʵSMAC, string����, ��: "11:22:33:44:55:66"  */
+	unsigned char inner_dmac[18]; /* �ڲ���ʵDMAC, string����, ��: "11:22:33:44:55:66"  */
+	unsigned char inner_smac_hex[6]; /* �ڲ���ʵSMAC, ԭʼ����������  */
+	unsigned char inner_dmac_hex[6]; /* �ڲ���ʵDMAC, ԭʼ����������  */	
+};
 /*
 	plug call MESA_set_stream_opt() to set feature of specified stream.
 		opt: option type, refer to enum MESA_stream_opt;
@@ -165,6 +192,18 @@ int MESA_get_tcp_pkt_opts_ext(const struct tcphdr *tcphdr, struct tcp_option_ext
 		<0:error;
 */
 int sapp_get_platform_opt(enum sapp_platform_opt opt, void *opt_val, int *opt_val_len);
+
+/*
+	Get some options of hardware .
+		opt: option type, refer to enum sapp_device_opt;
+		opt_val: option value, depend on opt type;
+		opt_val_len: value-result argment, IN:opt_val buf size, OUT:opt_val actual size;
+	
+	return value:
+		0 :OK;
+		<0:error;	
+*/
+int sapp_get_device_opt(const char *device, enum sapp_device_opt opt_type, void *opt_val, int *opt_val_len);
 /****************************************************************************************
 	CHN : ��Ϊ��ʷ��������,���ຯ��������Ϊ������,��ʹ���½ӿ�:MESA_set_stream_opt().
 	ENG : for compat old version, keep these functions, but we suggest you use new API MESA_set_stream_opt().
diff --git a/include/stream_internal.h b/include/stream_internal.h
index 393417d..0ff5f45 100644
--- a/include/stream_internal.h
+++ b/include/stream_internal.h
@@ -130,15 +130,20 @@ struct streaminfo_private
 	void   *pproject;		//ÿ�����̿����Զ���ʹ�ã�
 	UCHAR  layer_dir:2;   /* ������Ч, ��ǰ��ĵ�ַ�Ƿ��Ĭ�Ϲ���"��˿��ǿͻ���"��ͬ */	
 	UCHAR  stream_dir:2; /* ��������������Ч, ���Ĵ洢�ĵ�ַ�Ƿ��Ĭ�Ϲ���"��˿��ǿͻ���"��ͬ  */		
-	UCHAR  addr_use_as_hash:2; /* �����addr�Ƿ���ΪHASH����ͱȽϵĲ���, ��:MAC��ַ��������� */
-	UCHAR  stream_killed_flag:2; /* 2014-08-22 lijia add, ����ģʽ��, �Ѿ������Kill, ֮�������ֱ��Drop��Kill, �����ٸ��ϲ��� */
+	UCHAR  addr_use_as_hash:1; /* �����addr�Ƿ���ΪHASH����ͱȽϵĲ���, ��:MAC��ַ��������� */
+	UCHAR  addr_skip_for_layer_cmp:1;/*�����addr�Ƿ���Ϊ��ַ�ȽϵĲ㼶���磺MPLS��ַ����Ϊ�������㣬ֱ����������ֵĬ��Ϊ0������Ҫ�Ƚ�*/
+	UCHAR  need_update_opposite_addr:1;/*�����addr�Ƿ��ڶԲ�����ʱ���£��磺MPLS��ǩ�ǶԳ�ʱ��Ҫ��S2C���һ������¼�����ǩ,��ֵĬ��Ϊ0��������Ҫ����*/
+	UCHAR  stream_killed_flag:1; /* 2014-08-22 lijia add, ����ģʽ��, �Ѿ������Kill, ֮�������ֱ��Drop��Kill, �����ٸ��ϲ��� */
 	UCHAR  dirreverse;	     /* ��������ʱ�Ƿ������ip��ַ��ת, ����"��˿��ǿͻ���"�����෴ */
 	UINT16 timeout;/* ÿ�����ӵĶ��г�ʱʱ��, ��ֵ��������;, 1:���ھ�����̭��ʱ���ް��������, �Խ�Լ�ڴ�; 2:���ڱ�����ʱ���ް�����, ����IM�೤ʱ���ް������Ӳ�δ����, �����ýϴ��timeout */
 	unsigned short offset_to_raw_pkt_hdr; /* ����ͷ�����ԭʼ������ʼ��ַ��ƫ���� */
 	unsigned short offset_to_ip_hdr; /* 2015-12-07 lijia add, UDP/TCP ��ͷ����ڳ��ص�IP��ͷƫ���� */
 	const raw_pkt_t *raw_pkt; /* 2014-12-30 lijia add, ��Щ�ص�������֧��ԭʼ��, ����������Ҫ, �洢��private�ṹ�� */
 	unsigned int hash_slave; /* 2015-12-14 lijia add, ʹ��linux_jhash����ʱ, ����ͬʱ�õ��������ϵ�HASHֵ, ��HASH����ȷ����HASH����SLOTλ��, slave_HASH���ڿ��ٱȽϵ�ַ�Ƿ���� */
-	int hash_not_head_times;/* 2015-12-15 lijia add, ��ǰindex����HASH SLOT�ĵ�һλ�Ĵ��� */
+	unsigned char hash_not_head_times;/* 2015-12-15 lijia add, ��ǰindex����HASH SLOT�ĵ�һλ�Ĵ��� */
+	unsigned char cur_layer_raw_hdr_len; /* 2017-10-31 lijia add, ��ǰ���ԭʼ����ַ����, ��pppͷ��ѹ��, ԭ���汾�޷��������״̬, ����ʱҲ�޷���֪��ַ������ */
+	char __pad;
+	unsigned char gdev_block_timer;
 	unsigned short stream_low_layer_tunnel_type; /* 2016-07-25 lijia add, ��¼�����ײ���������, 0Ϊ������, �������:enum stream_carry_tunnel_t */
 	unsigned short stream_carry_up_layer_tunnel_type; /* ��ǰ���ϲ����������, ���統ǰ��ΪUDP, ���صĿ�����teredo������L2TP���� */
   
@@ -179,6 +184,7 @@ struct tcpdetail_private
 	void   *apme;		  //Ӧ�ò�������
 	void   *pAllpktpme;   //��״̬��tcp����������
 	struct tcp_flow_stat *flow_stat; /* 2016-07-14 lijia add, ���ڼ�¼TCP��data���ļ���, ʵ���ڴ������ͷ���projectģ�����, ����ΪNULL,  */
+	struct tcp_flow_stat *deduce_flow_stat; /* 2018-10-30 lijia add, ���ڼ�¼������ƶϳ������ϴ��������, ���������ĳ���; �Լ������������, �Զ�Ӧ���յ�������  */
 };
 
 struct udpdetail_private
@@ -258,6 +264,12 @@ struct sapp_global_single_t{
 	int signal_take_over_sw; /* �Ƿ�ӹܳ���ϵͳ�ź�, ��SIGSEGV, SIGABRT�ȵ� */
 	int ipentry_priority_over_ipfrag; /* IP_entry���ȼ�����IP_frag_entry, Ĭ��Ϊ0, ��ӦWY�����ض����� */
 	int tuple4_reuse_time_interval; /* ��Ԫ�����õ���С���ʱ�� */
+	void *fs2_handle;
+	const char *fs2_server_ip;
+	unsigned short fs2_server_port_host;
+	short __pad1;
+	int fs2_filed_id_array[COUNTER_NUM];
+	int treat_vlan_as_mac_in_mac_sw;
 };
 
 #define TIMESTAMP_SINGLE_PKT_REGION 		(4) /* ������ʱͳ������ */
@@ -294,8 +306,6 @@ extern void *g_sapp_log_handle;
 
 int MESA_kill_tcp_remedy(struct streaminfo *stream, const void *ext_raw_pkt);
 
-long long sapp_get_cpu_cycle(void);
-
 int get_stream_carry_tunnel_type(const struct streaminfo *this_stream, const struct streaminfo *upper_stream, unsigned short *tunnel_type);
 
 void cycle_pkt_dump(int thread_seq, const raw_pkt_t *p_raw_pkt);
@@ -305,7 +315,7 @@ void idle_polling_call(int thread_seq);
 int sapp_identify_broad_multicast_pkt(const void *this_layer_data, const raw_pkt_t *raw_pkt);
 int sapp_assistant_init(void);
 
-inline long long sapp_get_cpu_cycle(void)
+static inline long long sapp_get_cpu_cycle(void)
 {
 #ifdef __x86_64
 #define X86_64_ENV 1
diff --git a/include/sysinfo.h b/include/sysinfo.h
index 7f9819b..ddfa51c 100644
--- a/include/sysinfo.h
+++ b/include/sysinfo.h
@@ -100,6 +100,7 @@
 #define TUNNEL_TEREDO			(64)
 #define TUNNEL_TEREDO_LEN		(65)
 #define TUNNEL_IP_IN_IP			(66)
+#define TUNNEL_GTP              (67)
 
 #define SEND_IP_RAW_PKT		(70) /* ����MESA_sendpacket_iplayer()���͹���õ�IP������ */
 #define SEND_IP_RAW_PKT_LEN	(71)
@@ -114,6 +115,9 @@
 #define SEND_UDP_PKT			(80) /* MESA_fakepacket_send_udp()����UDP���ݰ� */
 #define SEND_UDP_PKT_LEN		(81)
 
+#define SEND_PKT_ERR			(82)
+#define SEND_PKT_ERR_LEN		(83) /* sendto error */
+
 /* 2014-12-02 lijia add */
 #define PKT_UNKNOWN			(98)
 #define PKT_UNKNOWN_LEN		(99)
diff --git a/inner_plug/CMakeLists.txt b/inner_plug/CMakeLists.txt
new file mode 100644
index 0000000..abdb822
--- /dev/null
+++ b/inner_plug/CMakeLists.txt
@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 2.8)
+
+include_directories(${MESA_SDK_PREFIX}/include)
+include_directories(${MESA_SDK_PREFIX}/include/MESA)
+include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+#include_directories(${CMAKE_SOURCE_DIR}/project)
+include_directories(${CMAKE_SOURCE_DIR}/include)
+include_directories(${CMAKE_SOURCE_DIR}/include/net)
+include_directories(${CMAKE_SOURCE_DIR}/include/support)
+include_directories(${CMAKE_SOURCE_DIR}/include/stream_inc)
+include_directories(${CMAKE_SOURCE_DIR}/dealpkt)
+
+add_definitions(-D_BSD_SOURCE -D_BSD_SOURCE -D__BSD_SOURCE -D__FAVOR_BSD -DHAVE_NET_ETHERNET_H)
+
+add_definitions(-fPIC)
+add_library(sapp_assistant SHARED sapp_assistant.cpp)
+add_library(gdev_assistant SHARED gdev_assistant.c)
+
+install(TARGETS sapp_assistant DESTINATION ${MESA_SDK_PREFIX}/lib/)
+install(TARGETS gdev_assistant DESTINATION ${MESA_SDK_PREFIX}/lib/)
diff --git a/inner_plug/Makefile b/inner_plug/Makefile
index 13db6a7..ab9702e 100644
--- a/inner_plug/Makefile
+++ b/inner_plug/Makefile
@@ -118,7 +118,7 @@ wangyan_keepalive_plug.so:wangyan_keepalive_plug.c ../lib/libping.a
 	mkdir -p $(RELEASE_PLT_PATH)/wangyan_keepalive_plug;
 	cp $@ $(RELEASE_PLT_PATH)/wangyan_keepalive_plug/;
 
-libsapp_assistant.so: sapp_assistant.c
+libsapp_assistant.so: sapp_assistant.cpp
 	$(CCC) -o $@ -shared -fPIC $(H_DIR) $(CFLAGS) $^ $(MODULES) $(LIB) -lMESA_field_stat2;
 	mkdir -p /opt/MESA/lib; 
 	cp $@ /opt/MESA/lib/;
diff --git a/inner_plug/gdev_assistant.c b/inner_plug/gdev_assistant.c
new file mode 100644
index 0000000..b2f9d69
--- /dev/null
+++ b/inner_plug/gdev_assistant.c
@@ -0,0 +1,472 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <assert.h>
+#include "stream.h"
+#include "stream_internal.h" 
+#include "stream_manage.h"
+#include "packet_io_internal.h"
+#include "mesa_net.h"
+#include "grule.h"
+#include "MESA_prof_load.h"
+#include "MESA_socket_wrap.h"
+#include <dlfcn.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <linux/if_ether.h>
+
+
+static void * gdev_block_c3_handle;
+static unsigned char gdev_block_c3_license[8];
+static unsigned gdev_block_c3_service_type;
+static unsigned gdev_block_c3_rule_scope;
+static int gdev_block_module_conn_flag = 0;
+
+#define GDEV_BLOCK_PLUG_CONF  "./conf/gdev_block.conf"
+
+/* ʹ�ö�̬����ģʽ, ������libc3client.so������, ����sapp���޷����� */
+static void * (*dl_grule_open)(void);
+static int (*dl_grule_opt_set)(void * hdl, int level, int type, const void * opt, size_t opt_size);
+static int (*dl_grule_connect)(void * hdl, const char * addr);
+static int (*dl_grule_send)(void * hdl, grule_t *rules, size_t rule_num, int flags);
+static int (*dl_grule_recv)(void * hdl, grule_result_t *rst, size_t rst_num, int flags);
+
+/*
+	2018-08-13, 
+		����־���ȡ������, ��û��IP�Ϸ��Լ��, �����˴����HMD����, ����......
+		���͹���֮ǰҪ���ϸ�Ϸ��Լ��, ��Ҫ�����κ���!!!
+
+		1: legal, �Ϸ�IP;
+		0: illegal, �Ƿ�IP;
+*/
+static int gdev_block_ipv4_legality_check(unsigned int ip_net_order)
+{
+	unsigned int ip_host_order;
+	
+	if(0 == ip_net_order){  /* ȫ0��ַ, �Ƿ� */
+		return 0;
+	}
+	
+	if(0xFFFFFFFF == ip_net_order){ /* �㲥��ַ, �Ƿ� */
+		return 0;
+	}
+
+	ip_host_order = ntohl(ip_net_order);
+
+	if((ip_host_order & 0xFF000000) == 0){ /* ���8λΪ0, �Ƿ� */
+		return 0;
+	}
+	
+	if((ip_host_order & 0xFF) == 0){ /* ���8λΪ0, ��ʵҲ��һ���Ƿ�, ���ǳ������Ǹ������ַ, ����Ƿ���, TODO 1 */
+		return 0;
+	}
+
+	if((ip_host_order & 0xFF) == 0xFF){ /* ���8λΪ0xff, ��ʵҲ��һ���Ƿ�, ���ǳ������Ǹ��㲥��ַ, ����Ƿ���, TODO 1 */
+		return 0;
+	}	
+
+	if((ip_host_order & 0xF0000000) == 0xE0000000){ /* �鲥��ַ, �Ƿ� */
+		return 0;
+	}
+	
+	if((ip_host_order & 0xF0000000) == 0xF0000000){ /* ������ַ, �Ƿ� */
+		return 0;
+	}
+	
+	return 1;
+}
+
+static int gdev_block_send_rule_tuple5(unsigned int sip_net, unsigned int dip_net, unsigned short sport_net, unsigned short dport_net, unsigned char protocol)
+{
+	grule_t grule;
+	grule_result_t grule_result;
+	int send_ret, recv_ret;
+
+	memset(&grule, 0, sizeof(grule_t));
+	
+	/* rule_id��ȫ�ֱ�����ȡ������, �ں���������������ڲ��� */
+	grule.srv_type = gdev_block_c3_service_type;
+	grule.rule_scope = gdev_block_c3_rule_scope;
+	grule.big_type = GRULE_BIG_TYPE_MASK4;
+	grule.durable = 0;
+	grule.action = GRULE_ACTION_ADD;
+
+	/* ʹ��tuple�������1 */
+	grule.rule_type.sip_flag = 1;
+	//grule.rule_type.sipmsk_flag = 1;
+	grule.rule_type.dip_flag = 1;
+	//grule.rule_type.dipmsk_flag = 1;
+	grule.rule_type.sport_flag = 1;
+	//grule.rule_type.spmsk_flag = 1;
+	grule.rule_type.dport_flag = 1;
+	//grule.rule_type.dpmsk_flag = 1;
+	grule.rule_type.proto_flag = 1;
+	//grule.rule_type.pmsk_flag = 1;
+
+	grule.m4.sip = sip_net;
+	//grule.m4.sip_mask = 0xFFFFFFFF;
+	grule.m4.dip = dip_net;
+	//grule.m4.dip_mask = 0xFFFFFFFF;
+	grule.m4.sport = sport_net;
+	//grule.m4.spor_mask = 0xFFFF;
+	grule.m4.dport = dport_net;
+	//grule.m4.dport_maske = 0xFFFF;
+	grule.m4.proto = protocol;
+	//grule.m4.proto_mask = 0xFF;
+
+	send_ret = dl_grule_send(gdev_block_c3_handle, &grule, 1, 0);
+	if(send_ret < 0){
+		recv_ret = dl_grule_recv(gdev_block_c3_handle, &grule_result, 1, 0);
+		printf("grule_send errno is: %u\n", grule_result.result);
+	}
+	return send_ret;
+}
+
+
+int gdev_block_send_rule(const struct streaminfo *pstream)
+{
+	unsigned char protocol;
+	int send_ret;
+
+	if(0 == gdev_block_module_conn_flag){
+		sapp_runtime_log(20, "gdev_block module not init succ!\n\n");
+		return -1;
+	}
+	
+	if(pstream->addr.addrtype != ADDR_TYPE_IPV4){
+		sapp_runtime_log(20, "gdev_block unsupport IPv6 yet!\n");
+		/* �ݲ�֧��IPv6 */
+		return -1;
+	}
+
+	if(STREAM_TYPE_TCP == pstream->type){
+		protocol = 6;
+	}else{
+		protocol = 17;
+	}
+
+	if(gdev_block_ipv4_legality_check(pstream->addr.tuple4_v4->saddr) == 0){
+		return -1;
+	}
+
+	if(gdev_block_ipv4_legality_check(pstream->addr.tuple4_v4->daddr) == 0){
+		return -1;
+	}
+	
+	send_ret = gdev_block_send_rule_tuple5(pstream->addr.tuple4_v4->saddr, pstream->addr.tuple4_v4->daddr, 
+							pstream->addr.tuple4_v4->source, pstream->addr.tuple4_v4->dest, protocol);
+	if(send_ret <= 0){
+		sapp_runtime_log(20, "gdev send c3 rule error, tuple4: %s\n", printaddr(&pstream->addr, pstream->threadnum));
+	}else{
+		sapp_runtime_log(10, "gdev send c3 rule SUCC, tuple4: %s\n", printaddr(&pstream->addr, pstream->threadnum));
+	}
+	
+	return send_ret;
+}
+
+
+static int gdev_block_hex2mem( char *source, int srclen, unsigned char* dest)
+{
+        int i,j;
+        unsigned char c,h4bit,l4bit;
+
+        if( NULL == source || NULL==dest || srclen<=0 )
+        {
+                return -1;
+        }
+
+        for(i=0,j=0; i<srclen; )
+        {
+                c = source[i];
+                if(c >= '0' && c <= '9')
+                        h4bit = c - '0';
+                else if(c >= 'A' && c <= 'F')
+                        h4bit = c - 'A' + 10;
+                else if(c >= 'a' && c <= 'f')
+                        h4bit = c - 'a' + 10;
+                else
+                {
+                        if(i == srclen -1)//the last c is 0a
+                        {
+                                return j;
+                        }
+                        else
+                        {
+                                return -1;
+                        }
+                }
+                ++i;
+
+                if(i>=srclen)
+                {
+                        return -1;
+                }
+
+                c = source[i];
+                if(c >= '0' && c <= '9')
+        	         l4bit = c - '0';
+                else if(c >= 'A' && c <= 'F')
+                        l4bit = c - 'A' + 10;
+                else if(c >= 'a' && c <= 'f')
+                        l4bit = c - 'a' + 10;
+                else
+                {
+                        return -1;
+                }
+                dest[j]= (h4bit<<4)|l4bit;				
+
+                j++;
+                i++;
+        }
+        dest[j] = '\0';
+	
+        return j;
+}
+
+/*
+	C3�����Ӻ���������, ������Ҳ������, ����һ�����Զ��Ƿ���ڵĺ���.
+	-1: error
+	 0: succ or other.
+*/
+static int gdev_detect_c3_server_is_exist(void)
+{
+	char c3_ip_str[32];
+	int ret, tmp_int;
+	unsigned short c3_port;
+	struct sockaddr_in sockadd;
+
+	MESA_load_profile_string_def(GDEV_BLOCK_PLUG_CONF, "gdev", "c3_server_ip", c3_ip_str, 32, "$");
+	MESA_load_profile_int_def(GDEV_BLOCK_PLUG_CONF, "gdev", "c3_server_port", &tmp_int, 0);
+
+	if('$' == c3_ip_str[0]){
+		return 0;
+	}
+
+	if((tmp_int > 0) && (tmp_int < 65535)){
+		c3_port = (unsigned short)tmp_int;
+	}
+
+	int sock_fd = socket(AF_INET, SOCK_STREAM, 0);
+	if(sock_fd < 0){
+		return 0;
+	}
+
+	sockadd.sin_family = AF_INET;
+	ret = inet_pton(AF_INET, c3_ip_str, &sockadd.sin_addr.s_addr);
+	if(ret <= 0){
+		goto err_exit;
+	}
+	sockadd.sin_port = htons(c3_port);
+	
+	ret = MESA_sock_connect(sock_fd, (const struct sockaddr  *)&sockadd, sizeof(sockadd), 3000);
+	if(ret < 0){
+		close(sock_fd);
+		return -1;
+	}
+	
+err_exit:
+	/* �������󶼷���0, ��ʾδȷ���Ƿ������������ */
+	close(sock_fd);
+	return 0;
+}
+
+
+/*
+	raw_dataָ������ͻ�����, �ڲ���ʵ�������ݰ���IPͷ��;
+*/
+int packet_io_send_fake_pkt_by_gdev(MESA_send_handle *send_handle, enum addr_type_t addrtype, 
+	char *raw_data, int datalen, int dir_reverse,char *feedback_buf, int *feedback_buf_len)
+{
+	const struct streaminfo_private *pstrem_pr =  (const struct streaminfo_private *)send_handle->user_arg;
+	const struct streaminfo *pstream = (const struct streaminfo *)send_handle->user_arg;
+    const struct streaminfo *tmpstream = pstream;
+	vxlan_header_t *vxlan_hdr;
+	struct vxlan_info mim_mem_hdr;
+	struct mesa_ethernet_hdr *inner_eth_hdr;
+	//struct mesa_udp_hdr *udp_hdr;
+	//struct mesa_ip4_hdr *ip4_hdr;
+	int ret, opt_len;
+	struct sockaddr_in sock_addr_v4;
+	char *data = raw_data;
+
+	while(pstream->pfather != NULL){
+		pstream = pstream->pfather; /* seek to the lowest layer */
+	}
+
+	if(ADDR_TYPE_MAC_IN_MAC != pstream->addr.addrtype){
+		sapp_runtime_log(20, "packet_io_send_fake_pkt_by_gdev error, addr type is not MAC_IN_MAC!");
+		return -1;
+	}
+
+	opt_len = sizeof(mim_mem_hdr);
+	ret = MESA_get_stream_opt(tmpstream, MSO_STREAM_VXLAN_INFO, &mim_mem_hdr, &opt_len);
+	if(ret < 0){
+		sapp_runtime_log(20, "packet_io_send_fake_pkt_by_gdev(): get vxlan info error!\n");
+		return -1;
+	}
+    data += sizeof(vxlan_header_t);/*����Ԥ����vxlanͷ��*/
+    datalen -=  sizeof(vxlan_header_t);
+
+	data += sizeof(struct mesa_ethernet_hdr);/*����mim�����MAC*/
+	datalen -= sizeof(struct mesa_ethernet_hdr);
+	inner_eth_hdr = (struct mesa_ethernet_hdr *)data;
+
+	if(dir_reverse){ /* ��ǰ����������������ʱ�ĵ�ַ�Ƿ����, �����ṹ�����Ԫ��: sip=1.1.1.1, dip=2.2.2.2, ��ǰ�뷢�͵İ�sip=2.2.2.2, dip=1.1.1.1 */
+		memcpy(inner_eth_hdr->ether_shost, pstream->addr.mimac->inner_dst_mac, MAC_ADDR_LEN);
+		memcpy(inner_eth_hdr->ether_dhost, pstream->addr.mimac->inner_src_mac, MAC_ADDR_LEN);
+	}else{
+		memcpy(inner_eth_hdr->ether_shost, pstream->addr.mimac->inner_src_mac, MAC_ADDR_LEN);
+		memcpy(inner_eth_hdr->ether_dhost, pstream->addr.mimac->inner_dst_mac, MAC_ADDR_LEN);
+	}
+
+	if(ADDR_TYPE_IPV4 == addrtype){
+		inner_eth_hdr->ether_type = htons(ETH_P_IP);
+	}else if(ADDR_TYPE_IPV6 == addrtype){
+		inner_eth_hdr->ether_type = htons(ETH_P_IPV6);
+	}else{
+		assert(0); /* */
+        sapp_runtime_log(20, "packet_io_send_fake_pkt_by_gdev(): inner_eth_hdr not IP4 or IP6, %d!\n", addrtype);
+		return -1;
+	}
+	
+	data -= sizeof(vxlan_header_t);
+	datalen +=  sizeof(vxlan_header_t);
+
+	vxlan_hdr = (vxlan_header_t *)data;
+
+	memset(vxlan_hdr, 0, sizeof(vxlan_header_t));
+
+	vxlan_hdr->link_id = mim_mem_hdr.link_id;
+	vxlan_hdr->link_layer_type = mim_mem_hdr.encap_type;
+
+	/* ����ʱ, vxlanͷ����vlan_id������ */
+
+	if(dir_reverse){ /* ��ǰ����������������ʱ�ĵ�ַ�Ƿ����, �����ṹ�����Ԫ��: sip=1.1.1.1, dip=2.2.2.2, ��ǰ�뷢�͵İ�sip=2.2.2.2, dip=1.1.1.1 */
+		vxlan_hdr->dir = mim_mem_hdr.link_dir ^ 1;
+	}else{
+		vxlan_hdr->dir = mim_mem_hdr.link_dir;
+	}
+#if 0
+	data -= sizeof(struct mesa_udp_hdr);
+	udp_hdr = (struct mesa_udp_hdr *)data;
+
+	udp_hdr->uh_sport = htons((unsigned short)sapp_global_single.send_fake_pkt_gdev_sport); /* ���������ļ���дvxlanԴ�˿� */
+	udp_hdr->uh_dport = htons(4789); 
+	udp_hdr->uh_ulen = htons(datalen + sizeof(vxlan_header_t) + sizeof(struct mesa_udp_hdr));
+	udp_hdr->uh_sum = 0;
+
+	data -= sizeof(struct mesa_ip4_hdr);
+	ip4_hdr = (struct mesa_ip4_hdr *)data;
+
+	ip4_hdr->ip_v = 4;
+	ip4_hdr->ip_hl = 5;
+	ip4_hdr->ip_tos = 0;
+	ip4_hdr->ip_len = htons(datalen + sizeof(vxlan_header_t) + sizeof(struct mesa_udp_hdr) + sizeof(struct mesa_ip4_hdr));
+	ip4_hdr->ip_off = 0;
+	ip4_hdr->ip_id = MESA_rand_range(10000, 60000);
+	ip4_hdr->ip_ttl = MESA_rand_range(64, 128);
+	ip4_hdr->ip_p = IPPROTO_UDP;
+	ip4_hdr->ip_dst.s_addr = 0xC906000A;/*  Ŀ��ID����device_id������*/
+	ip4_hdr->ip_src.s_addr = 0xE506000A; /*  ԴIP�������ļ���ã����Թ̶�*/
+#endif
+
+	sock_addr_v4.sin_family = AF_INET;
+	inet_pton(AF_INET, "10.3.127.1", &sock_addr_v4.sin_addr.s_addr);
+	//sock_addr_v4.sin_addr.s_addr = ;/* TODO, Ŀ��ID����device_id������*/
+	sock_addr_v4.sin_port = htons(4789);
+
+    ret = sendto(send_handle->raw_udp_fd, data, datalen, 0,
+				(struct sockaddr *)&sock_addr_v4, sizeof(struct sockaddr));
+
+	return ret;
+}
+
+
+int gdev_block_init(void)
+{
+	int ret;
+	char tmp_str[128];
+	char gdev_c3_addr_list[128];
+	void *libc3_client_so_handle;
+
+	libc3_client_so_handle = dlopen("/opt/MESA/lib/libc3client.so", RTLD_NOW | RTLD_NODELETE);
+	if(NULL == libc3_client_so_handle){
+		printf("\n\033[33m[Warning] dlopen '%s' error!\033[0m\n", "/opt/MESA/lib/libc3client.so");
+		return -1;
+	}
+
+	dl_grule_open = ( void * (*)(void))dlsym(libc3_client_so_handle, "grule_open");
+	if(NULL == dl_grule_open){
+		return -1;
+	}
+
+	dl_grule_opt_set = (int (*)(void * hdl, int level, int type, const void * opt, size_t opt_size))dlsym(libc3_client_so_handle, "grule_opt_set");
+	if(NULL == dl_grule_opt_set){
+		return -1;
+	}
+
+	dl_grule_connect = (int (* )(void * hdl, const char * addr))dlsym(libc3_client_so_handle, "grule_connect");
+	if(NULL == dl_grule_connect){
+		return -1;
+	}
+
+	dl_grule_send = (int (* )(void * hdl, grule_t *rules, size_t rule_num, int flags))dlsym(libc3_client_so_handle, "grule_send");
+	if(NULL == dl_grule_send){
+		return -1;
+	}
+
+	dl_grule_recv = (int (*)(void * hdl, grule_result_t *rst, size_t rst_num, int flags))dlsym(libc3_client_so_handle, "grule_recv");
+	if(NULL == dl_grule_recv){
+		return -1;
+	}
+	
+	gdev_block_c3_handle = dl_grule_open();
+	if(NULL == gdev_block_c3_handle){
+		printf("grule_open() error!\n");
+		return -1;
+	}
+
+	MESA_load_profile_string_def(GDEV_BLOCK_PLUG_CONF, "gdev", "auth_data", tmp_str, 128, "#");
+	if('#' == tmp_str[0]){/* û�ҵ�license */
+		printf( "invalid config:%s->%s!\n", GDEV_BLOCK_PLUG_CONF, "auth_data");
+		return -1;
+	}
+	ret = gdev_block_hex2mem(tmp_str, 16, (unsigned char *)gdev_block_c3_license);
+	if(ret < 0){
+		printf("invalid config:%s->%s!\n", GDEV_BLOCK_PLUG_CONF, "auth_data");
+		return -1;
+	}
+
+	MESA_load_profile_string_def(GDEV_BLOCK_PLUG_CONF, "gdev", "c3_list", gdev_c3_addr_list, 128, "#");
+	if('#' == tmp_str[0]){
+		printf("invalid config:%s->%s!\n", GDEV_BLOCK_PLUG_CONF, "c3_list");
+		return -1;
+	}
+	
+	MESA_load_profile_uint_def(GDEV_BLOCK_PLUG_CONF, "gdev", "service_type", &gdev_block_c3_service_type, 1);
+	MESA_load_profile_uint_def(GDEV_BLOCK_PLUG_CONF, "gdev", "rule_scope", &gdev_block_c3_rule_scope, 1);
+	
+	dl_grule_opt_set(gdev_block_c3_handle, GRULE_SOL_PROTO, GRULE_TYPE_AUTH, gdev_block_c3_license, sizeof(gdev_block_c3_license));
+
+	if(gdev_detect_c3_server_is_exist() < 0){
+		sapp_runtime_log(20, "grule_connect %s error!\n", gdev_c3_addr_list);
+		return -1;
+	}
+
+	ret = dl_grule_connect(gdev_block_c3_handle, gdev_c3_addr_list);
+	if(ret < 0){
+		sapp_runtime_log(20, "grule_connect %s error!\n", gdev_c3_addr_list);
+		return -1;
+	}
+	
+	gdev_block_module_conn_flag = 1;
+	sapp_runtime_log(10, "grule_connect %s succ!\n", gdev_c3_addr_list);
+
+	return 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/inner_plug/sapp_assistant.c b/inner_plug/sapp_assistant.cpp
index 828ac08..ba2d333 100644
--- a/inner_plug/sapp_assistant.c
+++ b/inner_plug/sapp_assistant.cpp
@@ -52,7 +52,7 @@ typedef struct{
 	int sapp_active_send_fs_id;
 }sapp_fs_id_t;
 
-static sapp_fs_id_t g_sapp_fs_id;
+//static sapp_fs_id_t g_sapp_fs_id;
 static const unsigned char G_BROADCAST_ADDR[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 
 
@@ -312,7 +312,7 @@ int sapp_get_platform_opt(enum sapp_platform_opt opt, void *opt_val, int *opt_va
 	return ret;
 }
 
-
+#if 0
 int sapp_fileld_stat_init(void)
 {
 	int opt;
@@ -361,6 +361,7 @@ int sapp_fileld_stat_init(void)
 	
 	return 0;
 }
+#endif
 
 /*
 	��Ϊsapp_fs_handle�����ʼ����, ���ܻ������������Ҫʹ��FS_registerע���µ��ֶ�,
@@ -370,37 +371,122 @@ int sapp_fileld_stat_init(void)
 	ʹ��һ��С����, ƽ̨��ʼ�հ���, �϶����ǿ�ʼ������.
 	Ȼ���ٵ���FS_start(sapp_fs_handle);
 */
+
+#if 0
 static void *sapp_delay_start(void *arg)
 {
-	time_t last_time;
+	//time_t last_time;
 	
 	while(0 == g_SysInputInfo[0][PKT_IP]){
 		usleep(100);
 	}
 
-	FS_start(sapp_fs_handle);
-
+	if(sapp_global_single.fs2_handle != NULL){
+		FS_start(sapp_fs_handle);
+	}
 
-	last_time = time(NULL);
+	//last_time = time(NULL);
 	while(1){
-		if(g_CurrentTime > last_time){	
-			FS_operate(sapp_fs_handle, g_sapp_fs_id.sapp_tot_pkt_fs_id, 0, FS_OP_SET, sysinfo_new[PKT_ETHERNET]);
-			FS_operate(sapp_fs_handle, g_sapp_fs_id.sapp_tot_bytes_fs_id, 0, FS_OP_SET, sysinfo_new[PKT_ETHERNET_LEN]);
-			last_time = g_CurrentTime;
-		}
-
 		usleep(1000);
 	}
 
 	return NULL;
 }
+#endif
+
+void sapp_fs2_update(int field_index, unsigned  long long value)
+{
+	if(sapp_global_single.fs2_handle != NULL){
+		FS_operate(sapp_global_single.fs2_handle, sapp_global_single.fs2_filed_id_array[field_index], 0, FS_OP_SET,  (long long)value);
+	}
+}
+
+static int sapp_fs2_init(void)
+{
+	int module_switch;
+	char cfg_ip_str[32];
+	int cfg_port;
+	int fs2_opt;
+
+	MESA_load_profile_int_def("conf/main.conf", "ShowStatInfo", "FS_switch", &module_switch, 0);
+	if(0 == module_switch){
+		sapp_global_single.fs2_handle = NULL;
+		return 0;
+	}
+
+	sapp_global_single.fs2_handle = FS_create_handle();
+	if(NULL == sapp_global_single.fs2_handle){
+		sapp_runtime_log(RLOG_LV_FATAL, "FS_create_handle() error: %s!\n", strerror(errno));
+		return -1;
+	}
+
+	MESA_load_profile_string_def("conf/main.conf", "ShowStatInfo", "FS_server_ip", cfg_ip_str,32, "#");
+	if('#' == cfg_ip_str[0]){
+		sapp_runtime_log(RLOG_LV_FATAL, "FS_switch is enable, but not found FS_server_ip config\n");
+		return -1;
+	}
+
+	sapp_global_single.fs2_server_ip = strdup(cfg_ip_str);
+
+	MESA_load_profile_int_def("conf/main.conf", "ShowStatInfo", "FS_server_port", &cfg_port, -1);
+	if(cfg_port <= 0 || cfg_port > 65535){
+		sapp_runtime_log(RLOG_LV_FATAL, "FS_server_port %d invalid!\n", cfg_port);
+		return -1;
+	}
+
+	sapp_global_single.fs2_server_port_host = (unsigned short)cfg_port;
+
+	fs2_opt = 1;
+	FS_set_para(sapp_global_single.fs2_handle, STAT_CYCLE, &fs2_opt, sizeof(int));
+
+	fs2_opt = 1; /* 1:Rewrite ,2: Append.  */
+	FS_set_para(sapp_global_single.fs2_handle, PRINT_MODE, &fs2_opt, sizeof(int));
+
+	MESA_load_profile_int_def("conf/main.conf", "ShowStatInfo", "FS_print_switch", &fs2_opt, 0);	
+	FS_set_para(sapp_global_single.fs2_handle, PRINT_TRIGGER, &fs2_opt, sizeof(int));
+
+	FS_set_para(sapp_global_single.fs2_handle, OUTPUT_DEVICE, "fs2_sysinfo.log", strlen("fs2_sysinfo.log")+1);
+
+	FS_set_para(sapp_global_single.fs2_handle, APP_NAME, "sapp", strlen("sapp")+1);
+
+	FS_set_para(sapp_global_single.fs2_handle, STATS_SERVER_IP, (void *)sapp_global_single.fs2_server_ip, strlen(sapp_global_single.fs2_server_ip)+1);
+
+	FS_set_para(sapp_global_single.fs2_handle, STATS_SERVER_PORT, &sapp_global_single.fs2_server_port_host, sizeof(short));
+
+	sapp_global_single.fs2_filed_id_array[PKT_ETHERNET] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_STATUS, FS_CALC_CURRENT, "Ethernet_pps");
+	sapp_global_single.fs2_filed_id_array[PKT_ETHERNET_LEN] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_STATUS, FS_CALC_CURRENT, "Ethernet_bps");
+
+	sapp_global_single.fs2_filed_id_array[PKT_IP] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "IPv4_pps");
+	sapp_global_single.fs2_filed_id_array[PKT_IPLEN] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "IPv4_bps");
+
+	sapp_global_single.fs2_filed_id_array[PKT_IPV6] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "IPv6_pps");
+	sapp_global_single.fs2_filed_id_array[PKT_IPV6LEN] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "IPv6_bps");
+
+	sapp_global_single.fs2_filed_id_array[PKT_TCP] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "TCP_pps");
+	sapp_global_single.fs2_filed_id_array[PKT_TCPLEN] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "TCP_bps");
+
+	sapp_global_single.fs2_filed_id_array[PKT_UDP] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "UDP_pps");
+	sapp_global_single.fs2_filed_id_array[PKT_UDPLEN] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "UDP_bps");
+
+	sapp_global_single.fs2_filed_id_array[SYS_TCP_LINK_NEW] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "TCP_LINK_NEW");
+	sapp_global_single.fs2_filed_id_array[SYS_TCP_LINK_DEL] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "TCP_LINK_DEL");
+	sapp_global_single.fs2_filed_id_array[SYS_TCP_LINK_DATA] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "TCP_CONCURRENT");
+
+	sapp_global_single.fs2_filed_id_array[SEND_TCP_RST] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "SEND_TCP_RST");
+	sapp_global_single.fs2_filed_id_array[SEND_TCP_SYN_ACK] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "SEND_TCP_S/A");
+	sapp_global_single.fs2_filed_id_array[SEND_UDP_PKT] = FS_register(sapp_global_single.fs2_handle, FS_STYLE_FIELD, FS_CALC_CURRENT, "SEND_UDP");
+
+	FS_start(sapp_global_single.fs2_handle);
+	
+	return 0;
+}
 
 
 int sapp_assistant_init(void)
 {
-	pthread_t pid;
+	///pthread_t pid;
 	
-	if(sapp_fileld_stat_init() < 0){
+	if(sapp_fs2_init() < 0){
 		return -1;
 	}
 
@@ -408,9 +494,8 @@ int sapp_assistant_init(void)
 
 	pthread_mutex_init(&g_plug_Independent_thread_mutex, NULL);
 
-	pthread_create(&pid, NULL, sapp_delay_start, NULL);
-
-	pthread_detach(pid);
+	///pthread_create(&pid, NULL, sapp_delay_start, NULL);
+	///pthread_detach(pid);
 	
 	return 1;
 }
diff --git a/packet_io/CMakeLists.txt b/packet_io/CMakeLists.txt
new file mode 100644
index 0000000..f2a3b76
--- /dev/null
+++ b/packet_io/CMakeLists.txt
@@ -0,0 +1,48 @@
+cmake_minimum_required(VERSION 2.8)
+add_definitions(-D_BSD_SOURCE -D_BSD_SOURCE -D__BSD_SOURCE -D__FAVOR_BSD=1 -DHAVE_NET_ETHERNET_H)
+add_definitions(-DPLATFORM_NSDPF_PAPP=1)
+
+include_directories(${MESA_SDK_PREFIX}/include)
+include_directories(${MESA_SDK_PREFIX}/include/MESA)
+include_directories(${CMAKE_SOURCE_DIR}/include)
+include_directories(${CMAKE_SOURCE_DIR}/include/stream_inc)
+include_directories(${CMAKE_SOURCE_DIR}/include/net)
+include_directories(${CMAKE_SOURCE_DIR}/include/support)
+include_directories(${CMAKE_SOURCE_DIR}/dealpkt)
+include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+
+add_definitions(-fPIC)
+
+if(CAPTURE_MODE MATCHES "PCAP")
+    set(PACKET_IO_SOURCE ${PACKET_IO_SOURCE} packet_io_pcap.c)
+    add_library(packet_io_pcap SHARED ${PACKET_IO_SOURCE})
+endif()
+
+if(CAPTURE_MODE MATCHES "PAG")
+	set(PACKET_IO_SOURCE ${PACKET_IO_SOURCE} packet_io_pag_marsio.c)
+    add_library(packet_io_pag_marsio SHARED ${PACKET_IO_SOURCE})
+endif()
+
+if(CAPTURE_MODE MATCHES "PPF")
+	set(PACKET_IO_SOURCE ${PACKET_IO_SOURCE} packet_io_ppf.c)
+    add_library(packet_io_ppf SHARED ${PACKET_IO_SOURCE})
+endif()
+
+if(CAPTURE_MODE MATCHES "DPDK")
+	set(PACKET_IO_SOURCE ${PACKET_IO_SOURCE} packet_io_dpdk.c)
+    add_library(packet_io_dpdk SHARED ${PACKET_IO_SOURCE})
+endif()
+
+if(CAPTURE_MODE MATCHES "MARSIO")
+	set(PACKET_IO_SOURCE ${PACKET_IO_SOURCE} packet_io_marsio.c)
+    add_library(packet_io_marsio SHARED ${PACKET_IO_SOURCE})
+endif()
+
+set(PACKET_IO_STATIC_SOURCE cycle_pkt_dump_through_write_offset.c  packet_io_lib_load.c pkt_dispatch_new.c
+iknow_info.c                           packet_io_log.c         sendpacket.c
+sendpacket_wrap.c   packet_io.c packet_io_device.c 
+packet_io_status_by_mesafs.cpp packet_io_status.cpp  packet_io_status_new.c )
+
+add_library(packet_io STATIC ${PACKET_IO_STATIC_SOURCE})
+
+target_link_libraries(packet_io timestamp_record iknow)
diff --git a/packet_io/cycle_pkt_dump_through_write.c b/packet_io/cycle_pkt_dump_through_write.c.bak
index ee6a59d..ee6a59d 100644
--- a/packet_io/cycle_pkt_dump_through_write.c
+++ b/packet_io/cycle_pkt_dump_through_write.c.bak
diff --git a/packet_io/cycle_pkt_dump_through_write_offset.c b/packet_io/cycle_pkt_dump_through_write_offset.c
index cad996e..1d2845b 100644
--- a/packet_io/cycle_pkt_dump_through_write_offset.c
+++ b/packet_io/cycle_pkt_dump_through_write_offset.c
@@ -69,6 +69,8 @@ static pkt_dump_status_t PKT_DISCARD_STAT[MAX_THREAD_NUM];
 
 #endif
 
+const int tcpdump_mesa_version_VERSION_20181114 = 20181114;
+
 extern int g_packet_io_cap_level;
 extern int g_use_MESA_sleep_sw;
 extern int MESA_mkdir_p(const char *pathname, mode_t mode);
@@ -95,6 +97,8 @@ static int pkt_dump_tcp_cmd_sd = -1;/* TCP fd,  ���ڽ����ⲿtcpdump���� */
 static volatile int pkt_dump_udp_socket_peer_alive = 0; /* �ⲿtcpdump�Ƿ��� */
 static int pkt_dump_udp_pkt_sd[MAX_THREAD_NUM]; /* UDP�������ݰ�fd */
 static struct sockaddr_in udp_recv_addr;
+static int tcpdump_perceptive_flag = 0; /* �������ģʽ, ���Է��ֶ������� */	
+static int greedy_seek_flag = 0; /* ƫ�Ƶ����ڲ�IP, ��������ģʽ�²���BUG */
 
 static unsigned char phony_mac_hdr[14] = 
 {
@@ -102,14 +106,20 @@ static unsigned char phony_mac_hdr[14] =
 	0x12, 0x23, 0x34, 0x56, 0x67, 0x78,
 	0x08, 0x00
 };
-/* ������������, δָ����������, ������sapp����, �������ò������� */
+
+
+/* ���ߴ�����������, δָ����������, ��ͨ��sendto���ʹ������ݰ�, ����sapp����, �������ò������� */
 typedef struct{
 	int sample_pkt_num;
-	char __cache_alignment[60];
-}pkt_dump_sample_t;
+	unsigned int perceptive_mode_pkt_seq;
+	char __cache_alignment[56];
+}pkt_dump_mthread_t;
+
+static pkt_dump_mthread_t pkt_dump_mthread_info[MAX_THREAD_NUM];
+
+static int raw_cfg_pkt_dump_ratio = 30; /* ȫ��Ĭ�ϲ���������, ��ʾÿ��N��������һ��, ��ֹ��������tcpdump_mesa����ƽ̨���� */
+static int cur_conn_pkt_dump_ratio = 30; /* ��ǰ���ӵĲ���������, ���������host, port��bpf����, ��Ϊȫ����ģʽ, debug�Ŵ��� */
 
-static pkt_dump_sample_t pkt_dump_sample[MAX_THREAD_NUM];
-static int pkt_dump_ratio = 30; /* ÿ��N��������һ�� */
 
 typedef struct  {
 	unsigned int magic;
@@ -313,71 +323,214 @@ done:
 
 static inline int cycle_pkt_dump_sample_by_ratio(int thread_seq)
 {
-	if(pkt_dump_sample[thread_seq].sample_pkt_num++ >= pkt_dump_ratio){
-		pkt_dump_sample[thread_seq].sample_pkt_num = 0;
+	if(pkt_dump_mthread_info[thread_seq].sample_pkt_num++ >= cur_conn_pkt_dump_ratio){
+		pkt_dump_mthread_info[thread_seq].sample_pkt_num = 0;
 		return 1;
 	}
 
 	return 0;
 }
-static void __do_cycle_pkt_dump_udp_socket(int thread_seq, const raw_pkt_t *p_raw_pkt)
+
+extern char *timet_to_str(time_t timet, char *time_str, int time_str_len);
+static char udp_start_time_str[64];
+static long long tot_udp_send_succ_num = 0; /* sendto�ɹ����� */
+static long long tot_udp_send_err_num = 0; /* ���ʹ�������, �绺������ԭ�� */
+static long long tot_udp_send_willful_discard_num = 0; /* ������������ */
+
+
+/* 
+	Ϊ��DEBUG����, ֧�ֹ������ڲ����Ԫ��, ��tcpdump -w �洢�İ������������������������ݰ�.
+	
+	return value:
+		>=0: ��������, �����tcpdump_mesa;
+		 <0: ������bpf����, �򲻷��ϲ�������, ����.
+*/
+static int cycle_pkt_dump_seek_to_inner_ip(char *pkt_buf, int pktlen, int thread_seq)
 {
-	const mesa_ethernet_hdr *ehdr;
-	const unsigned char *pktdata;
-	int pktlen;
+	struct mesa_ethernet_hdr *ehdr = (struct mesa_ethernet_hdr *)pkt_buf;
+	char *first_ip_layer = NULL;
+	struct mesa_ip4_hdr *ip4hdr_greedy;
+	struct mesa_ip6_hdr *ip6hdr_greedy;
+	int bpf_match_pkt_len = -1;
+	int bpf_match_ipv4 = 0, bpf_match_ipv6 = 0;
+
+	if(ETHERTYPE_IP == ntohs(ehdr->ether_type)){
+		first_ip_layer = pkt_buf + sizeof(struct mesa_ethernet_hdr);
+	}else if(ETHERTYPE_IPv6 == ntohs(ehdr->ether_type)){
+		first_ip_layer = pkt_buf + sizeof(struct mesa_ethernet_hdr);
+	}else{
+		first_ip_layer = NULL;
+	}
+	
+	ip4hdr_greedy = (struct mesa_ip4_hdr *)MESA_net_jump_to_layer_greedy(pkt_buf, ADDR_TYPE_MAC, __ADDR_TYPE_IP_PAIR_V4);
+	if(ip4hdr_greedy){
+		if((char *)ip4hdr_greedy == first_ip_layer){
+			bpf_match_pkt_len = pktlen; /* ���ڲ�͵�һ��IPһ��, ˵���Ǳ�׼ethernet->IPv4��, ����memmove���� */
+		}else{
+			if(pktlen <= ((char *)ip4hdr_greedy - pkt_buf)){
+				return -1; /* ����ֲ���ԭ��, ��ת���ڲ��ͷ�����, ����!! */
+			}			
+			memmove(pkt_buf + sizeof(struct mesa_ethernet_hdr),
+			        ip4hdr_greedy,
+			        pktlen - ((char *)ip4hdr_greedy - pkt_buf));
+			bpf_match_pkt_len = pktlen - ((char *)ip4hdr_greedy - pkt_buf) + sizeof(struct mesa_ethernet_hdr);
+			ehdr->ether_type = htons(ETHERTYPE_IP); /* ��һ����ܲ���IPV4, ����MPLS, VLAN��, ��Ҫ�ĳ�IP, �Ա�bpf����������ȷִ�� */
+		}
 
-	if(1 == pkt_dump_udp_socket_peer_alive){
-		if(0 == G_PKT_DUMP_PER_THREAD_SW[thread_seq]){
-			return;
-		}	
-		/* ԭʼ������ƫ������, ������һ��Ethernet֡, ���� */
-		if(pkt_dump_data_offset + 14 > p_raw_pkt->raw_pkt_len){
-			return;
+		if(bpf_match_pkt_len <= 0){
+			sapp_runtime_log(20, "cycle_pkt_dump_seek_to_inner_ip() length error!\n");
+			return -1;
 		}
 		
-		if(g_packet_io_cap_level != CAP_LEVEL_MAC){
-			pktdata =  (const unsigned char *)p_raw_pkt->raw_pkt_data-14 + pkt_dump_data_offset, 
-			pktlen = p_raw_pkt->raw_pkt_len + 14 - pkt_dump_data_offset;
-			ehdr = (const mesa_ethernet_hdr *)pktdata;
-		}else{
-			pktdata =  (const unsigned char *)p_raw_pkt->raw_pkt_data + pkt_dump_data_offset, 
-			pktlen = p_raw_pkt->raw_pkt_len - pkt_dump_data_offset;
-			ehdr = (const mesa_ethernet_hdr *)pktdata;
+		/* �������ȷ�Ĺ�������, ���������, ��֤��������ȫ, ���ϵ�������ͼ;
+	       ���û�й�������, ��ȫ����ģʽ, Ϊ�˾�����Ӱ��������߳�, ���ݲ�����ֻ��һ���ְ�.
+		*/
+		if(G_PKT_DUMP_FILTER_STR[0] != '\0'){
+			bpf_match_ipv4 == bpf_filter(G_PKT_DUMP_BPF_FILTER[thread_seq].bf_insns, 
+						    (const unsigned char *)pkt_buf, (unsigned int)bpf_match_pkt_len, (unsigned int)bpf_match_pkt_len);
 		}
+	}else{
+		bpf_match_ipv4 = 0;
+	}
 
-		/* 2017-01-06 lijia add, �ǳ���Ethernet�������� */
-		switch(ntohs(ehdr->ether_type)){
-			case ETHERTYPE_IP:
-			case ETHERTYPE_IPv6:
-			case ETHERTYPE_VLAN:
-			case ETHERTYPE_ARP:
-			break;
+	ip6hdr_greedy = (struct mesa_ip6_hdr *)MESA_net_jump_to_layer_greedy(pkt_buf, ADDR_TYPE_MAC, __ADDR_TYPE_IP_PAIR_V6);
+	if(ip6hdr_greedy){
+		if((char *)ip6hdr_greedy == first_ip_layer){
+			bpf_match_pkt_len = pktlen; /* ���ڲ�͵�һ��IPһ��, ˵���Ǳ�׼ethernet->IPv6��, ����memmove���� */
+		}else{
+			if(pktlen <= ((char *)ip4hdr_greedy - pkt_buf)){
+				return -1; /* ����ֲ���ԭ��, ��ת���ڲ��ͷ�����, ����!! */
+			}				
+			memmove(pkt_buf + sizeof(struct mesa_ethernet_hdr),
+			        ip6hdr_greedy,
+			        pktlen - ((char *)ip6hdr_greedy - pkt_buf));
+			bpf_match_pkt_len = pktlen - ((char *)ip4hdr_greedy - pkt_buf) + sizeof(struct mesa_ethernet_hdr);
+			ehdr->ether_type = htons(ETHERTYPE_IPv6); /* ��һ����ܲ���IPV6, ����MPLS, VLAN��,��Ҫ�ĳ�IP,�Ա�bpf����������ȷִ�� */
+		}
 
-			default:
-			return;
+		if(bpf_match_pkt_len <= 0){
+			sapp_runtime_log(20, "cycle_pkt_dump_seek_to_inner_ip() length error!\n");
+			return -1;
 		}
-	
+		
+
+		/* �������ȷ�Ĺ�������, ���������, ��֤��������ȫ, ���ϵ�������ͼ;
+	       ���û�й�������, ��ȫ����ģʽ, Ϊ�˾�����Ӱ��������߳�, ���ݲ�����ֻ��һ���ְ�.
+		*/
 		if(G_PKT_DUMP_FILTER_STR[0] != '\0'){
-			if(0 == bpf_filter(G_PKT_DUMP_BPF_FILTER[thread_seq].bf_insns, 
-						    (const unsigned char *)pktdata, pktlen, pktlen)){
-				return;
-			}
+			bpf_match_ipv6 == bpf_filter(G_PKT_DUMP_BPF_FILTER[thread_seq].bf_insns, 
+						    (const unsigned char *)pkt_buf, (unsigned int)bpf_match_pkt_len, (unsigned int)bpf_match_pkt_len);
 		}
+		
+	}else{
+		bpf_match_ipv6 = 0;
+	}	
 
-		if(pkt_dump_ratio > 0){
+	if(bpf_match_ipv4 || bpf_match_ipv6){
+		return 1; /* ����ͷ�����м��������tcpdump_mesa */ 
+	}else{
+		if(cur_conn_pkt_dump_ratio > 0){
 			if(0 == cycle_pkt_dump_sample_by_ratio(thread_seq)){
+				tot_udp_send_willful_discard_num++;
+				return -1;
+			}
+		}
+	}
+
+	return 1;
+}
+
+static void __do_cycle_pkt_dump_udp_socket(int thread_seq, const raw_pkt_t *p_raw_pkt)
+{
+	const unsigned char *pktdata, *for_bpf_filter_data;
+	int pktlen, for_bpf_filter_len, ret;
+	char modify_pkt_buf[2048]; /* ��Ҫ�޸�ԭʼ��, ��copy����ʱ������ */
+	struct perceptive_info *pperceptive_info;
+
+	if(0 == pkt_dump_udp_socket_peer_alive){	
+		return;
+	}
+	if(0 == G_PKT_DUMP_PER_THREAD_SW[thread_seq]){
+		return;
+	}
+	/* ԭʼ������ƫ������, ������һ��Ethernet֡, ���� */
+	if(pkt_dump_data_offset + 14 > p_raw_pkt->raw_pkt_len){
+		return;
+	}
+
+	if(0 == greedy_seek_flag){
+		if(p_raw_pkt->low_layer_type  != (enum addr_type_t)CAP_LEVEL_MAC){
+			pktdata =  (const unsigned char *)p_raw_pkt->raw_pkt_data-14 + pkt_dump_data_offset;
+			for_bpf_filter_data = pktdata;
+			pktlen = p_raw_pkt->raw_pkt_len + 14 - pkt_dump_data_offset;
+			for_bpf_filter_len = pktlen;
+		}else{
+			pktdata =  (const unsigned char *)p_raw_pkt->raw_pkt_data + pkt_dump_data_offset;
+			pktlen = p_raw_pkt->raw_pkt_len - pkt_dump_data_offset;
+		}
+
+		/* �������ȷ�Ĺ�������, ���������, ��֤��������ȫ, ���ϵ�������ͼ;
+	       ���û�й�������, ��ȫ����ģʽ, Ϊ�˾�����Ӱ��������߳�, ���ݲ�����ֻ��һ���ְ�.
+		*/
+		if(G_PKT_DUMP_FILTER_STR[0] != '\0'){
+			if(0 == bpf_filter(G_PKT_DUMP_BPF_FILTER[thread_seq].bf_insns, 
+						    (const unsigned char *)for_bpf_filter_data, for_bpf_filter_len, for_bpf_filter_len)){
 				return;
 			}
+		}else{
+			if(cur_conn_pkt_dump_ratio > 0){
+				if(0 == cycle_pkt_dump_sample_by_ratio(thread_seq)){
+					tot_udp_send_willful_discard_num++;
+					return;
+				}
+			}
 		}
-		
-		/* bingo, match filter, sendto */
-		sendto(pkt_dump_udp_pkt_sd[thread_seq], 
-				(char *)pktdata, 
-				pktlen, 
+	
+	}else{
+		pktlen = p_raw_pkt->raw_pkt_len>2048?2048:p_raw_pkt->raw_pkt_len;
+		memcpy(modify_pkt_buf, p_raw_pkt->raw_pkt_data, pktlen);
+		pktlen = cycle_pkt_dump_seek_to_inner_ip(modify_pkt_buf, pktlen, thread_seq);
+		if(pktlen < 0){
+			return;
+		}
+		pktdata = (unsigned char *)modify_pkt_buf;
+		for_bpf_filter_data = pktdata;
+		for_bpf_filter_len = pktlen;
+	}
+
+	if(tcpdump_perceptive_flag > 0){ /* ������� */
+		memcpy(modify_pkt_buf, pktdata, pktlen>2048?2048:pktlen);
+		pperceptive_info = (struct perceptive_info *)&modify_pkt_buf[6]; /* ����ԴMAC��ַ */
+		pperceptive_info->thread_id = thread_seq;
+		pperceptive_info->pkt_seq = htonl(pkt_dump_mthread_info[thread_seq].perceptive_mode_pkt_seq);
+		pkt_dump_mthread_info[thread_seq].perceptive_mode_pkt_seq++;
+		pktdata = (unsigned char *)modify_pkt_buf;
+		pktlen = pktlen>2048?2048:pktlen;
+	}
+	
+	/* bingo, match filter, sendto */
+	ret = sendto(pkt_dump_udp_pkt_sd[thread_seq], 
+			(char *)p_raw_pkt->raw_pkt_data, /* ����ʱʹ���ڲ����ݰ�ͷ, ��Ҫ��������ԭʼ�� */
+			p_raw_pkt->raw_pkt_len, 		 /* ����ʱʹ���ڲ����ݰ�ͷ, ��Ҫ��������ԭʼ�� */
+		  	MSG_DONTWAIT,
+		  	(const struct sockaddr *)&udp_recv_addr,
+		  	sizeof(udp_recv_addr));
+	if((ret < 0) && (EINTR == errno)){
+		/* ���ȱ�֤sapp��������, ���ж���ɵķ���ʧ��ֻ����һ��, ������������ */
+		ret = sendto(pkt_dump_udp_pkt_sd[thread_seq], 
+				(char *)p_raw_pkt->raw_pkt_data, 
+				p_raw_pkt->raw_pkt_len, 
 			  	MSG_DONTWAIT,
 			  	(const struct sockaddr *)&udp_recv_addr,
 			  	sizeof(udp_recv_addr));
 	}
+	
+	if(ret < 0){
+		tot_udp_send_err_num++;
+	}else{
+		tot_udp_send_succ_num ++;
+	}
+
 }
 
 static void __do_cycle_pkt_dump(int thread_seq, const raw_pkt_t *p_raw_pkt)
@@ -400,7 +553,7 @@ static void __do_cycle_pkt_dump(int thread_seq, const raw_pkt_t *p_raw_pkt)
 	}
 
 	if(G_PKT_DUMP_FILTER_STR[0] != '\0'){
-		if(g_packet_io_cap_level != CAP_LEVEL_MAC){
+		if(g_packet_io_cap_level != (enum addr_type_t)CAP_LEVEL_MAC){
 			if(0 == bpf_filter(G_PKT_DUMP_BPF_FILTER[thread_seq].bf_insns, 
 						    (const unsigned char *)p_raw_pkt->raw_pkt_data-14, 
 			       		    p_raw_pkt->raw_pkt_len+14, p_raw_pkt->raw_pkt_len+14)){
@@ -430,7 +583,7 @@ static void __do_cycle_pkt_dump(int thread_seq, const raw_pkt_t *p_raw_pkt)
 	/* ���°�����, ʱ��� */
 	pcap_hdr[0].ts.tv_sec = (unsigned int )g_CurrentTime;	
 
-	if(g_packet_io_cap_level != CAP_LEVEL_MAC){
+	if(p_raw_pkt->low_layer_type != CAP_LEVEL_MAC){
 		pcap_hdr[0].caplen = p_raw_pkt->raw_pkt_len+14;
 		pcap_hdr[0].len = p_raw_pkt->raw_pkt_len+14;
 		memcpy(&pcap_hdr[1], phony_mac_hdr, 14);
@@ -808,6 +961,7 @@ static void pkt_dump_set_default_opt(void)
 	
 	memset(G_PKT_DUMP_FILTER_STR, 0, sizeof(G_PKT_DUMP_FILTER_STR));
 	pkt_dump_data_offset = 0;
+
 	/* Ĭ�������߳�ȫ������ */
 	memset(G_PKT_DUMP_PER_THREAD_SW, 1,  sizeof(G_PKT_DUMP_PER_THREAD_SW));
 }
@@ -821,6 +975,10 @@ static void pkt_dump_parse_opt_rcv_port(const struct pkt_dump_opt *cmd_opt, cons
 
 static void pkt_dump_parse_opt_bpf_filter(const struct pkt_dump_opt *cmd_opt, const char *opt_val)
 {
+	if(ntohs(cmd_opt->opt_len) >= sizeof(G_PKT_DUMP_FILTER_STR)){
+		printf("bpf filter string is too long: %s\n", opt_val);
+		return;
+	}
 	memcpy(G_PKT_DUMP_FILTER_STR, opt_val, ntohs(cmd_opt->opt_len)); /* �Ѱ�����EOF */
 }
 
@@ -853,7 +1011,28 @@ static void pkt_dump_parse_opt_thread_index(const struct pkt_dump_opt *cmd_opt,
 	return;
 }
 
-static void cycle_pkt_dump_command_paicdiarse(int connfd)
+static int pkt_dump_reply_ack(int connfd)
+{
+	char send_buf[128];
+	struct pkt_dump_handshake *pkt_hdr;
+	struct pkt_dump_opt *ack_opt;
+
+	pkt_hdr = (struct pkt_dump_handshake *)&send_buf[0];
+	ack_opt = (struct pkt_dump_opt *)(send_buf + sizeof(struct pkt_dump_handshake));
+
+	pkt_hdr->magic = htonl(PKT_DUMP_HDR_MAGIC);
+	pkt_hdr->version = htonl(20180119);
+	pkt_hdr->opt_num = htonl(1);
+
+	ack_opt->opt_type = htons(PKT_DUMP_OPT_ACK);
+	ack_opt->opt_len = 0;
+
+	int ret = MESA_sock_force_write(connfd, send_buf, sizeof(struct pkt_dump_handshake)+sizeof(struct pkt_dump_opt), 0);
+
+	return ret;
+}
+
+static void cycle_pkt_dump_command_parse(int connfd)
 {
 	char cmd_buf[1024];
 	unsigned int i;
@@ -861,7 +1040,7 @@ static void cycle_pkt_dump_command_paicdiarse(int connfd)
 	struct pkt_dump_handshake pkt_hdr;
 	struct pkt_dump_opt cmd_opt;
 	
-	/* �ȷ���2���ֽ�tcpdump UDP���ն˿� */
+	/* tcpdump_mesa�ȷ��͹̶�ͷ��, �����ж�magic, ѡ������, �汾��֮��� */
 	ret = MESA_sock_greedy_read(connfd,  &pkt_hdr, sizeof(pkt_hdr), -1);
 	if(0 == ret){
 		goto err_exit;
@@ -871,10 +1050,16 @@ static void cycle_pkt_dump_command_paicdiarse(int connfd)
 	}
 
 	if(ntohl(pkt_hdr.magic) != PKT_DUMP_HDR_MAGIC){
-		printf("Remote tcpdump is not recognized\n");
+		printf("Remote tcpdump_mesa is not recognized!\n");
 		goto err_exit;
 	}
 
+    /* �ݲ��ϸ��޶��Զ�tcpdump_mesa�汾��, ֻ��ӡ������Ϣ */
+	if(ntohl(pkt_hdr.version) != (unsigned int)tcpdump_mesa_version_VERSION_20181114){
+		printf("Remote tcpdump_mesa version is incompatible!\n");
+		sapp_runtime_log(20, "Remote tcpdump_mesa version is incompatible!\n");
+	}
+
 	pkt_dump_set_default_opt();
 
 	for(i = 0; i < ntohl(pkt_hdr.opt_num); i++){
@@ -886,13 +1071,15 @@ static void cycle_pkt_dump_command_paicdiarse(int connfd)
 			printf("sock read error, %s\n", strerror(errno));
 			goto err_exit;
 		}
-		/* get opt value */
-		ret = MESA_sock_greedy_read(connfd,  cmd_buf, ntohs(cmd_opt.opt_len), -1);
-		if(0 == ret){
-			goto err_exit;
-		}else if(ret < 0){
-			printf("sock read error, %s\n", strerror(errno));
-			goto err_exit;
+		/* get opt value if exist */
+		if(ntohs(cmd_opt.opt_len) > 0){
+			ret = MESA_sock_greedy_read(connfd,  cmd_buf, ntohs(cmd_opt.opt_len), -1);
+			if(0 == ret){
+				goto err_exit;
+			}else if(ret < 0){
+				printf("sock read error, %s\n", strerror(errno));
+				goto err_exit;
+			}
 		}
 		
 		switch(ntohs(cmd_opt.opt_type)){
@@ -911,6 +1098,15 @@ static void cycle_pkt_dump_command_paicdiarse(int connfd)
 			case PKT_DUMP_OPT_THREAD_INDEX:
 				pkt_dump_parse_opt_thread_index(&cmd_opt, cmd_buf);
 			break;
+
+			case PKT_DUMP_OPT_PERCEPTIVE:
+				tcpdump_perceptive_flag = 1;
+			break;
+
+			case PKT_DUMP_OPT_GREEDY_SEEK:
+				greedy_seek_flag = 1;
+			break;
+
 			default:
 				/* δ֪ѡ������������ */
 				break;
@@ -923,29 +1119,54 @@ static void cycle_pkt_dump_command_paicdiarse(int connfd)
 			goto err_exit;
 		}		
 
-		if(G_PKT_DUMP_FILTER_STR[0] != '\0'){ /* ����û��filter */
+		if(G_PKT_DUMP_FILTER_STR[0] != '\0'){ /* ����û��filter, ��ȫ���� */
 			if(pcap_compile(phony_pcap_handle[i], &G_PKT_DUMP_BPF_FILTER[i], G_PKT_DUMP_FILTER_STR, 100, 0) < 0){                
 				printf("Compile pcap filter '%s' error:%s\n", G_PKT_DUMP_FILTER_STR, pcap_geterr(phony_pcap_handle[i]));                
 				goto err_exit;    
 			}
+			/* �������ȷ�Ĺ�������, ���������, ��֤�����������ϵ�������ͼ */
+			cur_conn_pkt_dump_ratio = 0;			
 		}
 	}
 
 	pkt_dump_udp_socket_peer_alive = 1;
 
-	/* �Ժ��ٴ����κ�����, ������ȡ, ֱ���Զ����ӽ��� */
-	while(MESA_sock_greedy_read(connfd,  cmd_buf, sizeof(cmd_buf), -1)  != 0);
+	if(pkt_dump_reply_ack(connfd) < 0 ){
+		goto err_exit;
+	}
+
+	timet_to_str(time(NULL),  udp_start_time_str, 64);
+
+	/* ��tcpdump_mesa���������Ժ��ٴ����κ�����, ������ȡ�������κν���, ֱ���Զ�tcpdump_mesa���ӽ��� */
+	while(MESA_sock_greedy_read(connfd,  cmd_buf, sizeof(cmd_buf), -1) != 0);
+
+	MESA_handle_runtime_log(g_sapp_log_handle, 20, "tcpdump_mesa", "capture start at %s, send pkt succ: %lld, error: %lld, willful discard:%lld!",
+						   udp_start_time_str,
+						   tot_udp_send_succ_num,
+						   tot_udp_send_err_num,
+						   tot_udp_send_willful_discard_num);
 
 err_exit:
-	pkt_dump_udp_socket_peer_alive = 0;
-	usleep(1000 * 500); /* ��ʱ�ͷ�, �������߳�����ʹ��BPF������ */
-	for(i = 0; i <  (unsigned int )g_packet_io_thread_num; i++){
-		pcap_freecode(&G_PKT_DUMP_BPF_FILTER[i]);
-	}
+	/* �ָ����ֱ�����Ĭ��ֵ */
+	pkt_dump_udp_socket_peer_alive = 0; /* NOTE: ���������жϺ�, ��һ���ȹرղ������� */
+	tot_udp_send_succ_num = 0; /* sendto�ɹ����� */
+	tot_udp_send_err_num = 0; /* ���ʹ�������, �绺������ԭ�� */
+	tot_udp_send_willful_discard_num = 0; /* ������������ */
+	tcpdump_perceptive_flag = 0;
+	greedy_seek_flag = 0;
+	
 	memset(G_PKT_DUMP_FILTER_STR, 0, sizeof(G_PKT_DUMP_FILTER_STR));
 	pkt_dump_data_offset = 0;
+	cur_conn_pkt_dump_ratio = raw_cfg_pkt_dump_ratio;
+	
 	/* �ɵ������߳�ָ������, ÿ�λָ�Ĭ��ֵ */
 	memset(G_PKT_DUMP_PER_THREAD_SW, 0,  sizeof(G_PKT_DUMP_PER_THREAD_SW));
+	usleep(1000 * 500); /* ��ʱ�ͷ�, �������߳�����ʹ��BPF������ */
+	for(i = 0; i <  (unsigned int )g_packet_io_thread_num; i++){
+		pcap_freecode(&G_PKT_DUMP_BPF_FILTER[i]);
+		pkt_dump_mthread_info[i].sample_pkt_num = 0;
+		pkt_dump_mthread_info[i].perceptive_mode_pkt_seq = 0;
+	}	
 	close(connfd);
 	return;
 }
@@ -966,7 +1187,7 @@ static void * cycle_pkt_dump_udp_socket_daemon_thread(void *arg)
 		connfd = accept(pkt_dump_tcp_cmd_sd, (struct sockaddr *) &cliaddr, &cliaddr_len);
 		if(connfd > 0){
 			//cycle_pkt_dump_command_parse(connfd);
-			cycle_pkt_dump_command_paicdiarse(connfd);
+			cycle_pkt_dump_command_parse(connfd);
 		}
 	}
 
@@ -993,7 +1214,7 @@ static int cycle_pkt_dump_socket_init(void)
 		printf("pkt dump bind cmd port %u error, %s!\n", pkt_dump_tcp_bind_port, strerror(errno));
 		return -1;
 	}
-	listen(pkt_dump_tcp_cmd_sd,  1); /* ��ʱֻ֧��һ���ͻ��˲��� */
+	listen(pkt_dump_tcp_cmd_sd,  1); /* ��֧�ֲ���, ��ʱֻ֧��һ���ͻ��˲��� */
 
 	for(i = 0; i < g_packet_io_thread_num; i++){
 		pkt_dump_udp_pkt_sd[i] = socket(AF_INET, SOCK_DGRAM, 0);
@@ -1006,7 +1227,7 @@ static int cycle_pkt_dump_socket_init(void)
 
 int cycle_pkt_dump_init(int argc, char *argv[])
 {
-	int i, ret;
+	int i, ret = 0;
 	int int_tmp, total_files_size, core_num;
 	char per_thread_sw[PATH_MAX];
 	char pcap_errbuf[PCAP_ERRBUF_SIZE];
@@ -1031,8 +1252,8 @@ int cycle_pkt_dump_init(int argc, char *argv[])
 	pkt_dump_tcp_bind_port = (unsigned short)int_tmp;
 
 
-	MESA_load_profile_int_def((char *)"conf/main.conf", (char *)"pkt_dump", (char *)"pkt_dump_ratio", &pkt_dump_ratio, 30);
-
+	MESA_load_profile_int_def((char *)"conf/main.conf", (char *)"pkt_dump", (char *)"pkt_dump_ratio", &raw_cfg_pkt_dump_ratio, 30);
+	cur_conn_pkt_dump_ratio = raw_cfg_pkt_dump_ratio;
 	
 #if 0 == CYCLE_PKT_DUMP
 	printf("\n\033[33m[Warning]pkt_dump is enable, but sapp is not compile correct, please use debug=2.\033[0m\n");
diff --git a/packet_io/cycle_pkt_dump_through_write_with_offset.c b/packet_io/cycle_pkt_dump_through_write_with_offset.c.bak2
index 8a018f4..8a018f4 100644
--- a/packet_io/cycle_pkt_dump_through_write_with_offset.c
+++ b/packet_io/cycle_pkt_dump_through_write_with_offset.c.bak2
diff --git a/packet_io/mesa_pkt_dump.h b/packet_io/mesa_pkt_dump.h
index 3239e3c..43011cd 100644
--- a/packet_io/mesa_pkt_dump.h
+++ b/packet_io/mesa_pkt_dump.h
@@ -1,6 +1,8 @@
 #ifndef _MESA_PKT_DUMP_H_
 #define _MESA_PKT_DUMP_H_ 1
 
+#define MESA_PKT_DUM_H_VER (20181115)
+
 /* 
 	����DPDK-3.0, PFRINGģʽ��, ������ռ����ʱ, ͨ��ƽ̨ʵʱ����.
 */
@@ -12,6 +14,9 @@ enum pkt_dump_opt_t{
 	PKT_DUMP_OPT_BPF_FILTER,
 	PKT_DUMP_OPT_DATA_OFFSET,
 	PKT_DUMP_OPT_THREAD_INDEX,	
+	PKT_DUMP_OPT_ACK, /* sapp���ظ�tcpdump_mesa��ack�� */
+	PKT_DUMP_OPT_PERCEPTIVE, /* �������ģʽ, ���Է��ֶ������� */	
+	PKT_DUMP_OPT_GREEDY_SEEK,  /* ƫ�Ƶ����ڲ�IP, ��������ģʽ�²���BUG */ 
 };
 
 /* ������, �����Ժ�������ϵͳ��ARM, PowerPC, MIPS����ֲ */
@@ -28,5 +33,11 @@ struct pkt_dump_handshake{
 	unsigned int opt_num; /* ����ѡ�������, �籾�˽��ն˿ں�, BPF��������, ����offsetֵ�ȵ� */
 }__attribute__((packed, aligned(1)));
 
+struct perceptive_info{
+	unsigned char thread_id;
+	unsigned char pad;
+	unsigned int pkt_seq; /* ��0��ʼ�ۼ�, ���seq�пն�, ˵����������ж��˶��ٰ� */
+}__attribute__((packed, aligned(1)));
 
 #endif
+
diff --git a/packet_io/packet_io_dpdk_vxlan.c b/packet_io/packet_io_dpdk_vxlan.c
index efeb77b..4185503 100644
--- a/packet_io/packet_io_dpdk_vxlan.c
+++ b/packet_io/packet_io_dpdk_vxlan.c
@@ -42,6 +42,7 @@ extern unsigned char sendto_gdev_card_mac[6];
 /*
 	�˽ṹ�������׼vxlan(RFC7348)��ͬ, ������ר���豸��, ʹ����ĳЩ��׼���Ԥ���ֶ�.
 */
+#if 0
 typedef struct{
 	unsigned int r0:1;
 	unsigned int r1:1;
@@ -62,6 +63,7 @@ typedef struct{
 	unsigned int r8:24;
 	unsigned int flags:8;
 }vxlan_hdr_t;
+#endif
 
 #define RESERVED_HDR_LEN (sizeof(struct mesa_ethernet_hdr) + sizeof(struct mesa_ip4_hdr) + sizeof(struct mesa_udp_hdr) + sizeof(vxlan_hdr_t))
 
diff --git a/packet_io/packet_io_internal.h b/packet_io/packet_io_internal.h
index 6601bf8..8d93b0c 100644
--- a/packet_io/packet_io_internal.h
+++ b/packet_io/packet_io_internal.h
@@ -18,6 +18,7 @@ typedef struct{
 	int threadnum; 
 	int raw_ipv4_fd; /* �����ڷ���IPv4��rst�� */
 	int raw_ipv6_fd; /* �����ڷ���IPv6��rst�� */
+	int raw_udp_fd;
 	int raw_eth_fd; /* �����ڷ���Ethernetԭʼ���� */
 	unsigned char *send_buf;
 	void *low_level_send_handle; /* �ײ㷢�����, ���ݵײ�����, ͨ��dl_io_get_send_handle()��ȡ */
@@ -26,6 +27,7 @@ typedef struct{
 	unsigned long tot_send_pkt;
 	unsigned long tot_send_byte;
 	unsigned long tot_send_err;
+	void *user_arg; /* 2018-08-31 lijia add, for PanGu, ʹ�ô���vxlan����rst�� */
 }MESA_send_handle;
 
 /* 2012-07-10 LiJia add, ��������ģʽ���ɸ��������ļ����ݣ����Ĺ���ģʽ: 
@@ -56,6 +58,30 @@ typedef struct{
 #define DEV_NAME_STR_LEN			(32)
 
 extern int g_topology_mode;
+typedef struct 
+{
+	unsigned char flags;
+
+	/*------------byte delim -------*/
+	unsigned char reserved[3];
+
+	/*--------int delim -------*/
+	unsigned char vlan_id_half_high;
+	unsigned char link_layer_type : 4; /* ���㱨�ķ�װ��ʽ */
+	unsigned char vlan_id_half_low : 4;
+	unsigned int online_test : 1;
+	unsigned int link_id : 6;
+	unsigned int dir : 1;
+
+	unsigned int r7 : 1;
+	unsigned int r6 : 1;
+	unsigned int r5 : 1;
+	unsigned int r4 : 1;
+	unsigned int vni_flag : 1;
+	unsigned int r2 : 1;
+	unsigned int r1 : 1;
+	unsigned int r0 : 1;
+}vxlan_header_t;  /* ����GDEV��׼ */
 
 struct sendpacket_mac_table{
 	unsigned char src_mac[6];
@@ -115,6 +141,7 @@ enum timestamp_level{
 /* ��ʱ�洢���ڹ���ÿ���ͷ�Ĳ���, ��ip->id, ip->ttl, tcp->flags, tcp->win������ */
 typedef struct{
 	void *layer_args[__ADDR_TYPE_MAX];
+	long long __pad[6];
 }layer_args_t;
 
 struct dl_io_lib_name{
diff --git a/packet_io/packet_io_status.c b/packet_io/packet_io_status.cpp
index e8cfc8b..adaa76e 100644
--- a/packet_io/packet_io_status.c
+++ b/packet_io/packet_io_status.cpp
@@ -1,248 +1,334 @@
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdio.h>
-#include <string.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <arpa/inet.h>
-#include "dealpkt.h"
-#include "packet_io.h"
-#include "packet_io_internal.h"
-#include "stream_manage.h"
-#include "mesa_net.h"
-#include "sysinfo.h"
-#include "logger.h"
-#include <assert.h>
-#include <errno.h>
-
-#define STATS_STR_LEN	(32)
-
-volatile int update_packet_io_status_sw = 1;
-
-static unsigned long long sysinfo_old[COUNTER_NUM] = {0};
-static unsigned long long TO_KB = 1024;
-static unsigned long long TO_MB = 1024 * 1024;
-static unsigned long long TO_GB = 1024 * 1024 * 1024UL;
-static unsigned long long TO_TB;
-
-extern volatile unsigned long long sysinfo_new[COUNTER_NUM];
-
-extern int g_packet_io_thread_num;
-extern void pkt_runtime_output(void);
-
-/* ת���������׶������������ַ���, ��123bps, 34.5Mbps */
-static char *byte_convert_human(unsigned long long bytes, int interval, int multiple, char * byte_str)
-{
-    bytes *= multiple; /* to network pattern, or human pattern */
-
-    bytes /= interval; /* per second */
-
-    if(bytes < TO_KB){
-        snprintf(byte_str,STATS_STR_LEN,"%llu", bytes);
-    }else if(bytes < TO_MB){
-        snprintf(byte_str,STATS_STR_LEN,"%.2fK", (float)bytes/TO_KB);
-    }else if(bytes < TO_GB){
-        snprintf(byte_str,STATS_STR_LEN,"%.2fM", (float)bytes/TO_MB);
-    }else if(bytes < TO_TB){
-        snprintf(byte_str,STATS_STR_LEN,"%.2fG", (float)bytes/TO_GB);
-    }else{
-        snprintf(byte_str,STATS_STR_LEN,"%.2fT", (double)bytes/TO_TB);	
-    }
-
-    return byte_str;
-}
-
-
-void sysinfo_output(void)
-{
-	int i;
-	FILE* fp;
-	
-	static unsigned long long g_SysInputInfo_old[MAX_THREAD_NUM][COUNTER_NUM];
-	char s1[STATS_STR_LEN], s2[STATS_STR_LEN];
-
-	if(0 == update_packet_io_status_sw){
-		return;
-	}
-
-	memset((void *)sysinfo_new, 0, sizeof(sysinfo_new));
-
-	for(i=0;i<g_packet_io_thread_num;i++)
-	{
-		sysinfo_new[PKT_ETHERNET]  += g_SysInputInfo[i][PKT_ETHERNET];
-		sysinfo_new[PKT_ETHERNET_LEN]  += g_SysInputInfo[i][PKT_ETHERNET_LEN];
-		sysinfo_new[PKT_IP]  += g_SysInputInfo[i][PKT_IP];
-		sysinfo_new[PKT_IPLEN]  += g_SysInputInfo[i][PKT_IPLEN];
-		sysinfo_new[PKT_IPV6]  += g_SysInputInfo[i][PKT_IPV6];
-		sysinfo_new[PKT_IPV6LEN]  += g_SysInputInfo[i][PKT_IPV6LEN];
-		sysinfo_new[PKT_TCP]  += g_SysInputInfo[i][PKT_TCP];
-		sysinfo_new[PKT_TCPLEN]  += g_SysInputInfo[i][PKT_TCPLEN];
-		sysinfo_new[PKT_UDP]  += g_SysInputInfo[i][PKT_UDP];
-		sysinfo_new[PKT_UDPLEN]  += g_SysInputInfo[i][PKT_UDPLEN];
-		sysinfo_new[PKT_UNKNOWN]  += g_SysInputInfo[i][PKT_UNKNOWN];
-		sysinfo_new[PKT_UNKNOWN_LEN]  += g_SysInputInfo[i][PKT_UNKNOWN_LEN];
-
-		sysinfo_new[TCPV4_LINK_TOTAL]  += g_SysInputInfo[i][TCPV4_LINK_TOTAL];
-		sysinfo_new[TCPV4_LINK_NEW_CREATE] += g_SysInputInfo[i][TCPV4_LINK_NEW_CREATE];
-		sysinfo_new[TCPV4_LINK_CLOSE] += g_SysInputInfo[i][TCPV4_LINK_CLOSE];
-
-		sysinfo_new[TCPV6_LINK_TOTAL]  +=  g_SysInputInfo[i][TCPV6_LINK_TOTAL];
-		sysinfo_new[TCPV6_LINK_NEW_CREATE] += g_SysInputInfo[i][TCPV6_LINK_NEW_CREATE];
-		sysinfo_new[TCPV6_LINK_CLOSE] += g_SysInputInfo[i][TCPV6_LINK_CLOSE];
-		
-		sysinfo_new[UDPV4_LINK_TOTAL]  += g_SysInputInfo[i][UDPV4_LINK_TOTAL];;
-		sysinfo_new[UDPV4_LINK_NEW_CREATE] += g_SysInputInfo[i][UDPV4_LINK_NEW_CREATE];
-		sysinfo_new[UDPV4_LINK_CLOSE] += g_SysInputInfo[i][UDPV4_LINK_CLOSE];		
-
-		sysinfo_new[UDPV6_LINK_TOTAL]  += g_SysInputInfo[i][UDPV6_LINK_TOTAL];;
-		sysinfo_new[UDPV6_LINK_NEW_CREATE] += g_SysInputInfo[i][UDPV6_LINK_NEW_CREATE];
-		sysinfo_new[UDPV6_LINK_CLOSE] += g_SysInputInfo[i][UDPV6_LINK_CLOSE];	
-
-		sysinfo_new[TUNNEL_6OVER4] += g_SysInputInfo[i][TUNNEL_6OVER4];
-		sysinfo_new[TUNNEL_6OVER4_LEN] += g_SysInputInfo[i][TUNNEL_6OVER4_LEN];
-		sysinfo_new[TUNNEL_TEREDO] += g_SysInputInfo[i][TUNNEL_TEREDO];
-		sysinfo_new[TUNNEL_TEREDO_LEN] += g_SysInputInfo[i][TUNNEL_TEREDO_LEN];
-
-		sysinfo_new[SEND_TCP_RST] += g_SysInputInfo[i][SEND_TCP_RST];
-		sysinfo_new[SEND_TCP_RST_LEN] += g_SysInputInfo[i][SEND_TCP_RST_LEN];
-
-		sysinfo_new[SEND_TCP_SYN_ACK] += g_SysInputInfo[i][SEND_TCP_SYN_ACK];
-		sysinfo_new[SEND_TCP_SYN_ACK_LEN] += g_SysInputInfo[i][SEND_TCP_SYN_ACK_LEN];
-
-		sysinfo_new[SEND_UDP_PKT] += g_SysInputInfo[i][SEND_UDP_PKT];
-		sysinfo_new[SEND_UDP_PKT_LEN] += g_SysInputInfo[i][SEND_UDP_PKT_LEN];		
-	}
-
-	fp = fopen("./sysinfo.log","w+");
-	if(fp == NULL)
-	{
-		printf(" fopen sysinfo.log error, %s!\n", strerror(errno));
-		return;
-	}
-
-	fprintf(fp,"\n*********************** \033[41m%s\033[0m *************************\n", "sysinfo exactly");
-	fprintf(fp,"%-10s %12s %12s %12s %12s\n","RCV-PKT", "total_pkt", "total_len","pps", "Bps");
-	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "Ethernet", sysinfo_new[PKT_ETHERNET],sysinfo_new[PKT_ETHERNET_LEN],(sysinfo_new[PKT_ETHERNET]-sysinfo_old[PKT_ETHERNET]),(sysinfo_new[PKT_ETHERNET_LEN]-sysinfo_old[PKT_ETHERNET_LEN]));
-	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "IPv4", sysinfo_new[PKT_IP],sysinfo_new[PKT_IPLEN],(sysinfo_new[PKT_IP]-sysinfo_old[PKT_IP]),(sysinfo_new[PKT_IPLEN]-sysinfo_old[PKT_IPLEN]));
-	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n","IPv6",sysinfo_new[PKT_IPV6],sysinfo_new[PKT_IPV6LEN],(sysinfo_new[PKT_IPV6]-sysinfo_old[PKT_IPV6]),(sysinfo_new[PKT_IPV6LEN]-sysinfo_old[PKT_IPV6LEN]));
-	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n","TCP",sysinfo_new[PKT_TCP],sysinfo_new[PKT_TCPLEN],(sysinfo_new[PKT_TCP]-sysinfo_old[PKT_TCP]),(sysinfo_new[PKT_TCPLEN]-sysinfo_old[PKT_TCPLEN]));
-	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n","UDP",sysinfo_new[PKT_UDP],sysinfo_new[PKT_UDPLEN],(sysinfo_new[PKT_UDP]-sysinfo_old[PKT_UDP]),(sysinfo_new[PKT_UDPLEN]-sysinfo_old[PKT_UDPLEN]));
-	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n","Unknown",sysinfo_new[PKT_UNKNOWN],sysinfo_new[PKT_UNKNOWN_LEN],(sysinfo_new[PKT_UNKNOWN]-sysinfo_old[PKT_UNKNOWN]),(sysinfo_new[PKT_UNKNOWN_LEN]-sysinfo_old[PKT_UNKNOWN_LEN]));
-	fprintf(fp,"\n***************************************************************\n");
-	fprintf(fp,"%-10s %12s %12s %12s %12s\n","SND-PKT", "total_pkt", "total_len","pps", "Bps");
-	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "TCP_RST", sysinfo_new[SEND_TCP_RST],sysinfo_new[SEND_TCP_RST_LEN],(sysinfo_new[SEND_TCP_RST]-sysinfo_old[SEND_TCP_RST]),(sysinfo_new[SEND_TCP_RST_LEN]-sysinfo_old[SEND_TCP_RST_LEN]));
-	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "TCP_S/A", sysinfo_new[SEND_TCP_SYN_ACK],sysinfo_new[SEND_TCP_SYN_ACK_LEN],(sysinfo_new[SEND_TCP_SYN_ACK]-sysinfo_old[SEND_TCP_SYN_ACK]),(sysinfo_new[SEND_TCP_SYN_ACK_LEN]-sysinfo_old[SEND_TCP_SYN_ACK_LEN]));
-	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "UDP", sysinfo_new[SEND_UDP_PKT],sysinfo_new[SEND_UDP_PKT_LEN],(sysinfo_new[SEND_UDP_PKT]-sysinfo_old[SEND_UDP_PKT]),(sysinfo_new[SEND_UDP_PKT_LEN]-sysinfo_old[SEND_UDP_PKT_LEN]));
-
-
-	fprintf(fp,"\n%-10s %12s %12s\n", "TUNNEL", "total_pkt", "total_len");	
-	fprintf(fp,"%-10s %12llu %12llu\n", "6over4", sysinfo_new[TUNNEL_6OVER4], sysinfo_new[TUNNEL_6OVER4_LEN]); 
-	fprintf(fp,"%-10s %12llu %12llu\n","teredo",sysinfo_new[TUNNEL_TEREDO], sysinfo_new[TUNNEL_TEREDO_LEN]);
-
-#if (0 == SAPP_AS_TARGET_SO) /* ��Ϊ.so����ʱ, �޵ײ�IO��֧��, ������ö���ͳ�� */
-	fprintf(fp,"\n%-10s %12s\n", "DROP", "total_pkt");
-	fprintf(fp,"%-10s %12ld\n", "app", packet_io_get_app_drop_num_tot());
-	fprintf(fp,"%-10s %12ld\n\n", "lib", packet_io_get_lib_drop_num());
-#endif
-
-	fprintf(fp,"\n------------------------------- TCP statistics detail -----------------------------\n");
-	fprintf(fp,"%3s %-27s %-19s %-27s\n", "", "|-----------Current---------|", "|------Realtime-----|", "|--------From-of-startup---------|");
-	fprintf(fp,"%3s %8s %9s %10s %10s %10s %10s %9s %13s\n", "tid", "link-syn", "link-data", "link-nouse", "link-new/s", "link-del/s", "stream-num", "reset-num", "hash-list-max");
-	for(i = 0; i < g_packet_io_thread_num; i++){	
-		fprintf(fp, "%3d %8llu %9llu %10llu %10llu %10llu %10llu %9llu %13llu\n", 
-				i, 
-				g_SysInputInfo[i][SYS_TCP_LINK_SYN], 
-				g_SysInputInfo[i][SYS_TCP_LINK_DATA],
-				g_SysInputInfo[i][SYS_TCP_LINK_NOUSE], 
-				(g_SysInputInfo[i][SYS_TCP_LINK_NEW]-g_SysInputInfo_old[i][SYS_TCP_LINK_NEW]), 
-				(g_SysInputInfo[i][SYS_TCP_LINK_DEL]-g_SysInputInfo_old[i][SYS_TCP_LINK_DEL]),
-				g_SysInputInfo[i][SYS_TCP_LINK_NEW],
-				g_SysInputInfo[i][SYS_TCP_LINK_RESET],
-				g_SysInputInfo[i][SYS_HASH_LIST_MAX]);
-	}
-
-	fprintf(fp,"\n-------------------------- UDP statistics detail ------------------------\n");
-	fprintf(fp,"%3s %-27s %-19s %-20s\n", "  ", "|-----------Current---------|", "|------Realtime-----|", "|--From-of-startup--|");
-	fprintf(fp,"%3s %8s %9s %10s %10s %10s %10s %9s\n", "tid", "link-one", "link-two", "link-more", "link-new/s", "link-del/s", "stream-num", "reset-num");
-	for(i = 0; i < g_packet_io_thread_num; i++){	
-		fprintf(fp, "%3d %8llu %9llu %10llu %10llu %10llu %10llu %9llu\n", 
-				i, 
-				g_SysInputInfo[i][SYS_UDP_LINK_ONE], 
-				g_SysInputInfo[i][SYS_UDP_LINK_TWO],
-				g_SysInputInfo[i][SYS_UDP_LINK_MORE], 
-				(g_SysInputInfo[i][SYS_UDP_LINK_NEW]-g_SysInputInfo_old[i][SYS_UDP_LINK_NEW]), 
-				(g_SysInputInfo[i][SYS_UDP_LINK_DEL]-g_SysInputInfo_old[i][SYS_UDP_LINK_DEL]),
-				g_SysInputInfo[i][SYS_UDP_LINK_NEW],
-				g_SysInputInfo[i][SYS_UDP_LINK_RESET]);
-	}
-	
-	fprintf(fp,"*****************************************************************\n\n");
-	fprintf(fp,"################# \033[41m%s\033[0m --- is same as above! #########\n", "sysinfo humanly");
-	fprintf(fp,"%-10s %12s %12s %12s %12s\n", "RCV-PKT", "total_pkt", "total_len","pps", "bps");
-	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","Ethernet",sysinfo_new[PKT_ETHERNET],byte_convert_human(sysinfo_new[PKT_ETHERNET_LEN],1 ,1,s1),(sysinfo_new[PKT_ETHERNET]-sysinfo_old[PKT_ETHERNET]),byte_convert_human((sysinfo_new[PKT_ETHERNET_LEN]-sysinfo_old[PKT_ETHERNET_LEN]),1,8,s2));
-	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","IPv4",sysinfo_new[PKT_IP],byte_convert_human(sysinfo_new[PKT_IPLEN],1 ,1,s1),(sysinfo_new[PKT_IP]-sysinfo_old[PKT_IP]),byte_convert_human((sysinfo_new[PKT_IPLEN]-sysinfo_old[PKT_IPLEN]),1,8,s2));
-	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","IPv6",sysinfo_new[PKT_IPV6],byte_convert_human(sysinfo_new[PKT_IPV6LEN],1,1,s1),(sysinfo_new[PKT_IPV6]-sysinfo_old[PKT_IPV6]),byte_convert_human((sysinfo_new[PKT_IPV6LEN]-sysinfo_old[PKT_IPV6LEN]),1,8,s2));
-	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","TCP",sysinfo_new[PKT_TCP],byte_convert_human(sysinfo_new[PKT_TCPLEN],1,1,s1),(sysinfo_new[PKT_TCP]-sysinfo_old[PKT_TCP]),byte_convert_human((sysinfo_new[PKT_TCPLEN]-sysinfo_old[PKT_TCPLEN]),1,8,s2));
-	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","UDP",sysinfo_new[PKT_UDP],byte_convert_human(sysinfo_new[PKT_UDPLEN],1,1,s1),(sysinfo_new[PKT_UDP]-sysinfo_old[PKT_UDP]),byte_convert_human((sysinfo_new[PKT_UDPLEN]-sysinfo_old[PKT_UDPLEN]),1,8,s2));	
-	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","Unknown",sysinfo_new[PKT_UNKNOWN],byte_convert_human(sysinfo_new[PKT_UNKNOWN_LEN],1,1,s1),(sysinfo_new[PKT_UNKNOWN]-sysinfo_old[PKT_UNKNOWN]),byte_convert_human((sysinfo_new[PKT_UNKNOWN_LEN]-sysinfo_old[PKT_UNKNOWN_LEN]),1,8,s2));
-	fprintf(fp,"#################################################################\n");
-	fprintf(fp,"%-10s %12s %12s %12s %12s\n","SND-PKT", "total_pkt", "total_len","pps", "bps");
-	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n", "TCP_RST", sysinfo_new[SEND_TCP_RST], byte_convert_human(sysinfo_new[SEND_TCP_RST_LEN], 1, 1, s1),(sysinfo_new[SEND_TCP_RST]-sysinfo_old[SEND_TCP_RST]), byte_convert_human((sysinfo_new[SEND_TCP_RST_LEN]-sysinfo_old[SEND_TCP_RST_LEN]), 1,8,s2));
-	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n", "TCP_S/A", sysinfo_new[SEND_TCP_SYN_ACK], byte_convert_human(sysinfo_new[SEND_TCP_SYN_ACK_LEN], 1, 1, s1),(sysinfo_new[SEND_TCP_SYN_ACK]-sysinfo_old[SEND_TCP_SYN_ACK]), byte_convert_human((sysinfo_new[SEND_TCP_SYN_ACK_LEN]-sysinfo_old[SEND_TCP_SYN_ACK_LEN]),1,8,s2));
-	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n", "UDP", sysinfo_new[SEND_UDP_PKT], byte_convert_human(sysinfo_new[SEND_UDP_PKT_LEN],1,1,s1),(sysinfo_new[SEND_UDP_PKT]-sysinfo_old[SEND_UDP_PKT]), byte_convert_human((sysinfo_new[SEND_UDP_PKT_LEN]-sysinfo_old[SEND_UDP_PKT_LEN]),1,8,s2));
-
-	fprintf(fp,"#################################################################\n\n");
-	
-	memcpy((void *)sysinfo_old, (void *)sysinfo_new,sizeof(unsigned long long)*COUNTER_NUM);
-	memcpy(g_SysInputInfo_old, (void *)g_SysInputInfo, sizeof(g_SysInputInfo));
-
-	fclose(fp);
-
-	return ;
-}
-
-
-void *time_event_thread(void *arg)
-{
-	time_t last_log_time;
-
-#if(__GNUC__ * 100 + __GNUC_MINOR__ * 10 + __GNUC_PATCHLEVEL__ >= 480) /* �汾�ж�, �ܶ��ϵͳ�޷����� */
-#ifdef _GNU_SOURCE
-	pthread_setname_np(pthread_self(), "sapp_time_event");
-#endif
-#endif
-
-	TO_KB = 1024UL;
-	TO_MB = 1024 * 1024UL;
-	TO_GB = 1024 * 1024 * 1024UL;
-	TO_TB = (unsigned long long)1024 * 1024 * 1024 * 1024UL;
-
-	last_log_time = time(NULL);
-	
-	while(1)
-	{
-		g_CurrentTime = time(NULL);
-
-		/*
-			NOTE:
-			Ϊʲô���������ַ�ʽ, ������do_something() + sleep(1) ??
-
-			��Ϊdo_something()������дӲ��, �������ܾ����ļ�ʮms, �ټ���sleep(1)Ҳ�����Ǿ�ȷ������1��, ���ͳ����ʱ���ʵ�ʱ�1���ܶ�.
-		*/
-		if(g_CurrentTime > last_log_time){
-			last_log_time = g_CurrentTime;
-			sysinfo_output();
-			pkt_runtime_output();
-		}
-		
-		usleep(1000);
-	}
-	
-	return NULL;
-}
-
-#ifdef __cplusplus
-}
-#endif
+#include "field_stat2.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include "dealpkt.h"
+#include "packet_io.h"
+#include "packet_io_internal.h"
+#include "stream_manage.h"
+#include "mesa_net.h"
+#include "sysinfo.h"
+#include "logger.h"
+#include <assert.h>
+
+#define STATS_STR_LEN	(32)
+
+volatile int update_packet_io_status_sw = 1;
+
+static unsigned long long sysinfo_old[COUNTER_NUM] = {0};
+static unsigned long long TO_KB = 1024;
+static unsigned long long TO_MB = 1024 * 1024;
+static unsigned long long TO_GB = 1024 * 1024 * 1024UL;
+static unsigned long long TO_TB;
+
+extern int g_packet_io_thread_num;
+extern void sapp_statsd_add_para(const char *key, unsigned long long value);
+extern void pkt_runtime_output(void);
+extern void sapp_statsd_flush_buf(void);
+extern void sapp_fs2_update(int field_index, unsigned long long value);
+
+/* ת���������׶������������ַ���, ��123bps, 34.5Mbps */
+static char *byte_convert_human(unsigned long long bytes, int interval, int multiple, char * byte_str)
+{
+    bytes *= multiple; /* to network pattern, or human pattern */
+
+    bytes /= interval; /* per second */
+
+    if(bytes < TO_KB){
+        snprintf(byte_str,STATS_STR_LEN,"%llu", bytes);
+    }else if(bytes < TO_MB){
+        snprintf(byte_str,STATS_STR_LEN,"%.2fK", (float)bytes/TO_KB);
+    }else if(bytes < TO_GB){
+        snprintf(byte_str,STATS_STR_LEN,"%.2fM", (float)bytes/TO_MB);
+    }else if(bytes < TO_TB){
+        snprintf(byte_str,STATS_STR_LEN,"%.2fG", (float)bytes/TO_GB);
+    }else{
+        snprintf(byte_str,STATS_STR_LEN,"%.2fT", (double)bytes/TO_TB);	
+    }
+
+    return byte_str;
+}
+
+
+void sysinfo_output(void)
+{
+	int i, j;
+	FILE* fp;
+	unsigned long long sysinfo_new[COUNTER_NUM] = {0};
+	static unsigned long long g_SysInputInfo_old[MAX_THREAD_NUM][COUNTER_NUM];
+	char s1[STATS_STR_LEN], s2[STATS_STR_LEN];
+
+	if(0 == update_packet_io_status_sw){
+		return;
+	}
+
+	for(i=0;i<g_packet_io_thread_num;i++)
+	{
+#if 0	
+		sysinfo_new[PKT_ETHERNET]  += g_SysInputInfo[i][PKT_ETHERNET];
+		sysinfo_new[PKT_ETHERNET_LEN]  += g_SysInputInfo[i][PKT_ETHERNET_LEN];
+		sysinfo_new[PKT_IP]  += g_SysInputInfo[i][PKT_IP];
+		sysinfo_new[PKT_IPLEN]  += g_SysInputInfo[i][PKT_IPLEN];
+		sysinfo_new[PKT_IPV6]  += g_SysInputInfo[i][PKT_IPV6];
+		sysinfo_new[PKT_IPV6LEN]  += g_SysInputInfo[i][PKT_IPV6LEN];
+		sysinfo_new[PKT_TCP]  += g_SysInputInfo[i][PKT_TCP];
+		sysinfo_new[PKT_TCPLEN]  += g_SysInputInfo[i][PKT_TCPLEN];
+		sysinfo_new[PKT_UDP]  += g_SysInputInfo[i][PKT_UDP];
+		sysinfo_new[PKT_UDPLEN]  += g_SysInputInfo[i][PKT_UDPLEN];
+		sysinfo_new[PKT_UNKNOWN]  += g_SysInputInfo[i][PKT_UNKNOWN];
+		sysinfo_new[PKT_UNKNOWN_LEN]  += g_SysInputInfo[i][PKT_UNKNOWN_LEN];
+
+		sysinfo_new[SYS_TCP_LINK_NEW] +=  g_SysInputInfo[i][SYS_TCP_LINK_NEW];
+		sysinfo_new[SYS_TCP_LINK_DEL] +=  g_SysInputInfo[i][SYS_TCP_LINK_DEL];
+		sysinfo_new[SYS_TCP_LINK_DATA] += g_SysInputInfo[i][SYS_TCP_LINK_DATA];
+
+		sysinfo_new[TCPV4_LINK_TOTAL]  += g_SysInputInfo[i][TCPV4_LINK_TOTAL];
+		sysinfo_new[TCPV4_LINK_NEW_CREATE] += g_SysInputInfo[i][TCPV4_LINK_NEW_CREATE];
+		sysinfo_new[TCPV4_LINK_CLOSE] += g_SysInputInfo[i][TCPV4_LINK_CLOSE];
+
+		sysinfo_new[TCPV6_LINK_TOTAL]  +=  g_SysInputInfo[i][TCPV6_LINK_TOTAL];
+		sysinfo_new[TCPV6_LINK_NEW_CREATE] += g_SysInputInfo[i][TCPV6_LINK_NEW_CREATE];
+		sysinfo_new[TCPV6_LINK_CLOSE] += g_SysInputInfo[i][TCPV6_LINK_CLOSE];
+		
+		sysinfo_new[UDPV4_LINK_TOTAL]  += g_SysInputInfo[i][UDPV4_LINK_TOTAL];;
+		sysinfo_new[UDPV4_LINK_NEW_CREATE] += g_SysInputInfo[i][UDPV4_LINK_NEW_CREATE];
+		sysinfo_new[UDPV4_LINK_CLOSE] += g_SysInputInfo[i][UDPV4_LINK_CLOSE];		
+
+		sysinfo_new[UDPV6_LINK_TOTAL]  += g_SysInputInfo[i][UDPV6_LINK_TOTAL];;
+		sysinfo_new[UDPV6_LINK_NEW_CREATE] += g_SysInputInfo[i][UDPV6_LINK_NEW_CREATE];
+		sysinfo_new[UDPV6_LINK_CLOSE] += g_SysInputInfo[i][UDPV6_LINK_CLOSE];	
+
+		sysinfo_new[TUNNEL_6OVER4] += g_SysInputInfo[i][TUNNEL_6OVER4];
+		sysinfo_new[TUNNEL_6OVER4_LEN] += g_SysInputInfo[i][TUNNEL_6OVER4_LEN];
+		sysinfo_new[TUNNEL_TEREDO] += g_SysInputInfo[i][TUNNEL_TEREDO];
+		sysinfo_new[TUNNEL_TEREDO_LEN] += g_SysInputInfo[i][TUNNEL_TEREDO_LEN];
+
+		sysinfo_new[TUNNEL_GTP] += g_SysInputInfo[i][TUNNEL_GTP];
+
+		sysinfo_new[SEND_TCP_RST] += g_SysInputInfo[i][SEND_TCP_RST];
+		sysinfo_new[SEND_TCP_RST_LEN] += g_SysInputInfo[i][SEND_TCP_RST_LEN];
+
+		sysinfo_new[SEND_TCP_SYN_ACK] += g_SysInputInfo[i][SEND_TCP_SYN_ACK];
+		sysinfo_new[SEND_TCP_SYN_ACK_LEN] += g_SysInputInfo[i][SEND_TCP_SYN_ACK_LEN];
+
+		sysinfo_new[SEND_UDP_PKT] += g_SysInputInfo[i][SEND_UDP_PKT];
+		sysinfo_new[SEND_UDP_PKT_LEN] += g_SysInputInfo[i][SEND_UDP_PKT_LEN];	
+
+		sysinfo_new[SEND_PKT_ERR] += g_SysInputInfo[i][SEND_PKT_ERR];
+		sysinfo_new[SEND_PKT_ERR_LEN] += g_SysInputInfo[i][SEND_PKT_ERR_LEN];	
+#else
+		for(j = 0; j < COUNTER_NUM; j++){
+			sysinfo_new[j] +=  g_SysInputInfo[i][j];	
+		}
+#endif
+	}
+
+	fp = fopen("./sysinfo.log","w+");
+	if(fp == NULL)
+	{
+		//runtime_log(RLOG_LV_FATAL,(char *)"test_dealpkt",(char *)"sysinfo.log fopen error!\n");
+		return;
+	}
+
+	fprintf(fp,"\n*********************** \033[41m%s\033[0m *************************\n", "sysinfo exactly");
+	fprintf(fp,"%-10s %12s %12s %12s %12s\n","RCV-PKT", "total_pkt", "total_len","pps", "Bps");
+	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "Ethernet", sysinfo_new[PKT_ETHERNET],sysinfo_new[PKT_ETHERNET_LEN],(sysinfo_new[PKT_ETHERNET]-sysinfo_old[PKT_ETHERNET]),(sysinfo_new[PKT_ETHERNET_LEN]-sysinfo_old[PKT_ETHERNET_LEN]));
+	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "IPv4", sysinfo_new[PKT_IP],sysinfo_new[PKT_IPLEN],(sysinfo_new[PKT_IP]-sysinfo_old[PKT_IP]),(sysinfo_new[PKT_IPLEN]-sysinfo_old[PKT_IPLEN]));
+	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n","IPv6",sysinfo_new[PKT_IPV6],sysinfo_new[PKT_IPV6LEN],(sysinfo_new[PKT_IPV6]-sysinfo_old[PKT_IPV6]),(sysinfo_new[PKT_IPV6LEN]-sysinfo_old[PKT_IPV6LEN]));
+	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n","TCP",sysinfo_new[PKT_TCP],sysinfo_new[PKT_TCPLEN],(sysinfo_new[PKT_TCP]-sysinfo_old[PKT_TCP]),(sysinfo_new[PKT_TCPLEN]-sysinfo_old[PKT_TCPLEN]));
+	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n","UDP",sysinfo_new[PKT_UDP],sysinfo_new[PKT_UDPLEN],(sysinfo_new[PKT_UDP]-sysinfo_old[PKT_UDP]),(sysinfo_new[PKT_UDPLEN]-sysinfo_old[PKT_UDPLEN]));
+	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n","Unknown",sysinfo_new[PKT_UNKNOWN],sysinfo_new[PKT_UNKNOWN_LEN],(sysinfo_new[PKT_UNKNOWN]-sysinfo_old[PKT_UNKNOWN]),(sysinfo_new[PKT_UNKNOWN_LEN]-sysinfo_old[PKT_UNKNOWN_LEN]));
+	fprintf(fp,"\n***************************************************************\n");
+	fprintf(fp,"%-10s %12s %12s %12s %12s\n","SND-PKT", "total_pkt", "total_len","pps", "Bps");
+	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "TCP_RST", sysinfo_new[SEND_TCP_RST],sysinfo_new[SEND_TCP_RST_LEN],(sysinfo_new[SEND_TCP_RST]-sysinfo_old[SEND_TCP_RST]),(sysinfo_new[SEND_TCP_RST_LEN]-sysinfo_old[SEND_TCP_RST_LEN]));
+	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "TCP_S/A", sysinfo_new[SEND_TCP_SYN_ACK],sysinfo_new[SEND_TCP_SYN_ACK_LEN],(sysinfo_new[SEND_TCP_SYN_ACK]-sysinfo_old[SEND_TCP_SYN_ACK]),(sysinfo_new[SEND_TCP_SYN_ACK_LEN]-sysinfo_old[SEND_TCP_SYN_ACK_LEN]));
+	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "UDP", sysinfo_new[SEND_UDP_PKT],sysinfo_new[SEND_UDP_PKT_LEN],(sysinfo_new[SEND_UDP_PKT]-sysinfo_old[SEND_UDP_PKT]),(sysinfo_new[SEND_UDP_PKT_LEN]-sysinfo_old[SEND_UDP_PKT_LEN]));
+	fprintf(fp,"%-10s %12llu %12llu %12llu %12llu\n", "SEND-ERR", sysinfo_new[SEND_PKT_ERR], sysinfo_new[SEND_PKT_ERR_LEN], (sysinfo_new[SEND_PKT_ERR]-sysinfo_old[SEND_PKT_ERR]), sysinfo_new[SEND_PKT_ERR_LEN]-sysinfo_old[SEND_PKT_ERR_LEN]);
+
+	fprintf(fp,"\n%-10s %12s %12s\n", "TUNNEL", "total_pkt", "total_len");	
+	fprintf(fp,"%-10s %12llu %12llu\n", "6over4", sysinfo_new[TUNNEL_6OVER4], sysinfo_new[TUNNEL_6OVER4_LEN]); 
+	fprintf(fp,"%-10s %12llu %12llu\n","teredo",sysinfo_new[TUNNEL_TEREDO], sysinfo_new[TUNNEL_TEREDO_LEN]);
+	fprintf(fp,"%-10s %12llu %12llu\n","GTP",sysinfo_new[TUNNEL_GTP], 0LLU);
+
+
+	fprintf(fp,"\n%-10s %12s\n", "DROP", "total_pkt");
+	fprintf(fp,"%-10s %12ld\n", "app", packet_io_get_app_drop_num_tot());
+	fprintf(fp,"%-10s %12ld\n\n", "lib", packet_io_get_lib_drop_num());
+
+	fprintf(fp,"\n------------------------------- TCP statistics detail -----------------------------\n");
+	fprintf(fp,"%3s %-27s %-19s %-27s\n", "", "|-----------Current---------|", "|------Realtime-----|", "|--------From-of-startup---------|");
+	fprintf(fp,"%3s %8s %9s %10s %10s %10s %10s %9s %13s\n", "tid", "link-syn", "link-data", "link-nouse", "link-new/s", "link-del/s", "stream-num", "reset-num", "hash-list-max");
+	for(i = 0; i < g_packet_io_thread_num; i++){	
+		fprintf(fp, "%3d %8llu %9llu %10llu %10llu %10llu %10llu %9llu %13llu\n", 
+				i, 
+				g_SysInputInfo[i][SYS_TCP_LINK_SYN], 
+				g_SysInputInfo[i][SYS_TCP_LINK_DATA],
+				g_SysInputInfo[i][SYS_TCP_LINK_NOUSE], 
+				(g_SysInputInfo[i][SYS_TCP_LINK_NEW]-g_SysInputInfo_old[i][SYS_TCP_LINK_NEW]), 
+				(g_SysInputInfo[i][SYS_TCP_LINK_DEL]-g_SysInputInfo_old[i][SYS_TCP_LINK_DEL]),
+				g_SysInputInfo[i][SYS_TCP_LINK_NEW],
+				g_SysInputInfo[i][SYS_TCP_LINK_RESET],
+				g_SysInputInfo[i][SYS_HASH_LIST_MAX]);
+	}
+
+	fprintf(fp,"\n-------------------------- UDP statistics detail ------------------------\n");
+	fprintf(fp,"%3s %-27s %-19s %-20s\n", "  ", "|-----------Current---------|", "|------Realtime-----|", "|--From-of-startup--|");
+	fprintf(fp,"%3s %8s %9s %10s %10s %10s %10s %9s\n", "tid", "link-one", "link-two", "link-more", "link-new/s", "link-del/s", "stream-num", "reset-num");
+	for(i = 0; i < g_packet_io_thread_num; i++){	
+		fprintf(fp, "%3d %8llu %9llu %10llu %10llu %10llu %10llu %9llu\n", 
+				i, 
+				g_SysInputInfo[i][SYS_UDP_LINK_ONE], 
+				g_SysInputInfo[i][SYS_UDP_LINK_TWO],
+				g_SysInputInfo[i][SYS_UDP_LINK_MORE], 
+				(g_SysInputInfo[i][SYS_UDP_LINK_NEW]-g_SysInputInfo_old[i][SYS_UDP_LINK_NEW]), 
+				(g_SysInputInfo[i][SYS_UDP_LINK_DEL]-g_SysInputInfo_old[i][SYS_UDP_LINK_DEL]),
+				g_SysInputInfo[i][SYS_UDP_LINK_NEW],
+				g_SysInputInfo[i][SYS_UDP_LINK_RESET]);
+	}
+	
+	fprintf(fp,"*****************************************************************\n\n");
+	fprintf(fp,"################# \033[41m%s\033[0m --- is same as above! #########\n", "sysinfo humanly");
+	fprintf(fp,"%-10s %12s %12s %12s %12s\n", "RCV-PKT", "total_pkt", "total_len","pps", "bps");
+	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","Ethernet",sysinfo_new[PKT_ETHERNET],byte_convert_human(sysinfo_new[PKT_ETHERNET_LEN],1 ,1,s1),(sysinfo_new[PKT_ETHERNET]-sysinfo_old[PKT_ETHERNET]),byte_convert_human((sysinfo_new[PKT_ETHERNET_LEN]-sysinfo_old[PKT_ETHERNET_LEN]),1,8,s2));
+	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","IPv4",sysinfo_new[PKT_IP],byte_convert_human(sysinfo_new[PKT_IPLEN],1 ,1,s1),(sysinfo_new[PKT_IP]-sysinfo_old[PKT_IP]),byte_convert_human((sysinfo_new[PKT_IPLEN]-sysinfo_old[PKT_IPLEN]),1,8,s2));
+	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","IPv6",sysinfo_new[PKT_IPV6],byte_convert_human(sysinfo_new[PKT_IPV6LEN],1,1,s1),(sysinfo_new[PKT_IPV6]-sysinfo_old[PKT_IPV6]),byte_convert_human((sysinfo_new[PKT_IPV6LEN]-sysinfo_old[PKT_IPV6LEN]),1,8,s2));
+	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","TCP",sysinfo_new[PKT_TCP],byte_convert_human(sysinfo_new[PKT_TCPLEN],1,1,s1),(sysinfo_new[PKT_TCP]-sysinfo_old[PKT_TCP]),byte_convert_human((sysinfo_new[PKT_TCPLEN]-sysinfo_old[PKT_TCPLEN]),1,8,s2));
+	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","UDP",sysinfo_new[PKT_UDP],byte_convert_human(sysinfo_new[PKT_UDPLEN],1,1,s1),(sysinfo_new[PKT_UDP]-sysinfo_old[PKT_UDP]),byte_convert_human((sysinfo_new[PKT_UDPLEN]-sysinfo_old[PKT_UDPLEN]),1,8,s2));	
+	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n","Unknown",sysinfo_new[PKT_UNKNOWN],byte_convert_human(sysinfo_new[PKT_UNKNOWN_LEN],1,1,s1),(sysinfo_new[PKT_UNKNOWN]-sysinfo_old[PKT_UNKNOWN]),byte_convert_human((sysinfo_new[PKT_UNKNOWN_LEN]-sysinfo_old[PKT_UNKNOWN_LEN]),1,8,s2));
+	fprintf(fp,"#################################################################\n");
+	fprintf(fp,"%-10s %12s %12s %12s %12s\n","SND-PKT", "total_pkt", "total_len","pps", "bps");
+	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n", "TCP_RST", sysinfo_new[SEND_TCP_RST], byte_convert_human(sysinfo_new[SEND_TCP_RST_LEN], 1, 1, s1),(sysinfo_new[SEND_TCP_RST]-sysinfo_old[SEND_TCP_RST]), byte_convert_human((sysinfo_new[SEND_TCP_RST_LEN]-sysinfo_old[SEND_TCP_RST_LEN]), 1,8,s2));
+	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n", "TCP_S/A", sysinfo_new[SEND_TCP_SYN_ACK], byte_convert_human(sysinfo_new[SEND_TCP_SYN_ACK_LEN], 1, 1, s1),(sysinfo_new[SEND_TCP_SYN_ACK]-sysinfo_old[SEND_TCP_SYN_ACK]), byte_convert_human((sysinfo_new[SEND_TCP_SYN_ACK_LEN]-sysinfo_old[SEND_TCP_SYN_ACK_LEN]),1,8,s2));
+	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n", "UDP", sysinfo_new[SEND_UDP_PKT], byte_convert_human(sysinfo_new[SEND_UDP_PKT_LEN],1,1,s1),(sysinfo_new[SEND_UDP_PKT]-sysinfo_old[SEND_UDP_PKT]), byte_convert_human((sysinfo_new[SEND_UDP_PKT_LEN]-sysinfo_old[SEND_UDP_PKT_LEN]),1,8,s2));
+	fprintf(fp,"%-10s %12llu %12s %12llu %12s\n", "SEND-ERR", sysinfo_new[SEND_PKT_ERR], byte_convert_human(sysinfo_new[SEND_PKT_ERR_LEN],1,1,s1),(sysinfo_new[SEND_PKT_ERR]-sysinfo_old[SEND_PKT_ERR]), byte_convert_human((sysinfo_new[SEND_PKT_ERR_LEN]-sysinfo_old[SEND_PKT_ERR_LEN]),1,8,s2));
+
+	fprintf(fp,"#################################################################\n\n");
+
+	/* 2018-08-29 lijia add field statsd */
+#if 0	
+	sapp_statsd_add_para("Ethernet_pps", sysinfo_new[PKT_ETHERNET]-sysinfo_old[PKT_ETHERNET]);
+	sapp_statsd_add_para("Ethernet_bps", 8 *( sysinfo_new[PKT_ETHERNET_LEN]-sysinfo_old[PKT_ETHERNET_LEN]));
+	
+	sapp_statsd_add_para("IPv4_pps", sysinfo_new[PKT_IP]-sysinfo_old[PKT_IP]);
+	sapp_statsd_add_para("IPv4_bps", 8 *(sysinfo_new[PKT_IPLEN]-sysinfo_old[PKT_IPLEN]));
+
+	sapp_statsd_add_para("IPv6_pps", sysinfo_new[PKT_IPV6]-sysinfo_old[PKT_IPV6]);
+	sapp_statsd_add_para("IPv6_bps", 8 *(sysinfo_new[PKT_IPV6LEN]-sysinfo_old[PKT_IPV6LEN]));
+
+	sapp_statsd_add_para("TCP_pps", sysinfo_new[PKT_TCP]-sysinfo_old[PKT_TCP]);
+	sapp_statsd_add_para("TCP_bps", 8 *(sysinfo_new[PKT_TCPLEN]-sysinfo_old[PKT_TCPLEN]));
+	sapp_statsd_add_para("UDP_pps", sysinfo_new[PKT_UDP]-sysinfo_old[PKT_UDP]);	
+	sapp_statsd_add_para("UDP_bps", 8 *(sysinfo_new[PKT_UDPLEN]-sysinfo_old[PKT_UDPLEN]));
+	
+	sapp_statsd_add_para("TCP_LINK_NEW",sysinfo_new[SYS_TCP_LINK_NEW]-sysinfo_old[SYS_TCP_LINK_NEW]);
+	sapp_statsd_add_para("TCP_LINK_DEL", sysinfo_new[SYS_TCP_LINK_DEL]-sysinfo_old[SYS_TCP_LINK_DEL]);
+
+	sapp_statsd_add_para("TCP_RST_SEND",  sysinfo_new[SEND_TCP_RST]-sysinfo_old[SEND_TCP_RST]);
+	sapp_statsd_add_para("TCP_S/A_SEND",  sysinfo_new[SEND_TCP_SYN_ACK]-sysinfo_old[SEND_TCP_SYN_ACK]);
+	sapp_statsd_add_para("UDP_SEND",  sysinfo_new[SEND_UDP_PKT]-sysinfo_old[SEND_UDP_PKT]);
+
+	sapp_statsd_flush_buf(); /* statsd���, ������ۻ����Ƿ���, ǿ��ˢ��һ�� */
+#elif 0
+	sapp_fs2_update(PKT_ETHERNET, sysinfo_new[PKT_ETHERNET]-sysinfo_old[PKT_ETHERNET]);
+	sapp_fs2_update(PKT_ETHERNET_LEN, 8 *( sysinfo_new[PKT_ETHERNET_LEN]-sysinfo_old[PKT_ETHERNET_LEN]));
+	
+	sapp_fs2_update(PKT_IP, sysinfo_new[PKT_IP]-sysinfo_old[PKT_IP]);
+	sapp_fs2_update(PKT_IPLEN, 8 *(sysinfo_new[PKT_IPLEN]-sysinfo_old[PKT_IPLEN]));
+
+	sapp_fs2_update(PKT_IPV6, sysinfo_new[PKT_IPV6]-sysinfo_old[PKT_IPV6]);
+	sapp_fs2_update(PKT_IPV6LEN, 8 *(sysinfo_new[PKT_IPV6LEN]-sysinfo_old[PKT_IPV6LEN]));
+
+	sapp_fs2_update(PKT_TCP, sysinfo_new[PKT_TCP]-sysinfo_old[PKT_TCP]);
+	sapp_fs2_update(PKT_TCPLEN, 8 *(sysinfo_new[PKT_TCPLEN]-sysinfo_old[PKT_TCPLEN]));
+	sapp_fs2_update(PKT_UDP, sysinfo_new[PKT_UDP]-sysinfo_old[PKT_UDP]);	
+	sapp_fs2_update(PKT_UDPLEN, 8 *(sysinfo_new[PKT_UDPLEN]-sysinfo_old[PKT_UDPLEN]));
+	
+	sapp_fs2_update(SYS_TCP_LINK_NEW,sysinfo_new[SYS_TCP_LINK_NEW]-sysinfo_old[SYS_TCP_LINK_NEW]);
+	sapp_fs2_update(SYS_TCP_LINK_DEL, sysinfo_new[SYS_TCP_LINK_DEL]-sysinfo_old[SYS_TCP_LINK_DEL]);
+
+	sapp_fs2_update(SEND_TCP_RST,  sysinfo_new[SEND_TCP_RST]-sysinfo_old[SEND_TCP_RST]);
+	sapp_fs2_update(SEND_TCP_SYN_ACK,  sysinfo_new[SEND_TCP_SYN_ACK]-sysinfo_old[SEND_TCP_SYN_ACK]);
+	sapp_fs2_update(SEND_UDP_PKT,  sysinfo_new[SEND_UDP_PKT]-sysinfo_old[SEND_UDP_PKT]);
+#else
+	sapp_fs2_update(PKT_ETHERNET, sysinfo_new[PKT_ETHERNET]);
+	sapp_fs2_update(PKT_ETHERNET_LEN, 8 *( sysinfo_new[PKT_ETHERNET_LEN]));
+	
+	sapp_fs2_update(PKT_IP, sysinfo_new[PKT_IP]);
+	sapp_fs2_update(PKT_IPLEN, 8 *(sysinfo_new[PKT_IPLEN]));
+
+	sapp_fs2_update(PKT_IPV6, sysinfo_new[PKT_IPV6]);
+	sapp_fs2_update(PKT_IPV6LEN, 8 *(sysinfo_new[PKT_IPV6LEN]));
+
+	sapp_fs2_update(PKT_TCP, sysinfo_new[PKT_TCP]);
+	sapp_fs2_update(PKT_TCPLEN, 8 *(sysinfo_new[PKT_TCPLEN]));
+	sapp_fs2_update(PKT_UDP, sysinfo_new[PKT_UDP]);	
+	sapp_fs2_update(PKT_UDPLEN, 8 *(sysinfo_new[PKT_UDPLEN]));
+	
+	sapp_fs2_update(SYS_TCP_LINK_NEW,sysinfo_new[SYS_TCP_LINK_NEW]);
+	sapp_fs2_update(SYS_TCP_LINK_DEL, sysinfo_new[SYS_TCP_LINK_DEL]);
+	sapp_fs2_update(SYS_TCP_LINK_DATA, sysinfo_new[SYS_TCP_LINK_DATA]);
+
+	sapp_fs2_update(SEND_TCP_RST,  sysinfo_new[SEND_TCP_RST]);
+	sapp_fs2_update(SEND_TCP_SYN_ACK,  sysinfo_new[SEND_TCP_SYN_ACK]);
+	sapp_fs2_update(SEND_UDP_PKT,  sysinfo_new[SEND_UDP_PKT]);
+#endif
+
+	memcpy(sysinfo_old,sysinfo_new,sizeof(unsigned long long)*COUNTER_NUM);
+	memcpy(g_SysInputInfo_old, (void *)g_SysInputInfo, sizeof(g_SysInputInfo));
+
+	fclose(fp);
+
+	return ;
+}
+
+
+void *time_event_thread(void *arg)
+{
+	time_t last_log_time;
+
+#if(__GNUC__ * 100 + __GNUC_MINOR__ * 10 + __GNUC_PATCHLEVEL__ >= 480) /* �汾�ж�, �ܶ��ϵͳ�޷����� */
+#ifdef _GNU_SOURCE
+	pthread_setname_np(pthread_self(), "sapp_time_event");
+#endif
+#endif
+
+	TO_KB = 1024UL;
+	TO_MB = 1024 * 1024UL;
+	TO_GB = 1024 * 1024 * 1024UL;
+	TO_TB = (unsigned long long)1024 * 1024 * 1024 * 1024UL;
+
+	last_log_time = time(NULL);
+	
+	while(1)
+	{
+		g_CurrentTime = time(NULL);
+
+		/*
+			NOTE:
+			Ϊʲô���������ַ�ʽ, ������do_something(); sleep(1);
+
+			��Ϊdo_something()������дӲ��, �������ܾ����ļ�ʮms, �ټ���sleep(1)Ҳ�����Ǿ�ȷ������1��, ����΢����1��,
+			������ͳ����ʱ���ʵ�ʱ�1���ܶ�, ��ʱ�����к�, ���ͻ��ۻ�Խ��Խ��.
+		*/
+		if(g_CurrentTime > last_log_time){
+			last_log_time = g_CurrentTime;
+			sysinfo_output();
+			pkt_runtime_output();
+		}
+		
+		usleep(1000);
+	}
+	
+	return NULL;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/plugin/CMakeLists.txt b/plugin/CMakeLists.txt
new file mode 100644
index 0000000..f6088db
--- /dev/null
+++ b/plugin/CMakeLists.txt
@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 2.8)
+
+include_directories(${MESA_SDK_PREFIX}/include)
+include_directories(${MESA_SDK_PREFIX}/include/MESA)
+include_directories(inc)
+include_directories(${CMAKE_SOURCE_DIR}/include)
+add_library(plugctrl STATIC src/plugin_proc.c src/plugin.c src/plugin_platform.c 
+			src/plugin_protocol.c src/plugin_business.c)
+\ No newline at end of file
diff --git a/project/CMakeLists.txt b/project/CMakeLists.txt
new file mode 100644
index 0000000..c925382
--- /dev/null
+++ b/project/CMakeLists.txt
@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 2.8)
+add_definitions(-D_BSD_SOURCE -D_BSD_SOURCE -D__BSD_SOURCE -D__FAVOR_BSD=1 -DHAVE_NET_ETHERNET_H)
+add_definitions(-DPLATFORM_NSDPF_PAPP=1)
+
+include_directories(${MESA_SDK_PREFIX}/include)
+include_directories(${MESA_SDK_PREFIX}/include/MESA)
+include_directories(${CMAKE_SOURCE_DIR}/include)
+include_directories(${CMAKE_SOURCE_DIR}/include/net)
+include_directories(${CMAKE_SOURCE_DIR}/dealpkt)
+
+add_library(project STATIC project_requirement.c raw_ip_frag_list.c terminal_tag.c)
diff --git a/project/project_internal.h b/project/project_internal.h.bak
index b945d44..b945d44 100644
--- a/project/project_internal.h
+++ b/project/project_internal.h.bak
diff --git a/readme_GBK.txt b/readme_GBK.txt
index 098550c..77b1a5b 100644
--- a/readme_GBK.txt
+++ b/readme_GBK.txt
@@ -633,4 +633,7 @@ int stream_addr_list_pton(const char *addr_list_str, void *dst, int size, int th
 *********************************************************************
 2018-11-08 ���
 1)����Gserial_sendpacket_ipv6_layer()����, ���Է����ѹ���õ�IPV6���ݰ�.
+*********************************************************************
+2018-11-16 ���
+1)֧��cmake, �벢���汾����ͬ��.
 #endif
 \ No newline at end of file
diff --git a/readme_UTF8.txt b/readme_UTF8.txt
index be3f94c..9f3e2e0 100644
--- a/readme_UTF8.txt
+++ b/readme_UTF8.txt
@@ -633,4 +633,7 @@ int stream_addr_list_pton(const char *addr_list_str, void *dst, int size, int th
 *********************************************************************
 2018-11-08 李佳
 1)增加Gserial_sendpacket_ipv6_layer()函数, 可以发送已构造好的IPV6数据包.
+*********************************************************************
+2018-11-16 李佳
+1)支持cmake, 与并联版本部分同步.
 #endif
 \ No newline at end of file
diff --git a/support/CMakeLists.txt b/support/CMakeLists.txt
new file mode 100644
index 0000000..171306f
--- /dev/null
+++ b/support/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 2.8)
+
+
+add_subdirectory(iknow)
+add_subdirectory(timestamp_record)
+add_subdirectory(symbol_check)
+add_subdirectory(MESA_sleep)
+add_subdirectory(md5)
+add_subdirectory(MESA_socket_wrap/src)
+add_subdirectory(dictator2/src)
+
+#if(OPT_USE_DICTATOR)
+#	add_subdirectory(dictator2)
+#endif()
+#
+#if(OPT_USE_TXMEM)
+#	add_subdirectory(txmem2)
+#endif()
diff --git a/support/MESA_sleep/CMakeLists.txt b/support/MESA_sleep/CMakeLists.txt
new file mode 100644
index 0000000..09ba5de
--- /dev/null
+++ b/support/MESA_sleep/CMakeLists.txt
@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 2.8)
+
+#include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+#include_directories(${CMAKE_SOURCE_DIR}/project)
+#include_directories(${CMAKE_SOURCE_DIR}/include)
+#include_directories(${CMAKE_SOURCE_DIR}/include/support)
+#include_directories(${CMAKE_SOURCE_DIR}/dealpkt)
+
+add_definitions(-D_BSD_SOURCE -D_BSD_SOURCE -D__BSD_SOURCE -D__FAVOR_BSD -DHAVE_NET_ETHERNET_H)
+
+add_library(MESA_sleep STATIC  mesa_sleep_nowatchBGT.c)
diff --git a/support/MESA_socket_wrap/CMakeLists.txt b/support/MESA_socket_wrap/CMakeLists.txt
new file mode 100644
index 0000000..6fd7a4b
--- /dev/null
+++ b/support/MESA_socket_wrap/CMakeLists.txt
@@ -0,0 +1,5 @@
+#include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+#include_directories(${CMAKE_SOURCE_DIR}/project)
+#include_directories(${CMAKE_SOURCE_DIR}/include)
+#include_directories(${CMAKE_SOURCE_DIR}/include/support)
+add_subdirectory(src)
diff --git a/support/MESA_socket_wrap/src/CMakeLists.txt b/support/MESA_socket_wrap/src/CMakeLists.txt
new file mode 100644
index 0000000..2c95be9
--- /dev/null
+++ b/support/MESA_socket_wrap/src/CMakeLists.txt
@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 2.8)
+
+#include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+#include_directories(${CMAKE_SOURCE_DIR}/project)
+#include_directories(${CMAKE_SOURCE_DIR}/include)
+#include_directories(${CMAKE_SOURCE_DIR}/include/support)
+include_directories(${CMAKE_SOURCE_DIR}/include)
+
+add_definitions(-D_BSD_SOURCE -D_BSD_SOURCE -D__BSD_SOURCE -D__FAVOR_BSD -DHAVE_NET_ETHERNET_H)
+
+add_library(MESA_socket_wrap STATIC  MESA_socket_wrap.c)
diff --git a/support/MESA_socket_wrap/src/MESA_socket_wrap.c b/support/MESA_socket_wrap/src/MESA_socket_wrap.c
index b97fd07..1d85ff0 100644
--- a/support/MESA_socket_wrap/src/MESA_socket_wrap.c
+++ b/support/MESA_socket_wrap/src/MESA_socket_wrap.c
@@ -6,7 +6,7 @@
 	��ϵͳ��׼SOCKET�ӿڻ�����, ���ӳ�ʱ����, �����κ�����������, �����Ʒ���������.
 */
 
-#include "MESA_socket_wrap.h"
+#include "../include/MESA_socket_wrap.h"
 #include <sys/types.h> 
 #include <sys/socket.h>
 #include <stdio.h>
diff --git a/support/dictator2/src/CMakeLists.txt b/support/dictator2/src/CMakeLists.txt
new file mode 100644
index 0000000..adc48dc
--- /dev/null
+++ b/support/dictator2/src/CMakeLists.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 2.8)
+
+include_directories(${MESA_SDK_PREFIX}/include)
+include_directories(${MESA_SDK_PREFIX}/include/MESA)
+#include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+#include_directories(${CMAKE_SOURCE_DIR}/project)
+#include_directories(${CMAKE_SOURCE_DIR}/include)
+#include_directories(${CMAKE_SOURCE_DIR}/include/support)
+#include_directories(${CMAKE_SOURCE_DIR}/dealpkt)
+
+add_definitions(-D_BSD_SOURCE -D_BSD_SOURCE -D__BSD_SOURCE -D__FAVOR_BSD -DHAVE_NET_ETHERNET_H)
+
+add_library(dictator2 STATIC  dictator.cpp dictator_debuger.cpp
+    D_internal/D_kernel_list.cpp D_internal/list_common.cpp
+    D_internal/MESA_hash_v2.cpp D_internal/MESA_list_v2.cpp)
diff --git a/support/dictator2/src/Makefile b/support/dictator2/src/Makefile
index c4b64da..cfa938b 100644
--- a/support/dictator2/src/Makefile
+++ b/support/dictator2/src/Makefile
@@ -1,5 +1,6 @@
 all:
-	#make clean&&make -f Makefile_nodebug
-	make clean&&make -f Makefile_debug
+	cp dictator.h ../../../include/support/
+	make clean&&make -f Makefile_nodebug
+	#make clean&&make -f Makefile_debug
 clean:
 	rm *.o -f
diff --git a/support/md5/CMakeLists.txt b/support/md5/CMakeLists.txt
new file mode 100644
index 0000000..abd3aa7
--- /dev/null
+++ b/support/md5/CMakeLists.txt
@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 2.8)
+
+#include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+#include_directories(${CMAKE_SOURCE_DIR}/project)
+#include_directories(${CMAKE_SOURCE_DIR}/include)
+#include_directories(${CMAKE_SOURCE_DIR}/include/support)
+#include_directories(${CMAKE_SOURCE_DIR}/dealpkt)
+
+add_definitions(-D_BSD_SOURCE -D_BSD_SOURCE -D__BSD_SOURCE -D__FAVOR_BSD -DHAVE_NET_ETHERNET_H)
+
+add_library(md5 STATIC  md5.c)
diff --git a/support/symbol_check/CMakeLists.txt b/support/symbol_check/CMakeLists.txt
new file mode 100644
index 0000000..3895588
--- /dev/null
+++ b/support/symbol_check/CMakeLists.txt
@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 2.8)
+
+#include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+#include_directories(${CMAKE_SOURCE_DIR}/project)
+#include_directories(${CMAKE_SOURCE_DIR}/include)
+#include_directories(${CMAKE_SOURCE_DIR}/include/support)
+#include_directories(${CMAKE_SOURCE_DIR}/dealpkt)
+
+add_definitions(-D_BSD_SOURCE -D_GNU_SOURCE -D__BSD_SOURCE -D__FAVOR_BSD -DHAVE_NET_ETHERNET_H)
+
+add_library(symbol_check STATIC  libsymbol_check.c)
diff --git a/support/timestamp_record/CMakeLists.txt b/support/timestamp_record/CMakeLists.txt
new file mode 100644
index 0000000..9e45b42
--- /dev/null
+++ b/support/timestamp_record/CMakeLists.txt
@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 2.8)
+
+include_directories(${CMAKE_SOURCE_DIR}/packet_io)
+#include_directories(${CMAKE_SOURCE_DIR}/project)
+include_directories(${CMAKE_SOURCE_DIR}/include)
+include_directories(${CMAKE_SOURCE_DIR}/include/net)
+include_directories(${CMAKE_SOURCE_DIR}/include/stream_inc)
+include_directories(${CMAKE_SOURCE_DIR}/include/support)
+include_directories(${CMAKE_SOURCE_DIR}/dealpkt)
+
+add_definitions(-D_BSD_SOURCE -D_BSD_SOURCE -D__BSD_SOURCE -D__FAVOR_BSD -DHAVE_NET_ETHERNET_H)
+
+add_library(timestamp_record STATIC  timestamp_record.c)
+target_link_libraries(timestamp_record iknow)
diff --git a/support/timestamp_record/timestamp_record.c b/support/timestamp_record/timestamp_record.c
index 2eca59b..dc47350 100644
--- a/support/timestamp_record/timestamp_record.c
+++ b/support/timestamp_record/timestamp_record.c
@@ -15,7 +15,7 @@ extern "C" {
 #define CPU_CLOCK_TO_1US				(2199) /* 1΢��ת����CPU������, ����2.2GHz����2200 */
 
 
-#if DEBUG
+#if 1
 
 
 /* 2015-11-26 lijia add, ʱ�����¼ */
@@ -383,9 +383,9 @@ int timestamp_record_init(void)
 		g_timestamp_record_benchmark[i] = 10000 + i*30000; /* ���Դ����, ��ʼΪ10000��CPU����, ÿ������֮���30000��CPU���� */
 	}
 
-	iknow_register_cmd(PLATFORM_IHANDLE, "show timestamp summary", "show timestamp summary", 
-					  show_timestamp_summary_cb, 
-					  NULL, 0, NULL);
+	//iknow_register_cmd(PLATFORM_IHANDLE, "show timestamp summary", "show timestamp summary", 
+					  //show_timestamp_summary_cb, 
+					  //NULL, 0, NULL);
 
 	return 0;	
 }
author	lijia <[email protected]>	2018-11-16 17:57:27 +0800
committer	lijia <[email protected]>	2018-11-16 17:57:27 +0800
commit	26edec5e1555f30006af50b3fbba364bdd58b88f (patch)
tree	c4247091bb361fda4cb0e3edb5d0d1e2adb496ba
parent	ff19403215eae57355ee6cb19c565557c32e433c (diff)