tcp__sub.c

基于vxworks操作系统的电话语音平台系统

#include "pub\pub_incl.h"
#include "pub\pub_defi.h"
#include "pub\modulers.h"
#include "pub\pub__msg.h"
#include "pub\modulers.h"
#include "rtos\vxworks\tcpip\net_proc.h"


extern VOID TcpNetManSendMsgToDPC( US len, VOID *data );

extern BOOL TcpSendMsuToLocalManager(int port_num,int sFd,  UI len, VOID*buffer );
extern BOOL TcpIsThePacketToLocalNetManager(UI len, VOID* buffer);
extern BOOL TcpSendMsuToRemoteManager(UI len, VOID*buffer );


VOID tcpServerRecvTask( UC i );

TCPIP_SERVER_FSM	ServerFsm;
devtimer_handle		NetCtrlT0handle;

UC			NetMsgHeadFlag[Flag_Len];
UC			NetLinkCot;
STATIC BOOL		InitTimerComplete=FALSE;

UL			sta_TcpRecv=0;
UL			sta_TcpSend=0;
UC			nconn=0;
/*----------------------------------------------*/
/*				 Send Msg part					*/
/*----------------------------------------------*/
STATIC VOID InitOneServerFsm( US port_num )
{
	ServerFsm[port_num].State = INVALID_SOCKET;
	ServerFsm[port_num].Socket = -1;	

	ServerFsm[port_num].ResemblePos = 0;

	memset(ServerFsm[port_num].ResembleBuf, 0, MAX_RESEMBLE_LEN);
}

INT GetTcpCurrentSocketIdFromPortNum( US port_num )
{
	return ServerFsm[port_num].Socket;
}

STATIC VOID StopAllServerTimer( UI port_num )
{
	if( InitTimerComplete == TRUE )
		Stop_Devtimer((devtimer_CB *)NetCtrlT0handle, port_num);
}

VOID ClearOneServerFsm( US port_num )	
{
	INT Socketd;

	Socketd = ServerFsm[port_num].Socket;
	if( Socketd >= 0 )
		close( Socketd );

	if( nconn>0 )
		nconn--;

	StopAllServerTimer( port_num );
	InitOneServerFsm( port_num );
	/*SHOWPrintf("clear on server %d\n",port_num);*/
}

STATIC VOID SocketErrorHdl( US port_num )
{
	/* report comm information */

	ClientClose( port_num );
}

VOID ServerTimerOut( UI port_num, UC timer_name )
{
	SocketErrorHdl( port_num );
}

BOOL InitServerFsmTimer( VOID )
{
	NetCtrlT0handle = Init_Devtimer(MAX_CLIENT_NUM, ServerTimerOut );
	return TRUE;
}

VOID TrigServerFsmTimer( VOID )
{
	if( InitTimerComplete == TRUE )
		Trig_Devtimer( (devtimer_CB *)NetCtrlT0handle );
}

STATIC VOID InserviceServerFsm( US port_num, INT newsocket )
{
	/* Update ServerFsm */
	ServerFsm[port_num].State = IN_SERVICE_SOCKET;
	ServerFsm[port_num].Socket = newsocket;

	/* start timer */
	Stop_Devtimer((devtimer_CB *)NetCtrlT0handle, port_num);
	Start_Devtimer((devtimer_CB *)NetCtrlT0handle, port_num, NET_CTRL_TIMER0_LEN, NET_CTRL_TIMER0_NAME);
}

BOOL  GetFreeServerPort(US *port_num)
{
	UI i;

	for (i = 0; i < MAX_CLIENT_NUM; i++)
	{
		if (ServerFsm[i].State == INVALID_SOCKET)
		{
			*port_num = i;

			return TRUE;
		}
	}

	return FALSE;
}

STATIC VOID NetBufferDispatch( US port_num, VOID *buffer, UI length )
{
	if( length >= MAX_MSG_LEN )
		return;

	TcpNetManSendMsgToDPC( length, buffer );

	/* restart timer */
	Start_Devtimer((devtimer_CB *)NetCtrlT0handle,port_num,NET_CTRL_TIMER0_LEN,NET_CTRL_TIMER0_NAME);
}

STATIC VOID  ReCombine( US port_num, UC * RecvBuf, US RecvLen )
{
	US  ResemblePos, PacketLen, DataLen;
	UC  *ResembleBuf;
	US  TotalLen,i;
	INT Res;

	ResemblePos = ServerFsm[port_num].ResemblePos;		
	ResembleBuf = ServerFsm[port_num].ResembleBuf;		

	TotalLen = ResemblePos + RecvLen;

	if( TotalLen > MAX_RESEMBLE_LEN )
	{
		return;
	}
	else if ( (0 != RecvLen) && (NULL != RecvBuf) )
	{
		memcpy(ResembleBuf + ResemblePos, RecvBuf, RecvLen); /* combine buf */
	}

	if (TotalLen <= TRANS_DATA_HEADER_LEN)
	{
		BYPrintf("NET DATA length too short");

		ServerFsm[0].ResemblePos = TotalLen;

		return;
	}

	PacketLen = 0;

	for (i = 0; i <= (TotalLen - TRANS_DATA_HEADER_LEN); i++)
	{
		Res = memcmp(ResembleBuf + i, NetMsgHeadFlag, Flag_Len);

		if ( Res == 0 )
		{
			DataLen = (ResembleBuf[TRANS_DATA_DLEN_POS + i] << 8)
				+ ResembleBuf[TRANS_DATA_DLEN_POS + i + 1];
			PacketLen += (TRANS_DATA_HEADER_LEN + DataLen);

			if ((TotalLen - i) >= PacketLen)
			{
				NetBufferDispatch(port_num, ResembleBuf + i + Flag_Len, PacketLen - Flag_Len);
				i += (PacketLen - 1);
				PacketLen = 0;
				sta_TcpRecv++;
			}
			else
			{
				break;
			}
		}
	}

	ServerFsm[port_num].ResemblePos = TotalLen-i;
	memcpy(ResembleBuf, ResembleBuf+i, TotalLen-i);
}

