bs_udplink.c

wimax bs模拟器

/******************************************************************************\


			Copyright  (c)	2007,  UTStarcom,Inc. (ShenZhen R&D Center)
			All Rights Reserved.

			Subsystem		: WIMAX
			Group			: GW/AnchorDP/...
			File				: bs_udplink.c
			Version			: 
			Build			: 
			Author			: RCT
			Maintained by		: RCT
			Create Date		: 2007-01-22
			Last Modify		: 
			Description		: BS udp link
																			  
\******************************************************************************/
/*
-----------------------------------------------------------
Software Develop CodeName :

Module Reference :
	
-----------------------------------------------------------
Change History:

07-01.25	RCT		create file.
*/
#include "global.h"
#include "bs_common.h"
#include "bs_udpLink.h"
#include "bs_log.h"
#include "gw_up_if.h"

BS_UDP_CB_S ga_bs_udp_cb[BS_MAX_UDP_ID] = 
{
	{0,BS_R6_UDP_PORT,0},
	{0,DHCP_UDP_PORT,0},
	{0,ACTION_UDP_PORT,0}
};

int g_host_sock_fd;

u_long bs_udp_trace_id=0;

DWORD gHostIp;

extern DWORD gSourceIp;
extern MSG_Q_ID g_msgq_bscp;
extern MSG_Q_ID 	gDhcpClientMsgQId;
void bs_udp_recv();

/*******************************************************************************
** Function Name: bs_udp_data_init
** Input parameters description:
a - None
** Output results description:
a - Always OK.
** function description:
Initialize data except socket used by UDP task, such as the array of
message id.
*******************************************************************************/
static STATUS bs_udp_data_init()
{
	
    return OK;
}

/*******************************************************************************
** Function Name: bs_udp_sock_init
** Input parameters description:
a - None
** Output results description:
a - ERROR, create UDP and bind socket failure.
b - OK, create UDP and bind socket success.
** function description:
Create and bind socket.
*******************************************************************************/
static STATUS bs_udp_sock_init()
{
	int i;
	
	for(i = 0;i < BS_MAX_UDP_ID;i++)
	{
		ga_bs_udp_cb[i].dw_src_ip = gSourceIp;
		if (ERROR==(ga_bs_udp_cb[i].i_sock_fd = xSockOpen(SOCK_DGRAM)))
		{
			bs_log_err("failed to create socket for (0x%x:%d)",ga_bs_udp_cb[i].dw_src_ip,ga_bs_udp_cb[i].w_src_udp_port);
			return ERROR;
		}
		
		
		if ( ERROR==xSockBindWithIp(ga_bs_udp_cb[i].i_sock_fd, ga_bs_udp_cb[i].w_src_udp_port,ga_bs_udp_cb[i].dw_src_ip))
		{
			bs_log_err("failed to bind socket for (0x%x:%d)",ga_bs_udp_cb[i].dw_src_ip,ga_bs_udp_cb[i].w_src_udp_port);
			return ERROR;
		}		
	}

	if (ERROR == (g_host_sock_fd = xSockOpen(SOCK_DGRAM)))
	{
		bs_log_err("failed to create socket for g_host_sock_fd");
		return ERROR;
	}
	
	return OK;
}

/*******************************************************************************
** Function Name: bs_udp_sock_close
** Input parameters description:
a - None
** Output results description:
a - ERROR, create UDP and bind socket failure.
b - OK, create UDP and bind socket success.
** function description:
Create and bind socket.
*******************************************************************************/
STATUS bs_udp_sock_close()
{
	int i;

	for(i = 0;i < BS_MAX_UDP_ID;i++)
	{
		if (ga_bs_udp_cb[i].i_sock_fd>0 )
		{
			xSockClose(ga_bs_udp_cb[i].i_sock_fd);
		}
	}

	if (g_host_sock_fd>0 )
	{
		xSockClose(g_host_sock_fd);
	}

	return ERROR;
	
}


/*******************************************************************************
** Function Name: bs_udp_init
** Input parameters description:
a - None
** Output results description:
a - ERROR, create UDP task failure.
b - OK, create UDP task success.
** function description:
Create UdpTask
*******************************************************************************/
STATUS bs_udp_init()
{
    int i_tid;

    XTRACEOPEN("BS-UDP", 0, &bs_udp_trace_id);
    XTRACE0(bs_udp_trace_id,2,"bs trace udp opened");

 
    if(ERROR==bs_udp_sock_init())
    {
		bs_udp_sock_close();
		bs_log_err(" bs_udp_sock_init error.\n");
		
		return ERROR;
    }
	
    if (ERROR == bs_udp_data_init())
    {
		bs_udp_sock_close();
		
		bs_log_err(" bs_udp_data_init error.\n");
		return ERROR;
    }
	
    i_tid = xTaskCreate("tBsUdp", 
		(XTHREADFUNC)bs_udp_recv,
		BS_UDP_TASK_STACK_SIZE,
		NULL,
		BS_UDP_TASK_PRIORITY);
	
    if (ERROR==i_tid )
    {
        bs_udp_sock_close();
		
        bs_log_err("failed to spawn the UDP task");
        return ERROR;
    }
	
    return OK;
}

