📃 docs(clean redundancy code): 移除已注释代码，和直接放在头文件目录的event2.h

3 files changed, 2 insertions, 1113 deletions

diff --git a/src/common/linux_kernel_jhash.c b/src/common/linux_kernel_jhash.c
index 3ca884e..49de553 100644
--- a/src/common/linux_kernel_jhash.c
+++ b/src/common/linux_kernel_jhash.c
@@ -58,58 +58,6 @@ static inline __u32 rol32(__u32 word, unsigned int shift)
 /* An arbitrary initial parameter */

 #define JHASH_INITVAL		0xdeadbeef

 

-#if 0

-/* jhash - hash an arbitrary key

- * @k: sequence of bytes as key

- * @length: the length of the key

- * @initval: the previous hash, or an arbitray value

- *

- * The generic version, hashes an arbitrary sequence of bytes.

- * No alignment or length assumptions are made about the input key.

- *

- * Returns the hash value of the key. The result depends on endianness.

- */

-static inline u32 jhash(const void *key, u32 length, u32 initval)

-{

-	u32 a, b, c;

-	const u8 *k = key;

-

-	/* Set up the internal state */

-	a = b = c = JHASH_INITVAL + length + initval;

-

-	/* All but the last block: affect some 32 bits of (a,b,c) */

-	while (length > 12) {

-		a += __get_unaligned_cpu32(k);

-		b += __get_unaligned_cpu32(k + 4);

-		c += __get_unaligned_cpu32(k + 8);

-		__jhash_mix(a, b, c);

-		length -= 12;

-		k += 12;

-	}

-	/* Last block: affect all 32 bits of (c) */

-	/* All the case statements fall through */

-	switch (length) {

-	case 12: c += (u32)k[11]<<24;

-	case 11: c += (u32)k[10]<<16;

-	case 10: c += (u32)k[9]<<8;

-	case 9:  c += k[8];

-	case 8:  b += (u32)k[7]<<24;

-	case 7:  b += (u32)k[6]<<16;

-	case 6:  b += (u32)k[5]<<8;

-	case 5:  b += k[4];

-	case 4:  a += (u32)k[3]<<24;

-	case 3:  a += (u32)k[2]<<16;

-	case 2:  a += (u32)k[1]<<8;

-	case 1:  a += k[0];

-		 __jhash_final(a, b, c);

-	case 0: /* Nothing left to add */

-		break;

-	}

-

-	return c;

-}

-#endif

-

 /* jhash2 - hash an array of u32's

  * @k: the key which must be an array of u32's

  * @length: the number of u32's in the key

@@ -213,28 +161,16 @@ int stream_make_jhash(struct streaminfo_private *stream_pr, unsigned int maxsize
 	}else if(ADDR_TYPE_IPV6 == addr->addrtype){

 		const struct stream_tuple4_v6 *tuple4_v6 = addr->tuple4_v6;	

 		if(1 == stream_pr->layer_dir){

-#if 0 /* 20160930 lijia add, ���������治�������� */		

-			a = *((unsigned int *)(&tuple4_v6->saddr[12]));

-			b = *((unsigned int *)(&tuple4_v6->daddr[12]));

-#elif 0

-			memcpy(&a, &tuple4_v6->saddr[12], sizeof(int));

-			memcpy(&b, &tuple4_v6->daddr[12], sizeof(int));

-#else

 			for_werror_compile = (void *)(&tuple4_v6->saddr[12]);

 			a = *((unsigned int *)for_werror_compile);

 			for_werror_compile = (void *)(&tuple4_v6->daddr[12]);

 			b = *((unsigned int *)for_werror_compile);			

-#endif

 			c = tuple4_v6->source;

 			d = tuple4_v6->dest;			

 		}else{

-#if 0	/* 20160930 lijia add, ���������治�������� */		

-			a = *((unsigned int *)(&tuple4_v6->daddr[12]));

-			b = *((unsigned int *)(&tuple4_v6->saddr[12]));

-#else

+

 			memcpy(&a, &tuple4_v6->daddr[12], sizeof(int));

 			memcpy(&b, &tuple4_v6->saddr[12], sizeof(int));

-#endif

 			c = tuple4_v6->dest;

 			d = tuple4_v6->source;				

 		}

diff --git a/src/common/net_common.c b/src/common/net_common.c
index 1079722..f14d37c 100644
--- a/src/common/net_common.c
+++ b/src/common/net_common.c
@@ -80,942 +80,6 @@ char MESA_ascii_to_hex(char ascii)
 	return c;
 }
 
