path: root/src/common/net_common.c

#include "sapp_api.h"
#include "sapp_private_api.h"


#ifdef __cplusplus
extern "C" {
#endif

static int eth_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type);
static int vlan8021q_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type);
static int ipv4_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type);
static int ipv6_jump_to_layer(const char *raw_data,  int raw_layer_type, int expect_layer_type);

/* 
	��ַ��ת������, ���Ʊ�׼��<arpa/inet.h>�е�inet_ntop, inet_pton,
	Ϊ�˷���Ӧ�ô�ӡ��־������, ͬʱ֧��'��������'��'��������'������������;
	��ַ�����֮��, ���ݷ���IJ�ͬʹ��'<'��'>'�ָ�;
	��ַ��˫�����Ե�, ��IP��PORT��, ��'-'�ָ�Դ��Ŀ�ĵ�ַ, ��ʽ:"Դ-Ŀ��";
	�ַ�����ַʹ�ù̶�4�ֽڵ�ǰ׺, ���ڱ�ʶ�����ַ����;
	�ַ�����ʽ����:
		���ڲ���������, ��outward:
			T4T:6005-1673<IP4:61.147.112.53-11.215.62.23<MAC:0000ea60040d-0200000003b6
		��������ڲ����, ��inward:
			MAC:0000ea600608-020000000299>IP4:95.49.136.204-125.118.233.38>T4T:52694-46786
*/
const char *stream_addr_list_ntop_outward(const struct streaminfo *pstream);
const char *stream_addr_list_ntop_inward(const struct streaminfo *pstream);
const struct streaminfo *stream_addr_list_pton_outward(const char *addr_list_str, int thread_index);
const struct streaminfo *stream_addr_list_pton_inward(const char *addr_list_str, int thread_index);
const char *addr_type_to_prefix(enum addr_type_t layer_type);
extern void reverse_addr(void *addr, int addrtype);
extern const addr_convert_t G_ADDR_CONVERT_HANDLE[];


/* ascii�ַ�ת16���� */
char MESA_ascii_to_hex(char ascii)
{
	char c = 0;
	
	switch(ascii)
	{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			c = ascii - 0x30;
		break;

		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
			c = 10 + ascii - 0x61;
		break;

		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
			c = 10 + ascii - 0x41;
		break;
	}

	return c;
}


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;
	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�㼴�� , before 20181204*/
		const char *next_layer_hdr = raw_data+sizeof(struct mesa_udp_hdr);
        struct teredo_auth_hdr *p_teredo_hdr;
		int teredo_layer_len = 0, tmp_hdr_len = 0;
		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(20, "udp_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;
	}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 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;
		
		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{
					/* TODO: IPv6����������ģʽ */
					skip_len = -1;
				}
				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_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_V4, 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, "ppp_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 = ppp_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 = ppp_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_net_jump_to_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 == 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_PPPOE_SES:	
		case ADDR_TYPE_GRE:
		default:
			sapp_runtime_log(20, "MESA_net_jump_to_layer(): unsupport raw_layer_type:%d in MESA_net_jump_to_layer()!\n", raw_layer_type);
			return NULL;
	}

	if(ret < 0){
		return NULL;
	}

	return ((const char *)raw_data + ret);
}

/*
	��MESA_net_jump_to_layer()������:
		MESA_net_jump_to_layer()������㿪ʼ, �ҵ���һ�����������IJ���˳�;
		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; /* ���һ�γɹ��ҵ��IJ� */
	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;

	switch(addr_type){
		case __ADDR_TYPE_IP_PAIR_V4:
			proto = IPPROTO_IPIP;
		break;

		case __ADDR_TYPE_IP_PAIR_V6:
			proto = IPPROTO_IPV6;
		break;

		case ADDR_TYPE_TCP:
			proto = IPPROTO_TCP;
		break;

		case ADDR_TYPE_UDP:
			proto = IPPROTO_UDP;
		break;

		case ADDR_TYPE_GRE:
			proto = IPPROTO_GRE;
		break;

		default:
			sapp_runtime_log(20, "net_layer_to_ipv4_protocol(): unknown ip4 protocolr:%d\n", addr_type);
			proto = 0xFF;
		break;
	}

	return proto;
}

