tcp.i

cs8900 c51应用

#line 1 "..\tcp.c" /0



















































 
 





























 
 
 
#error *** WARNING C318 IN LINE 85 OF ..\tcp.c: can't open file 'inet/debug.h'
 
#error *** WARNING C318 IN LINE 86 OF ..\tcp.c: can't open file 'inet/datatypes.h'
 
#error *** WARNING C318 IN LINE 87 OF ..\tcp.c: can't open file 'inet/timers.h'
 
#error *** WARNING C318 IN LINE 88 OF ..\tcp.c: can't open file 'inet/ethernet.h'
 
#error *** WARNING C318 IN LINE 89 OF ..\tcp.c: can't open file 'inet/ip.h'
 
#error *** WARNING C318 IN LINE 90 OF ..\tcp.c: can't open file 'inet/tcp_ip.h'
 
#error *** WARNING C318 IN LINE 91 OF ..\tcp.c: can't open file 'inet/system.h'
 








 
 struct tcp_frame received_tcp_packet;
 













 
 struct tcb tcp_socket[NO_OF_TCPSOCKETS + 1]; 
 
 UINT8 tcp_tempbuf[MIN_TCP_HLEN + 1];  
 
 
 
 
 
 



























 
 INT8 tcp_getsocket (UINT8 soctype, UINT8 tos, UINT16 tout, INT32 (*listener)(INT8, UINT8, UINT32, UINT32) reentrant)
 {
 INT8 i;
 struct tcb* soc;
 
 if( NO_OF_TCPSOCKETS < 0 )
 return(-1);
 
 if( NO_OF_TCPSOCKETS == 0 )
 return(-1);
 
 if( (soctype != TCP_TYPE_SERVER) &&
 (soctype != TCP_TYPE_CLIENT) &&
 (soctype != TCP_TYPE_CLIENT_SERVER) &&
 (soctype != TCP_TYPE_NONE)				) {
 TCP_DEBUGOUT("Invalid socket type requested\r\n");
 return(-1);
 }
 
 if(listener == 0) {
 TCP_DEBUGOUT("ERROR:Event listener function not specified\r\n");
 return(-1);
 }
 
 TCP_DEBUGOUT("Searching for free TCP socket...\r\n");
 
 for(i=0; i < NO_OF_TCPSOCKETS; i++)	{
 soc = &tcp_socket[i];			 
 
 if(soc->state == TCP_STATE_FREE) {
 
 
 TCP_DEBUGOUT("Free socket found\r\n");
 
 soc->state = TCP_STATE_RESERVED;
 soc->type = soctype;
 soc->tos = tos;
 soc->event_listener = listener;
 soc->rem_ip = 0;
 soc->remport = 0;
 soc->locport = 0;
 soc->flags = 0;
 soc->tout = tout*TIMERTIC;
 
 return(i);
 }
 
 }
 
 
 
 TCP_DEBUGOUT("No socket found\r\n");
 return(-1);
 
 }
 
















 
 INT8 tcp_releasesocket (INT8 sochandle)
 {
 struct tcb* soc;
 
 if( NO_OF_TCPSOCKETS < 0 )
 return(-1);
 
 if( NO_OF_TCPSOCKETS == 0 )
 return(-1);
 
 if( sochandle > NO_OF_TCPSOCKETS ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 if( sochandle < 0 ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 soc = &tcp_socket[sochandle];		 
 
 if( (soc->state != TCP_STATE_FREE) &&
 (soc->state != TCP_STATE_RESERVED) &&
 (soc->state != TCP_STATE_CLOSED)		) {
 TCP_DEBUGOUT("Socket is not on valid state to be released\r\n");
 return(-1);
 }
 
 
 
 soc->state = TCP_STATE_FREE;
 soc->type = TCP_TYPE_NONE;
 soc->tos = 0;
 soc->event_listener = 0;
 soc->rem_ip = 0;
 soc->remport = 0;
 soc->locport = 0;
 soc->flags = 0;
 
 return(sochandle);
 
 }
 

















 
 INT8 tcp_listen (INT8 sochandle, UINT16 port)
 {
 struct tcb* soc;
 
 if( NO_OF_TCPSOCKETS < 0 )
 return(-1);
 
 if( NO_OF_TCPSOCKETS == 0 )
 return(-1);
 
 if( sochandle > NO_OF_TCPSOCKETS ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 if( sochandle < 0 ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 soc = &tcp_socket[sochandle];		 
 
 if( (soc->type & TCP_TYPE_SERVER) == 0 ) {
 TCP_DEBUGOUT("Socket has no server properties\r\n");
 return(-1);
 }
 
 if( soc->event_listener == 0) {
 TCP_DEBUGOUT("ERROR:No event listener function specified\r\n");
 return(-1);
 }
 
 
 if( (soc->state != TCP_STATE_RESERVED) &&
 (soc->state != TCP_STATE_LISTENING)	&&
 (soc->state != TCP_STATE_CLOSED) &&		
 (soc->state != TCP_STATE_TIMED_WAIT)		) {
 TCP_DEBUGOUT("Not possible to listen, socket on connected state\r\n");
 return(-1);
 
 }
 
 
 
 
 soc->state = TCP_STATE_LISTENING;
 
 soc->flags = 0;
 soc->rem_ip = 0;
 soc->remport = 0;
 soc->locport = port;
 soc->send_unacked = 0;
 soc->myflags = 0;
 soc->send_next = 0xFFFFFFFF;
 soc->send_mtu = TCP_DEF_MTU;
 soc->receive_next = 0;
 soc->retries_left = 0;
 
 TCP_DEBUGOUT("TCP listening socket created\r\n");
 
 return(sochandle);
 
 }
 
 





















 
 INT8 tcp_connect (INT8 sochandle, UINT32 ip, UINT16 rport, UINT16 myport )
 {
 struct tcb* soc;
 
 TCP_DEBUGOUT("FUNCTION: tcp_connect\r\n");
 
 if( NO_OF_TCPSOCKETS < 0 )
 return(-1);
 
 if( NO_OF_TCPSOCKETS == 0 )
 return(-1);
 
 if( sochandle > NO_OF_TCPSOCKETS ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 if( sochandle < 0 ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 
 
 if( myport == 0 )
 myport = tcp_getfreeport();
 
 if( myport == 0 )
 return(-1);
 
 soc = &tcp_socket[sochandle];		 
 
 
 
 if( (soc->type & TCP_TYPE_CLIENT) == 0 ) {
 TCP_DEBUGOUT("Socket has no client properties\r\n");
 return(-1);
 }
 
 if( soc->event_listener == 0) {
 TCP_DEBUGOUT("ERROR:No event listener function specified\r\n");
 return(-1);
 }
 
 
 
 if( (soc->state != TCP_STATE_RESERVED) &&
 (soc->state != TCP_STATE_LISTENING) &&
 (soc->state != TCP_STATE_CLOSED)		) {
 TCP_DEBUGOUT("Socket on unvalid state to initialize CONNECT\r\n");
 return(-1);
 }
 
 
 
 soc->rem_ip = ip;
 soc->remport = rport;
 soc->locport = myport;
 soc->flags = 0;
 soc->send_mtu = TCP_DEF_MTU;
 
 
 
 soc->send_unacked = tcp_initseq(); 
 soc->send_next = soc->send_unacked + 1;
 soc->myflags = TCP_FLAG_SYN;
 tcp_sendcontrol(sochandle);
 tcp_newstate(soc, TCP_STATE_SYN_SENT);
 
 return(sochandle);
 }
 
 
 





























 
 INT16 tcp_send (INT8 sockethandle, UINT8* buf, UINT16 blen, UINT16 dlen)
 {
 struct tcb* soc;
 UINT8 i;
 
 
 TCP_DEBUGOUT("Entering to send TCP data packet\r\n");
 
 kick_WD();
 
 if( sockethandle < 0 ) {
 TCP_DEBUGOUT("ERROR:Socket Handle not valid (<0)\r\n");
 return(-1);
 }
 
 if( sockethandle > NO_OF_TCPSOCKETS ) {
 TCP_DEBUGOUT("ERROR:Socket Handle not valid (>NO_OF_TCPSOCKETS)\r\n");
 return(-1);
 }
 
 soc = &tcp_socket[sockethandle];				 
 
 if(soc->state != TCP_STATE_CONNECTED) {
 TCP_DEBUGOUT("TCP is not connected!!\r\n");
 return(-1);
 }
 
 if(soc->send_unacked != soc->send_next) {
 TCP_DEBUGOUT("TCP contains unacked data, cannot send more\r\n");
 return(-1);
 }
 
 if( dlen > blen )
 dlen = blen;
 
 if(dlen + MIN_TCP_HLEN > soc->send_mtu) {
 if(soc->send_mtu > MIN_TCP_HLEN)
 dlen = soc->send_mtu - MIN_TCP_HLEN;
 else
 return(-1);
 }
 
 soc->send_next += dlen;
 
 soc->myflags = TCP_FLAG_ACK | TCP_FLAG_PUSH;
 process_tcp_out(sockethandle, buf - MIN_TCP_HLEN, blen + MIN_TCP_HLEN + 1, dlen);
 
 return(dlen);
 }
 
 
















 
 INT8 tcp_close (INT8 sochandle)
 {
 struct tcb* soc;
 
 TCP_DEBUGOUT("FUNCTION: tcp_close\r\n");
 
 if( NO_OF_TCPSOCKETS < 0 )
 return(-1);
 
 if( NO_OF_TCPSOCKETS == 0 )
 return(-1);
 
 if( sochandle > NO_OF_TCPSOCKETS ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 if( sochandle < 0 ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 soc = &tcp_socket[sochandle];		 
 
 switch(soc->state) {
 case TCP_STATE_LISTENING:
 tcp_newstate(soc, TCP_STATE_CLOSED);
 break;
 
 case TCP_STATE_SYN_RECEIVED:
 soc->myflags = TCP_FLAG_ACK | TCP_FLAG_FIN;
 soc->send_unacked++;
 soc->send_next++;
 tcp_sendcontrol(sochandle);
 tcp_newstate(soc, TCP_STATE_FINW1);
 break;
 
 case TCP_STATE_SYN_SENT:
 
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 break;
 
 case TCP_STATE_FINW1:
 case TCP_STATE_FINW2:
 case TCP_STATE_CLOSING:
 case TCP_STATE_TIMED_WAIT:
 case TCP_STATE_LAST_ACK:
 
 
 
 break;
 
 case TCP_STATE_CONNECTED:
 
 
 
 if(soc->send_unacked == soc->send_next ) {
 
 
 soc->myflags = TCP_FLAG_ACK | TCP_FLAG_FIN;
 soc->send_next++;
 tcp_sendcontrol(sochandle);
 tcp_newstate(soc, TCP_STATE_FINW1);				
 } else {
 
 
 
 soc->flags |= TCP_INTFLAGS_CLOSEPENDING;
 
 
 return(sochandle);
 }
 
 break;
 
 default:
 return(-1);
 }
 
 return(sochandle);
 
 }
 
 
 












 
 INT8 tcp_getstate (INT8 sochandle)
 {
 struct tcb* soc;
 
 if( NO_OF_TCPSOCKETS < 0 )
 return(-1);
 
 if( NO_OF_TCPSOCKETS == 0 )
 return(-1);
 
 if( sochandle > NO_OF_TCPSOCKETS ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 if( sochandle < 0 ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 soc = &tcp_socket[sochandle];		 
 
 return(soc->state);
 
 }
 
 














 
 INT16 tcp_checksend (INT8 sochandle)
 {
 struct tcb* soc;
 
 if( NO_OF_TCPSOCKETS < 0 )
 return(-1);
 
 if( NO_OF_TCPSOCKETS == 0 )
 return(-1);
 
 if( sochandle > NO_OF_TCPSOCKETS ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 soc = &tcp_socket[sochandle];		 
 
 if(soc->state != TCP_STATE_CONNECTED)
 return(-1);
 
 if(soc->send_unacked == soc->send_next)
 return(soc->send_mtu);
 
 return(-1);
 
 
 }
 
 
 















 
 INT8 tcp_abort (INT8 sochandle)
 {
 struct tcb* soc;
 
 TCP_DEBUGOUT("FUNCTION: tcp_abort\r\n");
 
 if( NO_OF_TCPSOCKETS < 0 )
 return(-1);
 
 if( NO_OF_TCPSOCKETS == 0 )
 return(-1);
 
 if( sochandle > NO_OF_TCPSOCKETS ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 if( sochandle < 0 ) {
 TCP_DEBUGOUT("Socket handle non-valid\r\n");
 return(-1);
 }
 
 soc = &tcp_socket[sochandle];		 
 
 switch (soc->state)	{
 case TCP_STATE_FREE:
 return(-1);
 
 case TCP_STATE_RESERVED:
 case TCP_STATE_CLOSED:
 return(sochandle);
 
 case TCP_STATE_TIMED_WAIT:
 case TCP_STATE_LISTENING:
 tcp_newstate(soc, TCP_STATE_CLOSED);
 return(sochandle);
 
 case TCP_STATE_SYN_SENT:
 case TCP_STATE_SYN_RECEIVED:
 case TCP_STATE_CONNECTED:
 case TCP_STATE_FINW1:
 case TCP_STATE_FINW2:
 case TCP_STATE_CLOSING:
 case TCP_STATE_LAST_ACK:
 
 soc->myflags = TCP_FLAG_RESET;
 tcp_sendcontrol(sochandle);
 tcp_newstate(soc, TCP_STATE_CLOSED);
 return(sochandle);
 
 default:
 return(-1);
 }
 
 
 }
 
 
 












 
 void tcp_poll (void)
 {
 struct tcb* soc;
 static UINT8 handle = 0;
 UINT8 i;
 INT32 temp;
 UINT8 old_retries;
 
 for(i=0; i < NO_OF_TCPSOCKETS; i++ ) {
 
 if(handle > NO_OF_TCPSOCKETS)
 handle = 0;
 
 soc = &tcp_socket[handle];
 
 switch(soc->state) {
 case TCP_STATE_FREE:
 case TCP_STATE_RESERVED:
 case TCP_STATE_CLOSED:
 case TCP_STATE_LISTENING:
 
 break;
 
 case TCP_STATE_CONNECTED:
 
 
 
 
 
 




 
 
 temp = soc->send_next - soc->send_unacked;
 
 
 
 if(soc->flags & TCP_INTFLAGS_CLOSEPENDING) {
 
 
 if(temp == 0) {
 soc->myflags = TCP_FLAG_ACK | TCP_FLAG_FIN;
 soc->send_next++;
 tcp_sendcontrol(handle);
 tcp_newstate(soc, TCP_STATE_FINW1);	
 soc->flags ^= TCP_INTFLAGS_CLOSEPENDING;
 
 handle++;
 
 return;		
 
 }
 }