/*******************************************************************************
** Function Name: bs_udp_send_packet
** Input parameters description:
a - i_sock_fd: socket to send
b - dw_dest_ip: Destination IP address
c - w_dst_udp_port: Destination UDP port
d - p_buf: Buffer pointer, point to buffer started with ENVELOP
e - dw_len: buffer length, for length check
** Output results description:
a - OK, send packet success
b - ERROR, send packet failure
** function description:
Called by High Layer program. Send a UDP packet to the IP
address specified.
*******************************************************************************/
STATUS bs_udp_send_packet(int i_sock_fd, DWORD dw_dest_ip, WORD w_dst_udp_port, BYTE * p_buf, DWORD dw_len)
{
	int    i_send_len;

	XTRACE2(bs_udp_trace_id,2,"bs_udp_send_packet->dstIp 0x%lx, dstPort %d\n",dw_dest_ip,w_dst_udp_port);
	XDUMP(bs_udp_trace_id, 1, p_buf, dw_len);
	
	i_send_len = xSockSendTo(i_sock_fd, 
		(char * )p_buf, 
		dw_len,
		dw_dest_ip,
		w_dst_udp_port);
	
    if (i_send_len != (int)dw_len)
    {
        bs_log_err( "xSockSendTo error, dest IP 0x%lx, dest port %d.\n", dw_dest_ip, w_dst_udp_port);
        return ERROR;
    }
	
    return OK;
}

/*******************************************************************************
** Function Name: bs_r64_msg_send
** Input parameters description:
a - i_sock_fd: socket to send
b - dw_dest_ip: Destination IP address
c - w_dst_udp_port: Destination UDP port
d - p_buf: Buffer pointer, point to buffer started with ENVELOP
e - dw_len: buffer length, for length check
** Output results description:
a - OK, send packet success
b - ERROR, send packet failure
** function description:
Called by High Layer program. Send a UDP packet to the IP
address specified.
*******************************************************************************/

STATUS bs_r6_msg_send(R64_MSG_S * msg)
{
	int i_send_len;
	UDP_MSG_S udp_msg;
	memset(&udp_msg,0,sizeof(UDP_MSG_S));

	r64_print_msg(msg);

	if(ERROR==r64_encode_msg(&udp_msg, msg))
	{
		bs_log_err("fail to encode the message");
		return ERROR;
	}

	if(ERROR==bs_udp_send_packet(ga_bs_udp_cb[BS_R6_UDP_PORT_ID].i_sock_fd, msg->msgHead.destinationIp, msg->msgHead.destinationUdpPort, udp_msg.data,udp_msg.dataLen))
	{
		bs_log_err("bs_r6_msg_send returned error");
		return ERROR;
	
	}

	if(ERROR==bs_udp_send_packet(g_host_sock_fd, gHostIp, HOST_BS_UDP_PORT, udp_msg.data,udp_msg.dataLen))
	{
		bs_log_err("send  bs message to host returned error");
		return ERROR;
	
	}

	return OK;
	

}