UINT8 net_layer_to_ipv6_protocol(int addr_type)
{
	UINT8 proto = 0;

	switch(addr_type){
		case ADDR_TYPE_TCP:
			proto = NEXTHDR_TCP;
		break;

		case ADDR_TYPE_UDP:
			proto = NEXTHDR_UDP;
		break;

		case __ADDR_TYPE_IP_PAIR_V4:
			proto = NEXTHDR_IPIP;
		break;

		default:
			sapp_runtime_log(20, "net_layer_to_ipv6_protocol(): unknown ip6 next-hdr:%d\n", addr_type);
			return 0xFF;
		break;
	}

	return proto;
}

/*
	��MESA��ַ����ת��Ϊ��׼Ethernet����;
	
	return value:
		ethernet type, host order.
*/
UINT16 net_layer_to_ethernet_protocol(int addr_type)
{
	UINT16 ether_type = 0;

	switch(addr_type){
		case __ADDR_TYPE_IP_PAIR_V4:
		case ADDR_TYPE_IPV4:
			ether_type = ETH_P_IP;
		break;

		case __ADDR_TYPE_IP_PAIR_V6:
		case ADDR_TYPE_IPV6:
			ether_type = ETH_P_IPV6;
		break;

		case ADDR_TYPE_VLAN:
			ether_type = ETHERTYPE_VLAN;
		break;

		case ADDR_TYPE_TCP:
		case ADDR_TYPE_UDP:
			sapp_runtime_log(RLOG_LV_FATAL, "%s:%d: Ethernet can't carry addr type:%d directly!\n", __FILE__, __LINE__,addr_type);
			//assert(0);
			ether_type = -1;
		break;

		case ADDR_TYPE_PPPOE_SES:
			ether_type = ETH_P_PPP_SES;
		break;

		case ADDR_TYPE_MPLS:
			ether_type = ETH_P_MPLS_UC;
		break;

		case ADDR_TYPE_ARP:
			ether_type = ETH_P_ARP;
		break;

		default:
			/* to do, unknown type */
			sapp_runtime_log(RLOG_LV_FATAL, "%s:%d: unknown ethernet carry addr type:%d!\n", __FILE__, __LINE__, addr_type);
			ether_type = -1;
		break;
	}

	return ether_type;
}

/*
	��MESA��ַ����ת��Ϊ��׼Ethernet����;
	
	return value:
		ethernet type, host order.
*/
UINT16 net_layer_to_ethernet_protocol_by_stream(const struct streaminfo *pstream)
{
	UINT16 ether_type = 0;
	int addr_type = pstream->addr.addrtype;

	switch(addr_type){
		case __ADDR_TYPE_IP_PAIR_V4:
		case ADDR_TYPE_IPV4:
			ether_type = ETH_P_IP;
		break;

		case __ADDR_TYPE_IP_PAIR_V6:
		case ADDR_TYPE_IPV6:
			ether_type = ETH_P_IPV6;
		break;

		case ADDR_TYPE_VLAN:
			if(ADDR_TYPE_8021Q_ABBR == pstream->addr.pkttype){
				ether_type = ETH_P_8021Q;
			}else{
				ether_type = ETH_P_8021AD;
			}
		break;

		case ADDR_TYPE_TCP:
		case ADDR_TYPE_UDP:
			sapp_runtime_log(RLOG_LV_FATAL, "%s:%d: Ethernet can't carry addr type:%d directly!\n", __FILE__, __LINE__,addr_type);
			//assert(0);
			ether_type = -1;
		break;

		case ADDR_TYPE_PPPOE_SES:
			ether_type = ETH_P_PPP_SES;
		break;

		case ADDR_TYPE_MPLS:
			ether_type = ETH_P_MPLS_UC;
		break;

		case ADDR_TYPE_ARP:
			ether_type = ETH_P_ARP;
		break;

		default:
			/* to do, unknown type */
			sapp_runtime_log(RLOG_LV_FATAL, "%s:%d: unknown ethernet carry addr type:%d!\n", __FILE__, __LINE__, addr_type);
			ether_type = -1;
		break;
	}

	return ether_type;
}