VOID InitServerFsm( VOID )
{
	US  i;

	NetLinkCot = INVALID_VALUE;

	NetMsgHeadFlag[0] = 0x55;
	NetMsgHeadFlag[1] = 0xAA;
	NetMsgHeadFlag[2] = 0x55;	
	
	for(i=0;i<MAX_CLIENT_NUM;i++)
		InitOneServerFsm(i);

	if( InitServerFsmTimer() == TRUE )
		InitTimerComplete = TRUE;
}

VOID NewClientHdl( int newsocket, struct sockaddr_in clientAddr )
{
	US port_num;
	char taskname[32];

	if (GetFreeServerPort(&port_num)==TRUE)
	{
		ClearOneServerFsm(port_num);
		InserviceServerFsm( port_num, newsocket );
		sprintf( taskname, "tNetRecv%d", port_num );
		nconn++;
		taskSpawn( taskname, 130,/*TCPRx_PRI,*/ 0, 4096 * 10, (FUNCPTR)tcpServerRecvTask,
			port_num, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	}
	else
	{
		close(newsocket);
	}
}

BOOL IsThereValidSocket( US port_num )
{
	if( ServerFsm[port_num].State==INVALID_SOCKET )
		return FALSE;

	return TRUE;
}

/*-------------------------------------*/
/*			Tcpip sub function         */
/*-------------------------------------*/
STATUS channel_open_as_server( int *Socket )
{
	struct sockaddr_in  serverAddr;    /* server's socket address */
	int                 sockAddrSize;  /* size of socket address structure */
	int                 sFd;           /* socket file descriptor */

	/* set up the local address */
	sockAddrSize = sizeof (struct sockaddr_in);
	bzero ((char *) &serverAddr, sockAddrSize);

	serverAddr.sin_family = AF_INET;
	serverAddr.sin_port = htons (SERVER_PORT_NUM);
	serverAddr.sin_addr.s_addr = htonl (INADDR_ANY);

	*Socket = -1;

	/* create a TCP-based socket */
	if ((sFd = socket (AF_INET, SOCK_STREAM, 0)) == ERROR)
	{
		return (ERROR);
	}

	/* bind socket to local address */
	if( bind(sFd, (struct sockaddr *) &serverAddr, sockAddrSize) == ERROR)
	{
		close (sFd);
		return (ERROR);
	}

	/* Create queue for client connection requests */
	if (listen (sFd, SERVER_MAX_CONNECTIONS) == ERROR)
	{
		close (sFd);
		return (ERROR);
	}

	*Socket = sFd;
	return OK;
}

VOID TcpipSendRecvHdl( US port_num )
{
}

/*
extern BOOL TcpIsThePacketToLocalNetManager(UI len, VOID* buffer)
extern BOOL TcpSendMsuToLocalManager(int sFd,  UI len, VOID*buffer )
extern BOOL TcpSendMsuToRemoteManager(UI len, VOID*buffer )
*/
VOID tcpServerSendHandle(VOID)
{
	int len, sFd;
	UC buffer[1600];
	UI i;

	if (((len = msgQReceive(NetManCenter_Q_ID, buffer, MAX_MSG_LEN, WAIT_FOREVER)) > 0)
		&& (len < MAX_MSG_LEN))
	{
		if ( TcpIsThePacketToLocalNetManager(len, buffer)==TRUE )
		{
			for (i = 0; i < MAX_CLIENT_NUM; i++)
			{
				if (ServerFsm[i].State != IN_SERVICE_SOCKET)
					continue;

				if ((sFd = GetTcpCurrentSocketIdFromPortNum(i)) > 0)
				{
					TcpSendMsuToLocalManager(i, sFd, len, buffer);
					sta_TcpSend++;
				}
			}
		}
		else
		{
			TcpSendMsuToRemoteManager(len, buffer );
		}
	}
}

VOID tcpServerRecvTask( UC i )
{
	int nRead;
	int sFd;
	UC buffer[1600];

	if( ServerFsm[i].State != IN_SERVICE_SOCKET )		
		return;

	sFd = GetTcpCurrentSocketIdFromPortNum(i);

	if( sFd < 0 )
	{
		ClientClose(i);
		return;
	}

	while ( (nRead = recv( sFd, buffer, 1600, 0) ) > 0  )
	{
		{
			ReCombine( i, buffer, nRead );

			Stop_Devtimer((devtimer_CB *)NetCtrlT0handle, i);
			Start_Devtimer((devtimer_CB *)NetCtrlT0handle, i, NET_CTRL_TIMER0_LEN, NET_CTRL_TIMER0_NAME);
		}

		taskDelay(0);
	}		

	ClientClose(i);
}