-/* jump layer���ܴ�sapp����, ������Ϊһ��������: libMESA_jump_layer, �ɸ�����tcpdump_mesa, ���������, ģ��ȵ� */
-#if 0
-static inline int check_layer_type(int layer_type)
-{
-	if(NULL == addr_type_to_prefix((enum addr_type_t)layer_type)){
-		return -1;
-	}
-
-	return 0;
-}
-
-static int arp_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	/* arpЭ�鲻�����κ��ϲ�����Э�� */
-	return -1;
-}
-
-
-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;
-	const unsigned char *next_ip_layer_hdr;
-	int skip_len;
-	int gtp_hdr_len;
-
-	if(ADDR_TYPE_GPRS_TUNNEL == expect_layer_type){
-		return 0;
-	}
-
-	gtp_hdr_len = deal_gtp_calc_gtp_hdr_len(gh);
-	if(gtp_hdr_len < 0){
-		return -1;
-	}
-
-	next_ip_layer_hdr = (unsigned char *)raw_data + gtp_hdr_len;
-
-	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(RLOG_LV_INFO, "gtp_jump_to_layer() error, unsupport type in GTP, 0x%x!\n", (*next_ip_layer_hdr));
-		return -1;
-	}
-
-	return gtp_hdr_len + skip_len;
-}
-
-extern int parse_l2tpv2_hdr(const struct l2tp_hdr_v2 *pl2tphdrv2, struct layer_addr_l2tp *l2tpaddr);
-static int l2tp_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	int l2tp_hdr_len, skip_len = 0;
-	
-	const unsigned char *next_layer_hdr;
-	struct layer_addr_l2tp tmp_l2tp_addr;
-
-	if(ADDR_TYPE_L2TP == expect_layer_type){
-		return 0;
-	}
-	
-	l2tp_hdr_len = parse_l2tpv2_hdr((const struct l2tp_hdr_v2 *)raw_data, &tmp_l2tp_addr);
-	if(l2tp_hdr_len < 0){
-		return -1;
-	}
-
-	next_layer_hdr = raw_data + l2tp_hdr_len;
-
-	if(tmp_l2tp_addr.l2tpun.l2tp_addr_v2.ppp_hdr_compress_enable){
-		if(tmp_l2tp_addr.l2tpun.l2tp_addr_v2.compress_ppp_hdr.protocol == 0x21){ 
-			skip_len = ipv4_jump_to_layer((char *)next_layer_hdr, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
-		}else if(tmp_l2tp_addr.l2tpun.l2tp_addr_v2.compress_ppp_hdr.protocol == 0x57){ 
-			skip_len = ipv6_jump_to_layer((char *)next_layer_hdr, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);		
-		}
-	}else{
-		if(ntohs(tmp_l2tp_addr.l2tpun.l2tp_addr_v2.ppp_hdr.protocol) == 0x0021){ 
-			skip_len = ipv4_jump_to_layer((char *)next_layer_hdr, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
-		}else if(ntohs(tmp_l2tp_addr.l2tpun.l2tp_addr_v2.ppp_hdr.protocol) == 0x57){ 
-			skip_len = ipv6_jump_to_layer((char *)next_layer_hdr, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);		
-		}
-	}
-	
-	return l2tp_hdr_len + skip_len;
-}
-
-static int teredo_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	const char *next_layer_hdr;
-	struct teredo_auth_hdr *p_teredo_hdr;
-	int teredo_layer_len = 0, tmp_hdr_len = 0, skip_len = 0;
-
-	
-	/* teredoʵ��û�����ݰ�ͷ */
-	next_layer_hdr = raw_data;
-
-	while((*next_layer_hdr & 0xF0) != 0x60){
-		p_teredo_hdr = (struct teredo_auth_hdr *)next_layer_hdr;
-		if(p_teredo_hdr->flags == ntohs(TEREDO_AUTH_HDR_FLAG))
-		{
-			//rfc4380 5.1.1 teredo ����0x0001ʱΪTeredo authentication headers����Ҫ����
-			tmp_hdr_len += sizeof(struct teredo_auth_hdr) + ntohs(p_teredo_hdr->au_len) + ntohs
-			(p_teredo_hdr->id_len) + 8 + 1;
-			next_layer_hdr += tmp_hdr_len;
-			teredo_layer_len += tmp_hdr_len;
-		}
-		else if(p_teredo_hdr->flags == ntohs(TEREDO_INDICATION_HDR_FLAG))
-		{
-			//rfc4380 teredo ����0x0000ʱΪTeredo indication headers����Ҫ����
-			next_layer_hdr += TEREDO_INDICATION_HDR_LEN;
-			teredo_layer_len += TEREDO_INDICATION_HDR_LEN;
-		}
-		else
-		{
-			sapp_runtime_log(RLOG_LV_INFO, "teredo_jump_to_layer(): unsupport teredo hdr:0x%d!\n", *(unsigned int *)(next_layer_hdr));
-			return -1;
-		}
-	}
-	skip_len = ipv6_jump_to_layer(next_layer_hdr, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
-	if(skip_len < 0){
-		return -1;
-	}
-	skip_len += teredo_layer_len;
-
-	return 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;
-	const char *next_layer_hdr;
-
-	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)){
-		skip_len = teredo_jump_to_layer(raw_data+sizeof(struct mesa_udp_hdr), 0, expect_layer_type);
-	}else if((1701 == usport) || (1701 == udport)){
-		skip_len = l2tp_jump_to_layer(raw_data+sizeof(struct mesa_udp_hdr), ADDR_TYPE_UDP, expect_layer_type);
-	}else{
-		/* ����UDP���Ͳ�֧������ת */
-		sapp_runtime_log(RLOG_LV_INFO, "udp_jump_to_layer(): unsupport udp sport:%u, dport:%u!\n", usport, udport);
-		return -1;
-	}
-	if(skip_len < 0){
-		return -1;
-	}
-
-	return skip_len + sizeof(struct mesa_udp_hdr);
-}
-
-static int udp_jump_to_layer_greedy(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;
-	const char *next_layer_hdr;
-
-	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)){
-		skip_len = teredo_jump_to_layer(raw_data+sizeof(struct mesa_udp_hdr), 0, expect_layer_type);
-	}else if((1701 == usport) || (1701 == udport)){
-		skip_len = l2tp_jump_to_layer(raw_data+sizeof(struct mesa_udp_hdr), ADDR_TYPE_UDP, expect_layer_type);
-	}else{
-		/* ����UDP���Ͳ�֧������ת */
-		sapp_runtime_log(RLOG_LV_INFO, "udp_jump_to_layer(): unsupport udp sport:%u, dport:%u!\n", usport, udport);
-		return -1;
-	}
-	if(skip_len < 0){
-		return -1;
-	}
-
-	return skip_len + sizeof(struct mesa_udp_hdr);
-}
-
-
-extern int set_gre_hdr(struct mesa_gre_hdr *stack_gre_addr, const void *this_layer_data);
-static int gre_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	int skip_len = 0;
-	int this_gre_layer_len;
-	struct mesa_gre_hdr this_layer_hdr;
-	
-	if(raw_layer_type == expect_layer_type){
-		return 0;
-	}
-
-	this_gre_layer_len = set_gre_hdr(&this_layer_hdr, (void *)raw_data);
-	if(this_gre_layer_len < 0){
-		return -1;
-	}
-
-	switch(ntohs(this_layer_hdr.gre_base.protocol))
-	{
-		case GRE_PRO_IPV4:
-			if(expect_layer_type == ADDR_TYPE_IPV4){
-				skip_len = 0;
-				break;
-			}else{
-				skip_len=ipv4_jump_to_layer(raw_data+this_gre_layer_len, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
-			}
-		break;
-
-		case GRE_PRO_IPV6:
-			if(expect_layer_type == ADDR_TYPE_IPV4){
-				skip_len = 0;
-				break;
-			}else{
-				skip_len=ipv6_jump_to_layer(raw_data+this_gre_layer_len, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
-			}
-		break;
-		
-		case GRE_PRO_PPP:
-			if((expect_layer_type == ADDR_TYPE_PPP) || (expect_layer_type == ADDR_TYPE_PPTP)){
-				skip_len = this_gre_layer_len;
-				break;
-			}else{
-				skip_len = ppp_jump_to_layer(raw_data+this_gre_layer_len, ADDR_TYPE_PPP, expect_layer_type);
-			}	
-		break;
-		
-		default:
-			sapp_runtime_log(RLOG_LV_INFO, "gre_jump_to_layer(): unknown gre protocol:0x%x!\n", ntohs(this_layer_hdr.gre_base.protocol));		
-			return -1;
-			break;
-	}
-
-	if(skip_len < 0){
-		sapp_runtime_log(RLOG_LV_INFO, "gre_jump_to_layer() error!\n");	
-		return -1;
-	}
-
-	return skip_len + this_gre_layer_len;
-}
-
-static int ipv4_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	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;
-
-	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){
-				skip_len = 0;
-				break;
-			}else{
-				skip_len = -1; /* tcp ��֮�ϲ���������Э�� */
-			}
-		break;
-
-		case IPPROTO_UDP:
-			if(ADDR_TYPE_UDP == expect_layer_type){
-				skip_len = 0;
-				break;
-			}else{
-				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_V6 == expect_layer_type){
-				skip_len = 0;
-				break;
-			}else{
-				skip_len = ipv6_jump_to_layer(raw_data+ip_hdr_len, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
-			}
-		break;
-
-		case IPPROTO_GRE:
-			if((ADDR_TYPE_GRE == expect_layer_type) || (ADDR_TYPE_PPTP == expect_layer_type)){
-				skip_len = 0;
-				break;
-			}else{
-				skip_len = gre_jump_to_layer(raw_data+ip_hdr_len, ADDR_TYPE_GRE, expect_layer_type);
-			}		
-		break;
-		
-		default:
-			skip_len = -1;
-		break;
-	}
-
-	if(skip_len < 0){
-		return -1;
-	}
-
-	return skip_len + sizeof(struct ip);
-}
-
-static int ipv6_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	const struct mesa_ip6_hdr *a_packet = (const struct mesa_ip6_hdr *)raw_data;
-	UINT8 next_hdr_type = a_packet->ip6_nxt_hdr;
-	UINT8 *next_hdr_ptr = (UINT8 *)a_packet + sizeof(struct mesa_ip6_hdr);	
-	int skip_len = 0;
-	int offset_to_ip6 = 0;
-	
-	if(raw_layer_type == expect_layer_type){
-		return 0;
-	}
-
-	while(1){
-		offset_to_ip6 = 0;
-		switch(next_hdr_type)
-		{
-			case NEXTHDR_HOP:
-			case NEXTHDR_ROUTING:
-			case NEXTHDR_AUTH:
-			case NEXTHDR_DEST:
-				offset_to_ip6 = (*(next_hdr_ptr + 1))*8 + 8; /* ѡ�����8�ֽ�Ϊ��λ */				
-			break;
-
-			case NEXTHDR_IPIP:
-				if(__ADDR_TYPE_IP_PAIR_V4 == expect_layer_type){
-					skip_len = next_hdr_ptr - (UINT8 *)raw_data;
-				}else{
-					skip_len = ipv4_jump_to_layer((const char *)next_hdr_ptr, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
-					if(skip_len < 0){
-						return -1;
-					}else{
-						return skip_len + next_hdr_ptr - (UINT8 *)raw_data;
-					}
-				}
-				goto done;
-			break;
-
-			case NEXTHDR_NONE:
-				skip_len = -1;
-				goto done;					
-			break;
-
-			case NEXTHDR_ICMP: /* IMCP���ٳ�������Э�� */
-				skip_len = -1;
-				goto done;
-			break;
-			
-			case NEXTHDR_TCP:
-				if(ADDR_TYPE_TCP == expect_layer_type){
-					skip_len = next_hdr_ptr - (UINT8 *)raw_data;
-				}else{
-					skip_len = -1;
-				}
-				goto done;
-			break;
-				
-			case NEXTHDR_UDP:
-				if(ADDR_TYPE_UDP == expect_layer_type){
-					skip_len = next_hdr_ptr - (UINT8 *)raw_data;
-				}else{
-					skip_len = udp_jump_to_layer((char *)next_hdr_ptr, ADDR_TYPE_UDP, expect_layer_type); 
-					if(skip_len < 0){
-						return -1;
-					}else{
-						return skip_len + next_hdr_ptr - (UINT8 *)raw_data;
-					}					
-				}
-				goto done;
-			break;
-
-			case NEXTHDR_FRAGMENT:	
-				/* IP��Ƭ���ټ������ڲ���ת */
-				skip_len = -1;
-				goto done;
-			break;
-
-			case NEXTHDR_ESP:
-				skip_len = -1;
-				goto done;
-
-			default:
-				sapp_runtime_log(20, "ipv6_jump_to_layer(): unknown IPv6 header type:0x%x!\n", next_hdr_type);		
-				skip_len = -1;
-				goto done;
-			break;
-		}
-
-		next_hdr_type = *next_hdr_ptr;
-		next_hdr_ptr += offset_to_ip6;
-	}	
-
-done:
-	if(skip_len < 0){
-		return -1;
-	}
-	
-	return skip_len;
-}
-
-static int ppp_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	int skip_len = 0;
-	struct mesa_ppp_hdr *ppp_data_hdr;
-	char *next_hdr;
-	
-	if(raw_layer_type == expect_layer_type){
-		return 0;
-	}
-	ppp_data_hdr = (struct mesa_ppp_hdr *)raw_data;
-	next_hdr = (char *)raw_data + sizeof(struct mesa_ppp_hdr);
-
-	switch(ntohs(ppp_data_hdr->protocol)){
-		case PPP_PROTOCOL_IPv4:
-			if(__ADDR_TYPE_IP_PAIR_V4 == expect_layer_type){
-				break;
-			}else{
-				skip_len = ipv4_jump_to_layer(next_hdr, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
-			}
-		break;
-
-		case PPP_IPV6:
-			if(__ADDR_TYPE_IP_PAIR_V6 == expect_layer_type){
-				break;
-			}else{
-				skip_len = ipv6_jump_to_layer(next_hdr, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
-			}		
-		break;
-
-		case PPP_COMP:
-		case PPP_CCP:
-		case PPP_IPCP:
-		case PPP_PAP:
-		case PPP_CHAP:
-		case PPP_LQR:
-		case PPP_PROTOCOL_LCP: 
-		
-			/* ������Ӧ�ò�Э�� */
-			skip_len = -1;
-		break;
-
-		default:
-			sapp_runtime_log(RLOG_LV_INFO, "ppp_jump_to_layer(): unsupport ppp pro:0x%x!\n", ntohs(ppp_data_hdr->protocol));
-		break;
-	}
-
-	if(skip_len < 0){
-		return -1;
-	}
-	
-	return skip_len + sizeof(struct mesa_ppp_hdr);
-}
-
-static int pppoe_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	int skip_len = 0;
-	struct mesa_pppoe_session_hdr *pppoe_ses_hdr;
-	char *next_hdr;
-	
-	if(raw_layer_type == expect_layer_type){
-		return 0;
-	}
-	pppoe_ses_hdr = (struct mesa_pppoe_session_hdr *)raw_data;
-	next_hdr = (char *)raw_data + sizeof(struct mesa_pppoe_session_hdr);
-
-	switch(ntohs(pppoe_ses_hdr->ppp_protocol)){
-		case PPP_PROTOCOL_IPv4:
-			if(__ADDR_TYPE_IP_PAIR_V4 == expect_layer_type){
-				break;
-			}else{
-				skip_len = ipv4_jump_to_layer(next_hdr, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
-			}
-		break;
-
-		case PPP_IPV6:
-			if(__ADDR_TYPE_IP_PAIR_V6 == expect_layer_type){
-				break;
-			}else{
-				skip_len = ipv6_jump_to_layer(next_hdr, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
-			}		
-		break;
-
-		case PPP_COMP:
-		case PPP_CCP:
-		case PPP_IPCP:
-		case PPP_PAP:
-		case PPP_CHAP:
-		case PPP_LQR:
-		case PPP_PROTOCOL_LCP: 
-		
-			/* ������Ӧ�ò�Э�� */
-			skip_len = -1;
-		break;
-
-		default:
-			sapp_runtime_log(20, "pppoe_jump_to_layer(): unsupport ppp pro:0x%x!\n", ntohs(pppoe_ses_hdr->ppp_protocol));
-		break;
-		
-	}
-
-	if(skip_len < 0){
-		return -1;
-	}
-	
-	return skip_len + sizeof(struct mesa_pppoe_session_hdr);
-}
-
-
-extern int set_mpls_addr(struct layer_addr_mpls *addr, const unsigned char *raw_mpls_pkt_data);
-static int mpls_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	int skip_len = 0;
-	struct layer_addr_mpls mpls_addr = {};
-	const char *next_layer_data;
-	int mpls_layer_len;
-
-	if(raw_layer_type == expect_layer_type){
-		return 0;
-	}
-
-	set_mpls_addr(&mpls_addr, (unsigned char *)raw_data);
-	mpls_layer_len = mpls_addr.c2s_layer_num * sizeof(struct mesa_mpls_hdr);
-	if(mpls_addr.c2s_has_ctrl_word){
-		mpls_layer_len += sizeof(int);
-	}
-
-	next_layer_data = raw_data + mpls_layer_len;
-
-	/* MPLSû���ֶα�ʶ��һ����ʲô, ���²���һ���IP���� */
-	if((*next_layer_data & 0xF0) == 0x40){
-		skip_len = ipv4_jump_to_layer(next_layer_data, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
-	}else if((*next_layer_data & 0xF0) == 0x60){
-		skip_len = ipv6_jump_to_layer(next_layer_data, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
-	}else{	
-		/* VPLS�Ͳ���control wordһ������, ��set_mpls_addr()������, �������Control word, next_layer_data�Ѿ����������ֽڵ�control word  */
-		skip_len = eth_jump_to_layer(next_layer_data, ADDR_TYPE_MAC, expect_layer_type);
-		if(skip_len < 0){
-			sapp_runtime_log(20, "WARNING: jmp unsupport type in MPLS to Ethernet, 0x%x!\n",  
-							(unsigned char)(*next_layer_data));
-			return -1;
-		}
-	}
-
-	return skip_len + mpls_layer_len;
-}
-
-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;
-	
-	switch(eth_type){
-		case ETH_P_ARP:
-			if(ADDR_TYPE_ARP == expect_layer_type){
-				break;
-			}else{
-				skip_len = arp_jump_to_layer(next_layer_data, ADDR_TYPE_ARP, expect_layer_type);
-			}
-		break;
-
-		case ETH_P_8021Q:
-		case ETH_P_8021AD:
-			if(ADDR_TYPE_VLAN == expect_layer_type){
-				break;
-			}else{
-				skip_len = vlan8021q_jump_to_layer(next_layer_data, ADDR_TYPE_VLAN, expect_layer_type);
-			}
-		break;
-		
-		case ETH_P_IP:
-			if(__ADDR_TYPE_IP_PAIR_V4 == expect_layer_type){
-				break;
-			}else{
-				skip_len = ipv4_jump_to_layer(next_layer_data, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
-			}
-		break;
-
-		case ETH_P_IPV6:
-			if(__ADDR_TYPE_IP_PAIR_V6 == expect_layer_type){
-				break;
-			}else{
-				skip_len = ipv6_jump_to_layer(next_layer_data, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
-			}
-		break;
-
-		case ETH_P_PPP_SES:
-			if(ADDR_TYPE_PPPOE_SES == expect_layer_type){
-				break;
-			}else{
-				skip_len = pppoe_jump_to_layer(next_layer_data, ADDR_TYPE_PPPOE_SES, expect_layer_type);
-			}
-		break;		
-
-		case ETH_P_MPLS_UC: /* 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;
-		break;
-	}
-
-	return skip_len;
-}
-
-extern int set_vlan_addr(struct layer_addr_vlan *addr, const unsigned char *vlan_tag);
-static int vlan8021q_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	int skip_len = 0;
-	struct layer_addr_vlan vlan_addr;
-	const char *next_layer_data;
-	const struct mesa_vlan_hdr *vhdr;
-	unsigned short next_layer_type;
-	int vlan_layer_len;
-
-	if(raw_layer_type == expect_layer_type){
-		return 0;
-	}
-
-	set_vlan_addr(&vlan_addr, (const unsigned char *)raw_data);
-	vlan_layer_len = sizeof(struct mesa_vlan_hdr) * vlan_addr.c2s_layer_num;
-	next_layer_data = raw_data + vlan_layer_len;
-	//vhdr = (struct mesa_vlan_hdr *)&vlan_addr.c2s_addr_array[vlan_addr.c2s_layer_num-1];
-	next_layer_type = ntohs(vlan_addr.c2s_addr_array[vlan_addr.c2s_layer_num-1].TPID);
-	
-	switch(next_layer_type){
-		case ETH_P_ARP:
-			if(ADDR_TYPE_ARP == expect_layer_type){
-				break;
-			}else{
-				skip_len = arp_jump_to_layer(next_layer_data, ADDR_TYPE_ARP, expect_layer_type);
-			}
-		break;
-		
-		case ETH_P_IP:
-			if(__ADDR_TYPE_IP_PAIR_V4 == expect_layer_type){
-				break;
-			}else{
-				skip_len = ipv4_jump_to_layer(next_layer_data, __ADDR_TYPE_IP_PAIR_V4, expect_layer_type);
-			}
-		break;
-
-		case ETH_P_IPV6:
-			if(__ADDR_TYPE_IP_PAIR_V6 == expect_layer_type){
-				break;
-			}else{
-				skip_len = ipv6_jump_to_layer(next_layer_data, __ADDR_TYPE_IP_PAIR_V6, expect_layer_type);
-			}
-		break;
-
-		case ETH_P_PPP_SES:
-			if(ADDR_TYPE_PPPOE_SES == expect_layer_type){
-				break;
-			}else{
-				skip_len = pppoe_jump_to_layer(next_layer_data, ADDR_TYPE_PPPOE_SES, expect_layer_type);
-			}
-		break;		
-
-		case ETH_P_PPP_DISC: /* pppoe���ֽ׶� */
-			skip_len = -1;
-		break;
-
-		/* QinQ */
-		case ETH_P_8021Q:
-			sapp_runtime_log(30, "vlan8021q_jump_to_layer(): multiple VLAN combine to one layer!\n");
-			assert(0);
-		break;
-
-		case ETH_P_MPLS_UC:
-			skip_len = mpls_jump_to_layer(next_layer_data, ADDR_TYPE_MPLS, expect_layer_type);
-		break;
-		
-		default:
-			sapp_runtime_log(20, "vlan8021q_jump_to_layer(): unsupport type: 0x%x!\n", next_layer_type);
-			skip_len = -1;
-	}
-
-	if(skip_len < 0){
-		return -1;
-	}
-
-	return skip_len + vlan_layer_len;
-}
-
-static int eth_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	struct ethhdr *p_eth_hdr = (struct ethhdr *)raw_data;
-	unsigned short eth_type = ntohs(p_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(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);
-}
-
-
-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;
-		NULL: not found expect layer.
-*/
-const void *MESA_jump_layer(const void *raw_data,  int raw_layer_type, int expect_layer_type)
-{
-	int  ret;
-
-	if(check_layer_type(raw_layer_type) < 0){
-		return NULL;
-	}
-
-	if(check_layer_type(expect_layer_type) < 0){
-		return NULL;
-	}
-
-	if(ADDR_TYPE_IPV4 == raw_layer_type){
-		/* ת�ɴ�IPv4��ַ���� */
-		raw_layer_type = __ADDR_TYPE_IP_PAIR_V4;
-	}
-
-	if(ADDR_TYPE_IPV6 == raw_layer_type){
-		/* ת�ɴ�IPv6��ַ���� */
-		raw_layer_type = __ADDR_TYPE_IP_PAIR_V6;
-	}
-
-	if(ADDR_TYPE_IPV4 == expect_layer_type){
-		/* ת�ɴ�IPv4��ַ���� */
-		expect_layer_type = __ADDR_TYPE_IP_PAIR_V4;
-	}
-
-	if(ADDR_TYPE_IPV6 == expect_layer_type){
-		/* ת�ɴ�IPv6��ַ���� */
-		expect_layer_type = __ADDR_TYPE_IP_PAIR_V6;
-	}
-
-	if(raw_layer_type == expect_layer_type){
-		return raw_data;
-	}
-	
-	switch(raw_layer_type){
-		case ADDR_TYPE_MAC:
-			ret = eth_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
-		break;
-		
-		case ADDR_TYPE_ARP:
-			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);
-		break;
-		
-		case __ADDR_TYPE_IP_PAIR_V4:
-			ret = ipv4_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
-		break;
-
-		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_MPLS:	
-			ret = mpls_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
-		break;
-
-		case ADDR_TYPE_GRE:
-			ret = gre_jump_to_layer((const char *)raw_data, raw_layer_type, expect_layer_type);
-		break;
-		
-		case ADDR_TYPE_PPPOE_SES:	
-			return NULL;
-		break;
-		
-		default:
-			sapp_runtime_log(20, "MESA_jump_layer(): unsupport raw_layer_type:%d in MESA_jump_layer()!\n", raw_layer_type);
-			return NULL;
-	}
-
-	if(ret < 0){
-		return NULL;
-	}
-
-	return ((const char *)raw_data + ret);
-}
-
-/*
-	��MESA_net_jump_to_layer()������:
-		MESA_jump_layer()������㿪ʼ, �ҵ���һ�����������IJ���˳�;
-		MESA_jump_layer_greedy()��һֱ���������ڲ�Э��ͷ, �ʺ�����ģʽ.
-	
-	return value:
-		Non-NULL: the pointer to expect layer;
-		NULL: not found expect layer.
-*/
-const void *MESA_jump_layer_greedy(const void *raw_data, int raw_layer_type, int expect_layer_type)
-{
-	int skip_len;
-	const void *expect_layer;
-	const void *success_layer = NULL; /* ���һ�γɹ��ҵ��IJ� */
-	int new_raw_layer_type = raw_layer_type; /* ����ת������, ���ܻ�����м����Ϣ */
-	const char *new_next_layer_data = (char *)raw_data;
-
-	if(ADDR_TYPE_IPV4 == raw_layer_type){
-		/* ת�ɴ�IPv4��ַ���� */
-		raw_layer_type = __ADDR_TYPE_IP_PAIR_V4;
-	}
-
-	if(ADDR_TYPE_IPV6 == raw_layer_type){
-		/* ת�ɴ�IPv6��ַ���� */
-		raw_layer_type = __ADDR_TYPE_IP_PAIR_V6;
-	}
-
-	if(ADDR_TYPE_IPV4 == expect_layer_type){
-		/* ת�ɴ�IPv4��ַ���� */
-		expect_layer_type = __ADDR_TYPE_IP_PAIR_V4;
-	}
-
-	if(ADDR_TYPE_IPV6 == expect_layer_type){
-		/* ת�ɴ�IPv6��ַ���� */
-		expect_layer_type = __ADDR_TYPE_IP_PAIR_V6;
-	}
-
-	expect_layer = MESA_jump_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���������һ��ƫ�� */
-				}else if(IPPROTO_GRE == ip4hdr->ip_p){
-					new_next_layer_data = (char *)expect_layer + ip4hdr->ip_hl * 4;
-					new_raw_layer_type = ADDR_TYPE_GRE; /* GRE */					
-				}else{
-					//TODO 2, IPIP, L2TPv3
-					goto done;
-				}
-			}
-			break;
-
-			case __ADDR_TYPE_IP_PAIR_V6:
-			{
-				//TODO2,
-				goto done;		
-			}
-			break;
-
-			case ADDR_TYPE_UDP:
-			{
-				skip_len = udp_jump_to_layer_greedy((char *)expect_layer, ADDR_TYPE_UDP, expect_layer_type);
-				if(skip_len < 0){
-					goto done;
-				}
-
-				success_layer = (char *)expect_layer + skip_len;
-				goto done;
-			}
-			break;
-
-			default:
-				sapp_runtime_log(RLOG_LV_INFO, "MESA_jump_layer_greedy() not support layer type:%d\n", expect_layer_type);
-				goto done;
-		}
-
-		expect_layer = MESA_jump_layer(new_next_layer_data, new_raw_layer_type, expect_layer_type);
-	}
-
-done:
-	return success_layer;
-}
-#endif 
-
 typedef struct{
 	enum addr_type_t addrtype;
 	const void *layer_header;
@@ -1243,12 +307,6 @@ enum addr_type_t ethernet_protocol_to_net_layer(UINT16 ether_type_host)
 		case ETH_P_ARP:
 			addrtype = ADDR_TYPE_ARP;
 		break;
-#if 0
-		case ETHERTYPE_PANGU_MAC_IN_MAC:
-			addrtype = ADDR_TYPE_MAC_IN_MAC;
-		break;
-#endif
-
 		default:
 			/* to do, unknown type */
 			sapp_runtime_log(RLOG_LV_INFO, "ethernet_protocol_to_net_layer(): unknown ethernet carry addr type:0x%x\n", ether_type_host);
diff --git a/src/common/stream_addr_inet.c b/src/common/stream_addr_inet.c
index 017c7c2..37b4f92 100644
--- a/src/common/stream_addr_inet.c
+++ b/src/common/stream_addr_inet.c
@@ -976,17 +976,11 @@ static int __addr_pton(char *single_addr_str, addr_continuous_bin_t *addr_bin_va
 	enum addr_type_t addr_type;
 	int i, ret = 0, prefix_with_delim_len, single_addr_str_len;
 
-#if 0	
-	addr_type = addr_prefix_to_type(single_addr_str);
-	if(__ADDR_TYPE_INIT == addr_type){
-		return -1;
-	}
-#else
+
 	prefix_with_delim_len = addr_prefix_to_stream_and_addr_type(single_addr_str, &addr_type, &addr_bin_val->stream.type);
 	if(prefix_with_delim_len < 0){
 		return -1;
 	}
-#endif
 
 	single_addr_str_len = strlen(single_addr_str);
 	if(single_addr_str[single_addr_str_len-1] != '>'){ /* ��ַ���һ���ַ����Ƿָ���'>' */
@@ -1298,51 +1292,6 @@ static int __addr_pure_udp_n2p_fun(const struct layer_addr *paddr, char *buf, in
 	return strlen(buf) + 1;
 }
 
-#if 0
-static int __addr_vlan_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len)
-{
-	const struct layer_addr_vlan *vlan_addr = paddr->vlan;
-	//const struct mesa_vlan_hdr *vhdr;
-	int i;
-	unsigned short vlan_id;
-	char tmp_buf[32] = {};
-	char vlan_addr_string[128] = {};
-	
-	/* ע��: �����зǶԳ�vlan����� */
-	int max_layer_num = vlan_addr->c2s_layer_num > vlan_addr->s2c_layer_num ? vlan_addr->c2s_layer_num:vlan_addr->s2c_layer_num;
-
-	for(i = 0; i < max_layer_num; i++){
-		if(vlan_addr->c2s_layer_num >= i+1){
-			//vhdr = (struct mesa_vlan_hdr *)&vlan_addr->c2s_addr_array[i];
-			vlan_id = ntohs(vlan_addr->c2s_addr_array[i].VID);
-			snprintf(tmp_buf, 32, "%d", vlan_id);
-			strcat(vlan_addr_string, tmp_buf);
-		}else{
-			strcat(vlan_addr_string, "N/A-");
-		}
-		if(vlan_addr->s2c_layer_num >= i+1){
-			//vhdr = (struct mesa_vlan_hdr *)&vlan_addr->s2c_addr_array[i];
-			vlan_id = ntohs(vlan_addr->s2c_addr_array[i].VID);
-			snprintf(tmp_buf, 32, "%d", vlan_id);
-			strcat(vlan_addr_string, tmp_buf);
-		}else{
-			strcat(vlan_addr_string, "-N/A");
-		}
-		if(i < max_layer_num-1){
-			strcat(vlan_addr_string, ",");
-		}
-	}
-	
-	int addr_len = strlen(vlan_addr_string);
-	if(buf_len <= addr_len + 1){
-		return -1;
-	}
-	strncpy(buf, vlan_addr_string, addr_len + 1);
-
-	return addr_len + 1;
-}
-#endif
-
 #define VLAN_ADDR_STR_LEN 128
 #define TMP_BUF_LEN 32
 
@@ -1479,60 +1428,6 @@ static int __addr_gre_n2p_fun(const struct layer_addr *paddr, char *buf, int buf
 	return addr_len + 1;
 }
 
-/*
-	��ʽ˵��:
-		ÿ��mpls��ַʹ��src-dst��ʾ, ���֮���mplsʹ��,�ָ�, 
-		����:
-		<1-2>
-		<1-2,3-4,5-6>
-*/
-#if 0
-static int __addr_mpls_n2p_fun(const struct layer_addr *paddr, char *buf, int buf_len)
-{
-	const struct layer_addr_mpls *mpls_addr = paddr->mpls;
-	const struct mesa_mpls_hdr *net_mpls_hdr;
-	int i;
-	int mpls_label;
-	char tmp_buf[32];
-	/* ע���зǶԳ�mpls����� */
-	int max_layer_num = mpls_addr->c2s_layer_num > mpls_addr->s2c_layer_num ? mpls_addr->c2s_layer_num:mpls_addr->s2c_layer_num;
-
-	char mpls_addr_string[128] = {};
-
-	for(i = 0; i < max_layer_num; i++){
-		if(mpls_addr->c2s_layer_num >= i+1){
-			//mpls_label = 0;
-			//net_mpls_hdr = (struct mesa_mpls_hdr *)&mpls_addr->src_mpls_pkt[i];
-			//mpls_label = (net_mpls_hdr->mpls_label_low<<12) | (net_mpls_hdr->mpls_label_mid<<4) | net_mpls_hdr->mpls_label_high; /* network order */
-			snprintf(tmp_buf, 32, "%d", ntohl(mpls_addr->c2s_addr_array[i].label));
-			strcat(mpls_addr_string, tmp_buf);
-		}else{
-			strcat(mpls_addr_string, "N/A");
-		}
-		if(mpls_addr->s2c_layer_num >= i+1){
-			//mpls_label = 0;
-			//net_mpls_hdr = (struct mesa_mpls_hdr *)&mpls_addr->dest_mpls_pkt[i];
-			//mpls_label = (net_mpls_hdr->mpls_label_low<<12) | (net_mpls_hdr->mpls_label_mid<<4) | net_mpls_hdr->mpls_label_high; /* network order */
-			snprintf(tmp_buf, 32, "-%d", ntohl(mpls_addr->s2c_addr_array[i].label));
-			strcat(mpls_addr_string, tmp_buf);
-		}else{
-			strcat(mpls_addr_string, "-N/A");
-		}
-		if(i < max_layer_num-1){
-			strcat(mpls_addr_string, ",");
-		}
-	}
-	
-	int addr_len = strlen(mpls_addr_string);
-	if(buf_len <= addr_len + 1){
-		return -1;
-	}
-	strncpy(buf, mpls_addr_string, addr_len + 1);
-
-	return addr_len + 1;
-}
-#endif
-
 #define MPLS_ADDR_STR_LEN 128
 #define TMP_BUF_LEN 32