/*
	����׼Ethernet����ת��ΪMESA��ַ����;
*/
enum addr_type_t ethernet_protocol_to_net_layer(UINT16 ether_type_host)
{
	enum addr_type_t addrtype = __ADDR_TYPE_INIT;

	switch(ether_type_host){
		case ETH_P_IP:
			addrtype = __ADDR_TYPE_IP_PAIR_V4;
		break;

		case ETH_P_IPV6:
			addrtype = __ADDR_TYPE_IP_PAIR_V6;
		break;

		case ETH_P_8021Q:
		case ETH_P_8021AD:
			addrtype = ADDR_TYPE_VLAN;
		break;

		case ETH_P_PPP_SES:
			addrtype =  ADDR_TYPE_PPPOE_SES;
		break;

		case ETH_P_MPLS_UC :
			addrtype = ADDR_TYPE_MPLS;
		break;

		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, "%s:%d: unknown ethernet carry addr type:0x%x\n", __FILE__, __LINE__, ether_type_host);
		break;
	}

	return addrtype;
}


/* ����ģʽ��, ���յ��İ�����ת�� */
int packet_io_forward_pkt(int thread_num, int top_mode)
{
	if(0 == (top_mode & __NET_CONN_SERIAL)){
		return -1;
	}

	/* to do!! */
	/* Gģʽ����˫��������ģʽ������һ��, G�൱��������һ����, ˫����ģʽ����ֱ��͸��, ��DPDK��PFRING�¶�֧�� */
	
	return 0;
}

int net_common_adjust_forward_mac(struct mesa_ethernet_hdr *raw_eth_hdr,int net_topology_mode)
{
	u_int8_t  tmp_addr[ETHER_ADDR_LEN];
	
	if(NET_CONN_SERIAL_GDEV == net_topology_mode){
		memcpy(tmp_addr, raw_eth_hdr->ether_shost, ETHER_ADDR_LEN);
		memcpy(raw_eth_hdr->ether_shost, raw_eth_hdr->ether_dhost, ETHER_ADDR_LEN);
		memcpy(raw_eth_hdr->ether_dhost, tmp_addr, ETHER_ADDR_LEN);
	}
	return 0;
}

int net_common_build_send_mac(UINT8 *buf, const struct mesa_ethernet_hdr *raw_eth_hdr,
						int upper_layer_addr_type, int dir_reverse, int net_topology_mode)
{
	struct mesa_ethernet_hdr *send_eth_hdr = (struct mesa_ethernet_hdr *)buf;

	if(NET_CONN_SERIAL_GDEV == net_topology_mode){
		/* �����ͬ��, �򵥵ߵ�˳�򼴿� */
		memcpy(send_eth_hdr->ether_dhost, raw_eth_hdr->ether_shost, ETHER_ADDR_LEN);
		memcpy(send_eth_hdr->ether_shost, raw_eth_hdr->ether_dhost, ETHER_ADDR_LEN);

		if(1 == dir_reverse){
			/* MAC��ַ���λȡ�� */
			if(send_eth_hdr->ether_dhost[5] & 0x01){
				send_eth_hdr->ether_dhost[5] &= 0xFE; /* ���һλ���� */
			}else{
				send_eth_hdr->ether_dhost[5] |= 0x01; /* ���һλ��Ϊ1 */
			}
		}
	}else{
		if(0 == dir_reverse){
			memcpy(send_eth_hdr->ether_dhost, raw_eth_hdr->ether_dhost, ETHER_ADDR_LEN);
			memcpy(send_eth_hdr->ether_shost, raw_eth_hdr->ether_shost, ETHER_ADDR_LEN);
		}else{
			memcpy(send_eth_hdr->ether_dhost, raw_eth_hdr->ether_shost, ETHER_ADDR_LEN);
			memcpy(send_eth_hdr->ether_shost, raw_eth_hdr->ether_dhost, ETHER_ADDR_LEN);
		}
	}

	send_eth_hdr->ether_type = htons(net_layer_to_ethernet_protocol(upper_layer_addr_type));

	return 0;
}