/*******************************************************************************
** Function Name: bs_udp_recv
** Input parameters description:
a - None
** Output results description:
a - None
** function description:
Udp Task entry.
*******************************************************************************/
void bs_udp_recv()
{
	
	int                 			i_recv_len;
	UDP_MSG_S          	st_udp_msg;
	GW_UP_DHCP_MSG	st_dhcp_msg;
	BS_ACTION_MSG_S	st_action_msg;
	int					i=0;
	fd_set 				st_read_fds;
	int 				 	num_fds=0;
	int					count;
	DWORD 				from_ip;
	WORD				from_port;
	
	for (i=0; i<BS_MAX_UDP_ID; i++)
	{
		num_fds=num_fds<(ga_bs_udp_cb[i].i_sock_fd+1)?(ga_bs_udp_cb[i].i_sock_fd+1):num_fds;
	}
	
	
    	while(1)
    	{
		FD_ZERO (&st_read_fds);
		
		for (i=0; i<BS_MAX_UDP_ID; i++)
		{
			FD_SET (ga_bs_udp_cb[i].i_sock_fd, &st_read_fds);
		}

		XTRACE0(bs_udp_trace_id,2,"select began");		

		count = select (num_fds, &st_read_fds, NULL, NULL, NULL);

		XTRACE0(bs_udp_trace_id,2,"select returned");		
		
		if (count <= 0)
		{
			bs_log_err("select returned error");
			break;
		}

		XTRACE0(bs_udp_trace_id,2,"a socket is ready to be received");
		
		/*recv bs udp message*/
		if (FD_ISSET(ga_bs_udp_cb[BS_R6_UDP_PORT_ID].i_sock_fd, &st_read_fds))
		{
			memset(st_udp_msg.data,0,sizeof(st_udp_msg.data));
			if ((i_recv_len = xSockRecvFrom(ga_bs_udp_cb[BS_R6_UDP_PORT_ID].i_sock_fd,  
				(char *)st_udp_msg.data, 
				MAX_UDP_BUF_LEN,
				&from_ip,
				&from_port))<0)
			{
				
				bs_log_err("recvfrom return error");
				
			}
			else
			{
				XTRACE4(bs_udp_trace_id,2,"socket(%d) received %d bytes from ip 0x%lx port %d",i,i_recv_len,from_ip,from_port);

				XDUMP(bs_udp_trace_id,1,st_udp_msg.data,i_recv_len);
				
				/* fill the header */
				st_udp_msg.env.protocolSap = BS_UDP_SAP;
				st_udp_msg.env.msgType = 0;
				st_udp_msg.env.MessageLength = i_recv_len + UDP_HEADER_LEN;
				
				st_udp_msg.dataLen = i_recv_len;
				st_udp_msg.srcIp = from_ip;
				st_udp_msg.srcUdpPort = from_port;
				
				st_udp_msg.destIp= ga_bs_udp_cb[BS_R6_UDP_PORT_ID].dw_src_ip;
				st_udp_msg.destUdpPort = ga_bs_udp_cb[BS_R6_UDP_PORT_ID].w_src_udp_port;


				/* send the message to bs_cp task */
				if (ERROR == msgQSend(g_msgq_bscp, (char *)&st_udp_msg, st_udp_msg.env.MessageLength, NO_WAIT, MSG_PRI_NORMAL))
				{
					bs_log_err(" msgQSend returned error");
				}
				XTRACE4(bs_udp_trace_id,2,"send to msgq,from ip 0x%lx port %d, to us ip 0x%lx port %d",from_ip,from_port,st_udp_msg.destIp,st_udp_msg.destUdpPort);
				XDUMP(bs_udp_trace_id,1,(char *)&st_udp_msg,st_udp_msg.env.MessageLength);
			}
		}	

		/* recv dhcp message*/
		if (FD_ISSET(ga_bs_udp_cb[DHCP_UDP_PORT_ID].i_sock_fd, &st_read_fds))
		{
			memset(st_dhcp_msg.pktBuf,0,sizeof(st_dhcp_msg.pktBuf));
			if ((i_recv_len = xSockRecvFrom(ga_bs_udp_cb[DHCP_UDP_PORT_ID].i_sock_fd,  
				(char *)st_dhcp_msg.pktBuf, 
				MAX_UDP_BUF_LEN,
				&from_ip,
				&from_port))<0)
			{				
				bs_log_err("recvfrom return error");				
			}
			else
			{
				XTRACE4(bs_udp_trace_id,2,"socket(%d) received %d bytes from ip 0x%lx port %d",i,i_recv_len,from_ip,from_port);

				XDUMP(bs_udp_trace_id,1,st_dhcp_msg.pktBuf,i_recv_len);

				st_dhcp_msg.stEnv.protocolSap = BS_UDP_DHCP_SAP;
				st_dhcp_msg.stEnv.msgType = 0;
				/*st_dhcp_msg.stEnv.MessageLength = i_recv_len + sizeof(st_dhcp_msg.stEnv) + sizeof(st_dhcp_msg.macAddr) 
					+ sizeof(st_dhcp_msg.gwupInternalId) + sizeof(st_dhcp_msg.pktLen);*/

				st_dhcp_msg.stEnv.MessageLength = i_recv_len + OFFSET(GW_UP_DHCP_MSG,pktBuf[0]);
				
				st_dhcp_msg.pktLen = i_recv_len;

				/* send the message to dhcp task */
				if (ERROR == msgQSend(gDhcpClientMsgQId, (char *)&st_dhcp_msg,st_dhcp_msg.stEnv.MessageLength, NO_WAIT, MSG_PRI_NORMAL))
				{
					bs_log_err(" msgQSend returned error");
				}
				
			}
		}
		
		/*recv action udp message*/
		if (FD_ISSET(ga_bs_udp_cb[ACTION_UDP_PORT_ID].i_sock_fd, &st_read_fds))
		{
			memset(st_action_msg.data,0,sizeof(st_action_msg.data));
			if ((i_recv_len = xSockRecvFrom(ga_bs_udp_cb[ACTION_UDP_PORT_ID].i_sock_fd,  
				(char *)st_action_msg.data, 
				MAX_UDP_BUF_LEN,
				&from_ip,
				&from_port))<0)
			{
				
				bs_log_err("recvfrom return error");
				
			}
			else
			{
				XTRACE2(bs_udp_trace_id,2,"socket(%d) received %d bytes",i,i_recv_len);

				XDUMP(bs_udp_trace_id,1,st_action_msg.data,i_recv_len);
				/* fill the header */
				st_action_msg.env.protocolSap = BS_ACTION_SAP;
				st_action_msg.env.msgType = 0;
				st_action_msg.env.MessageLength = i_recv_len + sizeof(ENVELOP);

				/* send the message to bs_cp task */
				if (ERROR == msgQSend(g_msgq_bscp, (char *)&st_action_msg, st_action_msg.env.MessageLength, NO_WAIT, MSG_PRI_NORMAL))
				{
					bs_log_err(" msgQSend returned error");
				}
				
			}
		}
		
	}
    
    bs_log_err("the UDP task terminated");
}