void MESA_stream_list_free(struct streaminfo_private *pstream_pr)
{
	struct streaminfo_private *pfather_pr;
	struct streaminfo *pstream = &pstream_pr->stream_public;

	if(NULL == pstream_pr){
		return;
	}
	/* �Ƚ�pfather���浽��ʱ���� */
	pfather_pr = (struct streaminfo_private *)pstream_pr->stream_public.pfather; /* 2021-01-11, ������ip��Ƭȷ����ַ, �˴�ʹ���ڴ���Ԫ��,ʹ��pfather������pfather_pr */

	dictator_free(pstream->threadnum, pstream->addr.paddr);
	dictator_free(pstream->threadnum, pstream_pr);

	return MESA_stream_list_free(pfather_pr);
}

struct streaminfo_private *MESA_stream_list_dup(struct streaminfo_private *stack_stream_pr, int reverse)
{
	struct streaminfo_private *heap_stream_pr = NULL;
	struct streaminfo *heap_stream;
	void *heap_addr;
	struct streaminfo *stack_stream;

	if(NULL == stack_stream_pr){
		return NULL;
	}
	stack_stream = &stack_stream_pr->stream_public;

	heap_stream_pr = (struct streaminfo_private *)dictator_malloc(stack_stream->threadnum, sizeof(struct streaminfo_private));
	memcpy(heap_stream_pr, stack_stream_pr, sizeof(struct streaminfo_private));
	heap_stream = &heap_stream_pr->stream_public;
	
	heap_addr = dictator_malloc(stack_stream->threadnum, stack_stream->addr.addrlen);
	memcpy(heap_addr, stack_stream->addr.paddr, stack_stream->addr.addrlen);

	if(reverse){
		heap_stream_pr->dirreverse=1;
		heap_stream_pr->stream_dir = 1 ^ heap_stream_pr->layer_dir; /* lijia comment, ��"src>=dst"Ĭ�Ϲ���һ�� */
		reverse_addr(heap_addr, heap_stream->addr.addrtype);
	}else{
		heap_stream_pr->stream_dir = heap_stream_pr->layer_dir;
	}

	heap_stream->addr.paddr = heap_addr;
	heap_stream->addr.addrlen = stack_stream->addr.addrlen;

	/* 2021-01-11, ������ip��Ƭȷ����ַ, �˴�ʹ���ڴ���Ԫ��,ʹ��pfather������pfather_pr */
	heap_stream->pfather = (struct streaminfo *)MESA_stream_list_dup((struct streaminfo_private *)(stack_stream->pfather), reverse);

	return (struct streaminfo_private *)heap_stream;
}

int MESA_stream_list_cmp(struct streaminfo_private *stream1_pr, struct streaminfo_private *stream2_pr)
{
	int ret = 0;
	//int isreverse = 0;
	struct streaminfo *stream1 = &stream1_pr->stream_public;
	struct streaminfo *stream2 = &stream2_pr->stream_public;
	
	if(NULL == stream1_pr){
		if(stream2_pr != NULL){		
			return -1;
		}else{	
			return 0;
		}
	}else{
		if(NULL == stream2_pr){			
			return 1;
		}	
	}

	if(stream1->type != stream2->type){
		return (stream1->type > stream2->type) ? 1:-1;
	}
	
	if(stream1->addr.addrtype != stream2->addr.addrtype){
		return (stream1->addr.addrtype > stream2->addr.addrtype)?1:-1;
	}
	
	//if(stream1_pr->dirreverse != stream2_pr->dirreverse){ /* lijia comment, ������dirreverse=0; */
		//isreverse = 1; 
	//}
	
	/* 2014-04-01 lijia add, ��������Ƚ�, ֱ������ */
	if((0 == stream1_pr->addr_use_as_hash) && (0 == stream2_pr->addr_use_as_hash)){
		return MESA_stream_list_cmp((struct streaminfo_private *)(stream1->pfather), (struct streaminfo_private *)(stream2->pfather));
	}

#if IP_PORT_UNION_VERSION
	/* IPPORT_UNION�汾ֻ��һ��streaminfo, ֱ�ӱȽϵ�ַ����, ������ת��pfather */
#else
	/* TCP��UDP�ĵ�ַ��Ϣ������IP��, ��������Ƚ� */
	if((ADDR_TYPE_IPV4 == stream1->addr.addrtype)
	||(ADDR_TYPE_IPV6 == stream1->addr.addrtype)){
		return MESA_stream_list_cmp((struct streaminfo_private *)(stream1->pfather), (struct streaminfo_private *)(stream2->pfather));
	}
#endif

	/* TODO 2, to do:
		if(isreverse), ��ת��ַ�Ƚ�, ����÷����ַ�ȽϺ��� 
	*/

	ret = memcmp(stream1->addr.paddr, stream2->addr.paddr, stream2->addr.addrlen);
	if(ret != 0){
		return ret;
	}

	ret = MESA_stream_list_cmp((struct streaminfo_private *)(stream1->pfather), (struct streaminfo_private *)(stream2->pfather));
	
	return ret;
}


/* ��ȡ��������Ӧ��ԭʼ��ͷ��ʼ��ַ */
const void *get_this_layer_header(const struct streaminfo *pstream)
{
	const void *this_layer_hdr = NULL;
	const struct streaminfo_private *pstream_pr = (const struct streaminfo_private *)pstream;

	if(OP_STATE_CLOSE == pstream->opstate){
		if(STREAM_TYPE_TCP == pstream->type){ 
			const struct tcpdetail_private *pr_tcpdetail=(struct tcpdetail_private *)pstream->pdetail;
			if((STREAM_LINK_TIMEOUT == pr_tcpdetail->link_state) || (STREAM_LINK_LRU_OUT == pr_tcpdetail->link_state)){
				this_layer_hdr = NULL;
			}
		}else if(STREAM_TYPE_UDP == pstream->type){
			this_layer_hdr = NULL; /* UDPȫ�ǿ�ʱ����̭, ��ǰ���϶�ΪNULL */
		}else{
			this_layer_hdr = (const void *)
					 ((const char *)(pstream_pr->raw_pkt->raw_pkt_data) + pstream_pr->offset_to_raw_pkt_hdr);
		}
	}else{
		this_layer_hdr = (const void *)
					 ((const char *)(pstream_pr->raw_pkt->raw_pkt_data) + pstream_pr->offset_to_raw_pkt_hdr);
	}
	
	return this_layer_hdr;
}

/* ɾ��ĩβ�Ļ��з�"\r\n" */
void del_last_rn(char *data, int max_len)
{
    int i;
    for(i = 0; i < max_len; i++){
        if(('\r' == data[i]) || ('\n' == data[i])){
            data[i] = '\0';
            return;
        }
    }

    return;
}

/*	
	����ֵ:
		ethernet����, ����ethͷ��.
*/
int get_pkt_len_from_eth_hdr(const struct mesa_ethernet_hdr *ehdr)
{
	int raw_pkt_len = -1;

	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(struct mesa_ethernet_hdr);
		}
		break;

		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);	
		}
		break;

		default:
		break;
	}

	return raw_pkt_len;
}

/* ģ��tcpdump��ʽ:   192.168.40.137.22 > 192.168.36.40.49429  */
const char *sapp_raw_ipv4_ntop(const struct mesa_ip4_hdr *ip4_hdr, char *out_buf, int buf_len )
{
	unsigned char inner_ip_proto;
	const struct mesa_tcp_hdr *inner_thdr = NULL;
	const struct mesa_udp_hdr *inner_uhdr = NULL;
	unsigned short sport, dport;
	char ipsrc_str[INET6_ADDRSTRLEN];
	char ipdst_str[INET6_ADDRSTRLEN];

	inner_ip_proto = ip4_hdr->ip_p;		
	if(IPPROTO_TCP == inner_ip_proto){
		inner_thdr = (struct mesa_tcp_hdr *)((char *)ip4_hdr + ip4_hdr->ip_hl*4);
		sport = ntohs(inner_thdr->th_sport);
		dport = ntohs(inner_thdr->th_dport);
	}else if(IPPROTO_UDP){
		inner_uhdr = (struct mesa_udp_hdr *)((char *)ip4_hdr + ip4_hdr->ip_hl*4);
		sport = ntohs(inner_uhdr->uh_sport);
		dport = ntohs(inner_uhdr->uh_dport);				
	}else{
		sapp_runtime_log(RLOG_LV_INFO, "sapp_raw_ipv4_ntop() error, unsupport ip protocol:%d", inner_ip_proto);
		return NULL;
	}
	
	inet_ntop(AF_INET, &ip4_hdr->ip_src.s_addr, ipsrc_str, sizeof(ipsrc_str));
	inet_ntop(AF_INET, &ip4_hdr->ip_dst.s_addr, ipdst_str, sizeof(ipdst_str));

	snprintf(out_buf, buf_len, "%s.%u > %s.%u", ipsrc_str, sport, ipdst_str, dport);

	return out_buf;
}


const char *sapp_raw_ipv6_ntop(const struct mesa_ip6_hdr *ip6_hdr, char *out_buf, int buf_len)
{
	unsigned char inner_ip_proto;
	const struct tcphdr *inner_thdr = NULL;
	const struct udphdr *inner_uhdr = NULL;
	unsigned short sport, dport;
	char ipsrc_str[INET6_ADDRSTRLEN];
	char ipdst_str[INET6_ADDRSTRLEN];
	

	/* TODO: �˴��п��ܰ���ѡ�����Ƭ, ����ֱ�ӻ�ȡ��һ���Э������, ��˴��������Ͻ�! */
	inner_ip_proto = ip6_hdr->ip6_nxt_hdr;	
	if(IPPROTO_TCP == inner_ip_proto){
		inner_thdr = (struct tcphdr *)((char *)ip6_hdr + sizeof(struct ip6_hdr));
		sport = inner_thdr->source;
		dport = inner_thdr->dest;				
	}else if(IPPROTO_UDP){
		inner_uhdr = (struct udphdr *)((char *)ip6_hdr + sizeof(struct ip6_hdr));
		sport = inner_uhdr->source;
		dport = inner_uhdr->dest;					
	}else{
		sapp_runtime_log(RLOG_LV_INFO, "sapp_raw_ipv6_ntop() error, unsupport ip6_nxt_hdr:%d", inner_ip_proto);
		return NULL;
	}	
	
	inet_ntop(AF_INET6, &ip6_hdr->ip6_src, ipsrc_str, sizeof(ipsrc_str));
	inet_ntop(AF_INET6, &ip6_hdr->ip6_dst, ipdst_str, sizeof(ipdst_str));

	snprintf(out_buf, buf_len, "%s.%u > %s.%u", ipsrc_str, sport, ipdst_str, dport);


	return out_buf;
}


#ifdef __cplusplus
}
#endif