tcp.i

cs8900 c51应用

 
 }
 
 
 
 if(received_tcp_packet.hlen_flags & TCP_FLAG_SYN) {
 TCP_DEBUGOUT("Simultaneous open, next SYN_RECEIVED\r\n");
 
 
 
 soc->receive_next =  received_tcp_packet.seqno;
 soc->receive_next++;							 
 
 tcp_newstate(soc, TCP_STATE_SYN_RECEIVED);
 soc->myflags = TCP_FLAG_SYN | TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);
 
 return(0);
 
 }
 
 
 
 TCP_DEBUGOUT("TCP packet out of nowhere received...\r\n");
 tcp_sendreset(&received_tcp_packet, frame->sip);
 
 return(-1);
 
 break;
 
 case TCP_STATE_FINW1:
 
 TCP_DEBUGOUT("FINW1 State\r\n");
 
 
 
 if(received_tcp_packet.hlen_flags & TCP_FLAG_RESET) {
 TCP_DEBUGOUT("ERROR:Reset received\r\n");
 
 
 
 soc->event_listener(sochandle, TCP_EVENT_ABORT, soc->rem_ip, soc->remport);
 
 if(soc->type & TCP_TYPE_SERVER)
 tcp_newstate(soc, TCP_STATE_LISTENING);
 else
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 return(-1);
 }
 
 
 
 if( (received_tcp_packet.hlen_flags & TCP_FLAG_FIN) &&
 (received_tcp_packet.hlen_flags & TCP_FLAG_ACK)	) {
 
 
 if( received_tcp_packet.ackno != soc->send_next ) {
 TCP_DEBUGOUT("FIN+ACK received but wrong Ack\n\r");
 return(-1);
 }
 
 TCP_DEBUGOUT("FIN+ACK received, next TIMED_WAIT\n\r");
 
 
 
 soc->receive_next = received_tcp_packet.seqno;
 soc->receive_next++;
 soc->receive_next += dlen;
 
 
 
 soc->send_unacked = soc->send_next;
 
 tcp_newstate(soc, TCP_STATE_TIMED_WAIT);
 soc->myflags = TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);
 
 return(0);
 
 }
 
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_FIN	) {
 
 TCP_DEBUGOUT("Simultaneous close, next CLOSING\n\r");
 
 
 
 soc->receive_next = received_tcp_packet.seqno;
 soc->receive_next++;
 soc->receive_next += dlen;
 
 tcp_newstate(soc, TCP_STATE_CLOSING);
 soc->myflags = TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);			
 return(0);
 
 }			
 
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_ACK	) {
 
 
 if( received_tcp_packet.ackno != soc->send_next ) {
 TCP_DEBUGOUT("ACK received but wrong Ack\n\r");
 return(-1);
 }
 
 TCP_DEBUGOUT("Our FIN is ACKed but peer don't agree to disconnect yet\r\n");
 TCP_DEBUGOUT("Next FINW2\r\n");
 
 
 
 soc->send_unacked = soc->send_next;
 
 tcp_newstate(soc, TCP_STATE_FINW2);
 
 return(0);
 
 }
 
 break;
 
 case TCP_STATE_FINW2:
 
 TCP_DEBUGOUT("FINW2 State\r\n");
 
 
 
 if(received_tcp_packet.hlen_flags & TCP_FLAG_RESET) {
 TCP_DEBUGOUT("ERROR:Reset received\r\n");
 
 
 
 soc->event_listener(sochandle, TCP_EVENT_ABORT, soc->rem_ip, soc->remport);				
 
 if(soc->type & TCP_TYPE_SERVER)
 tcp_newstate(soc, TCP_STATE_LISTENING);
 else
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 return(-1);
 }			
 
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_FIN	) {
 
 TCP_DEBUGOUT("FIN received, next TIMED_WAIT\n\r");
 
 
 
 soc->receive_next = received_tcp_packet.seqno;
 soc->receive_next++;
 soc->receive_next += dlen;
 
 tcp_newstate(soc, TCP_STATE_TIMED_WAIT);
 soc->myflags = TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);			
 return(0);
 
 }		
 
 break;
 
 case TCP_STATE_CLOSING:
 
 TCP_DEBUGOUT("CLOSING State...\r\n");
 
 
 
 if(received_tcp_packet.hlen_flags & TCP_FLAG_RESET)	{
 TCP_DEBUGOUT("ERROR:Reset received\r\n");
 
 
 
 soc->event_listener(sochandle, TCP_EVENT_ABORT, soc->rem_ip, soc->remport);				
 
 if(soc->type & TCP_TYPE_SERVER)
 tcp_newstate(soc, TCP_STATE_LISTENING);
 else
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 return(-1);
 }			
 
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_ACK	) {
 
 
 if( received_tcp_packet.ackno != soc->send_next ) {
 TCP_DEBUGOUT("ACK received but wrong Ack\n\r");
 return(-1);
 }
 
 TCP_DEBUGOUT("Our FIN is ACKed and peer wants to close too\r\n");
 TCP_DEBUGOUT("Next TIMED_WAIT\r\n");
 
 
 
 soc->send_unacked = soc->send_next;
 
 tcp_newstate(soc, TCP_STATE_TIMED_WAIT);
 
 return(0);
 
 }
 
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_FIN	) {
 
 TCP_DEBUGOUT("Repeated FIN, repeat ACK\n\r");
 
 
 
 soc->receive_next = received_tcp_packet.seqno;
 soc->receive_next++;
 soc->receive_next += dlen;
 
 soc->myflags = TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);			
 
 return(0);
 
 }
 
 
 break;
 
 case TCP_STATE_LAST_ACK:
 
 TCP_DEBUGOUT("LAST_ACK State...\r\n");
 
 
 
 if(received_tcp_packet.hlen_flags & TCP_FLAG_RESET) {
 TCP_DEBUGOUT("ERROR:Reset received\r\n");
 
 
 
 soc->event_listener(sochandle, TCP_EVENT_ABORT, soc->rem_ip, soc->remport);				
 
 if(soc->type & TCP_TYPE_SERVER)
 tcp_newstate(soc, TCP_STATE_LISTENING);
 else
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 return(-1);
 }			
 
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_ACK	) {
 
 
 if( received_tcp_packet.ackno != soc->send_next ) {
 TCP_DEBUGOUT("ACK received but wrong Ack\n\r");
 return(-1);
 }
 
 TCP_DEBUGOUT("Last ACK received, next LISTENING or CLOSED\r\n");
 
 
 
 soc->send_unacked = soc->send_next;				
 
 if(soc->type & TCP_TYPE_SERVER)
 tcp_newstate(soc, TCP_STATE_LISTENING);
 else
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 return(0);
 
 }			
 
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_FIN	) {
 
 TCP_DEBUGOUT("Repeated FIN, repeat ACK\n\r");
 
 
 
 soc->receive_next = received_tcp_packet.seqno;
 soc->receive_next++;
 soc->receive_next += dlen;
 
 soc->myflags = TCP_FLAG_FIN | TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);
 
 return(0);
 
 }			
 
 
 break;
 
 case TCP_STATE_TIMED_WAIT:
 
 TCP_DEBUGOUT("TIMED_WAIT State...\r\n");
 
 
 
 if(received_tcp_packet.hlen_flags & TCP_FLAG_RESET) {
 TCP_DEBUGOUT("ERROR:Reset received\r\n");
 
 
 
 soc->event_listener(sochandle, TCP_EVENT_ABORT, soc->rem_ip, soc->remport);				
 
 if(soc->type & TCP_TYPE_SERVER)
 tcp_newstate(soc, TCP_STATE_LISTENING);
 else
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 return(-1);
 }			
 
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_FIN	) {
 
 TCP_DEBUGOUT("Repeated FIN, repeat ACK\n\r");
 
 
 
 soc->receive_next = received_tcp_packet.seqno;
 soc->receive_next++;
 soc->receive_next += dlen;
 
 soc->myflags = TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);
 
 return(0);
 
 }
 
 
 
 break;
 
 
 default:
 
 TCP_DEBUGOUT("ERROR:TCP State machine in unknown state!!\r\n");
 
 tcp_sendreset(&received_tcp_packet, frame->sip);
 
 RESET_SYSTEM();
 
 }
 
 TCP_DEBUGOUT("Should not be there!\r\n");
 
 return(-1);
 
 }
 
 
















 
 INT16 process_tcp_out (INT8 sockethandle, UINT8* buf, UINT16 blen, UINT16 dlen)
 {
 struct tcb* soc;
 UINT16 cs;
 UINT8 cs_cnt;
 UINT16 i;
 UINT8* buf_start;
 
 TCP_DEBUGOUT("Entering to send TCP packet\r\n");
 
 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);
 }
 
 if( (dlen + MIN_TCP_HLEN) > blen ) {
 TCP_DEBUGOUT("ERROR:Transmit buffer too small for TCP header\r\n");
 return(-1);
 } 
 
 soc = &tcp_socket[sockethandle];				 
 
 buf_start = buf;
 
 if( (dlen + MIN_TCP_HLEN) > soc->send_mtu ) {
 TCP_DEBUGOUT("ERROR:Send MTU exceeded\r\n");
 return(-1);
 }
 
 
 
 *buf++ = (UINT8)(soc->locport >> 8);
 *buf++ = (UINT8)soc->locport;
 *buf++ = (UINT8)(soc->remport >> 8);
 *buf++ = (UINT8)soc->remport;
 *buf++ = (UINT8)(soc->send_unacked >>24);
 *buf++ = (UINT8)(soc->send_unacked >>16);
 *buf++ = (UINT8)(soc->send_unacked >>8);
 *buf++ = (UINT8)(soc->send_unacked);
 *buf++ = (UINT8)(soc->receive_next >>24);
 *buf++ = (UINT8)(soc->receive_next >>16);
 *buf++ = (UINT8)(soc->receive_next >>8);
 *buf++ = (UINT8)(soc->receive_next);
 *buf =	MIN_TCP_HLEN >> 2;
 *buf <<= 4;
 buf++;
 *buf++ = soc->myflags;
 *buf++ = (UINT8)(TCP_DEF_MTU >> 8);
 *buf++ = (UINT8)TCP_DEF_MTU;
 *buf++ = 0;								 
 *buf++ = 0;
 *buf++ = 0;								 
 *buf++ = 0;
 
 
 
 
 cs = 0;
 cs_cnt = 0;
 
 
 
 cs = ip_checksum(cs, (UINT8)(localmachine.localip >> 24), cs_cnt++);	
 cs = ip_checksum(cs, (UINT8)(localmachine.localip >> 16), cs_cnt++);
 cs = ip_checksum(cs, (UINT8)(localmachine.localip >> 8), cs_cnt++);
 cs = ip_checksum(cs, (UINT8)localmachine.localip, cs_cnt++);
 
 cs = ip_checksum(cs, (UINT8)(soc->rem_ip >> 24), cs_cnt++);	
 cs = ip_checksum(cs, (UINT8)(soc->rem_ip >> 16), cs_cnt++);
 cs = ip_checksum(cs, (UINT8)(soc->rem_ip >> 8), cs_cnt++);
 cs = ip_checksum(cs, (UINT8)soc->rem_ip, cs_cnt++);	
 
 cs = ip_checksum(cs, 0, cs_cnt++);
 
 cs = ip_checksum(cs, (UINT8)IP_TCP, cs_cnt++);
 
 cs = ip_checksum(cs, (UINT8)((dlen + MIN_TCP_HLEN) >> 8), cs_cnt++);
 cs = ip_checksum(cs, (UINT8)(dlen + MIN_TCP_HLEN), cs_cnt++);
 
 
 
 buf = buf_start;
 
 for(i=0; i < (dlen + MIN_TCP_HLEN); i++)
 cs = ip_checksum(cs, *buf++, cs_cnt++);
 
 cs = ~ cs;
 
 
#line 2213 "..\tcp.c" /1
 
 
 
 
 
 
 
 
#line 2221 "..\tcp.c" /0
 
 
 
 buf = buf_start + 16;
 *buf++ = (UINT8)(cs >> 8);
 *buf = (UINT8)cs;
 
 
 
 TCP_DEBUGOUT("Sending TCP...\r\n");
 
 process_ip_out(soc->rem_ip, IP_TCP, soc->tos, 100, buf_start, dlen + MIN_TCP_HLEN);
 
 TCP_DEBUGOUT("TCP packet sent\r\n");
 
 return(0);
 
 
 }
 
 
 










 
 void tcp_sendcontrol (INT8 sockethandle)
 {
 UINT8 i;
 
 
 TCP_DEBUGOUT("Entering to send TCP control packet\r\n");
 
 kick_WD();
 
 if( sockethandle < 0 ) {
 TCP_DEBUGOUT("ERROR:Socket Handle not valid (<0)\r\n");
 return;
 }
 
 if( sockethandle > NO_OF_TCPSOCKETS ) {
 TCP_DEBUGOUT("ERROR:Socket Handle not valid (>NO_OF_TCPSOCKETS)\r\n");
 return;
 }
 
 process_tcp_out(sockethandle, &tcp_tempbuf[0], MIN_TCP_HLEN + 1, 0);
 
 return;
 
 
 }
 














 
 void tcp_sendreset (struct tcp_frame *frame, UINT32 remip)
 {
 struct tcb* soc;
 
 soc = &tcp_socket[NO_OF_TCPSOCKETS];				 
 
 
 
 
 if( frame->hlen_flags & TCP_FLAG_RESET )
 return;
 
 
 
 soc->rem_ip = remip;
 soc->remport = frame->sport;
 soc->locport = frame->dport;
 soc->tos = 0;
 
 
 
 if( frame->hlen_flags & TCP_FLAG_ACK ) {
 
 
 soc->send_unacked = frame->ackno;
 soc->myflags = TCP_FLAG_RESET;	
 soc->receive_next = frame->seqno;
 } else {
 soc->send_unacked = 0;
 soc->myflags = TCP_FLAG_RESET | TCP_FLAG_ACK;	
 soc->receive_next = frame->seqno+1;
 }
 
 
 soc->send_mtu = TCP_DEF_MTU;
 
 tcp_sendcontrol(NO_OF_TCPSOCKETS);
 
 }
 
 










 
 UINT32 tcp_initseq (void)
 {
 
 TCP_DEBUGOUT("Calculating initial sequence number\r\n");
 
 return( ( (UINT32)base_timer << 24) | 0x00FFFFFF );
 
 }
 













 
 INT8 tcp_mapsocket (struct ip_frame* ipframe, struct tcp_frame* tcpframe)
 {
 struct tcb* soc;
 UINT8 i;
 
 
 
 
 for( i=0; i < NO_OF_TCPSOCKETS; i++) {
 soc = &tcp_socket[i];					 
 
 if(soc->state == TCP_STATE_LISTENING)
 continue;							 
 if(soc->remport != tcpframe->sport)
 continue;						
 if(soc->locport != tcpframe->dport)
 continue;						
 if(soc->rem_ip != ipframe->sip)	
 continue;						
 
 
 
 TCP_DEBUGOUT("Active connection socket found\r\n");
 
 return(i);
 }
 
 
 
 TCP_DEBUGOUT("No active connection, checking if SYN packet\r\n");
 
 
 
 if( (tcpframe->hlen_flags & TCP_FLAG_SYN) == 0 )
 return(-1);
 if( tcpframe->hlen_flags & TCP_FLAG_ACK )
 return(-1);
 if( tcpframe->hlen_flags & TCP_FLAG_RESET )
 return(-1);
 if( tcpframe->hlen_flags & TCP_FLAG_FIN )
 return(-1);
 
 TCP_DEBUGOUT("Trying to allocate listening one for SYN packet\r\n");
 
 
 
 for( i=0; i < NO_OF_TCPSOCKETS; i++) {
 soc = &tcp_socket[i];				 
 
 if(soc->state != TCP_STATE_LISTENING)
 continue;	
 
 if(soc->locport != tcpframe->dport)
 continue;
 
 
 
 soc->rem_ip = ipframe->sip;
 soc->remport = tcpframe->sport;
 
 TCP_DEBUGOUT("Allocated new socket\r\n");
 
 return(i);
 
 }
 
 
 
 TCP_DEBUGOUT("ERROR:No socket found or allocated for TCP packet\r\n");
 
 return(-1);
 
 }
 
 










 
 void tcp_newstate (struct tcb* soc, UINT8 nstate)
 {
 soc->state = nstate;
 soc->retries_left = TCP_DEF_RETRIES;
 
 
 
 switch(soc->state) {
 case TCP_STATE_TIMED_WAIT:
 soc->retries_left = 0;
 break;
 
 case TCP_STATE_LAST_ACK:
 case TCP_STATE_FINW1:
 case TCP_STATE_FINW2:
 case TCP_STATE_CLOSING:
 soc->retries_left = 1;
 break;
 
 default:
 break;
 
 }
 
 
 
 if(soc->state == TCP_STATE_CONNECTED)
 init_timer(soc->persist_timerh, soc->tout);
 
 
 
 init_timer(soc->retransmit_timerh, TCP_DEF_RETRY_TOUT*TIMERTIC);
 
 return;
 
 
 }
 










 
 UINT16 tcp_getfreeport (void)
 {
 struct tcb* soc;
 static UINT16 lastport = 1;
 UINT16 start;
 UINT16 i;
 
 
 
 
 for( start = lastport++; start != lastport; lastport++) {
 if(lastport == TCP_PORTS_END)
 lastport = 1;
 
 for(i = 0; i < NO_OF_TCPSOCKETS; i++) {
 soc = &tcp_socket[i];					 
 
 if( (soc->state > TCP_STATE_CLOSED) && (soc->locport == lastport) ) {
 
 break; 
 }
 
 }	
 
 
 
 if( i == NO_OF_TCPSOCKETS)
 break; 
 
 }
 
 if(lastport == start) {
 TCP_DEBUGOUT("Out of TCP ports!!\n\r");
 return(0);
 }
 
 return(lastport);
 
 }
 
 
 













 
 UINT8 tcp_check_cs (struct ip_frame* ipframe, UINT16 len)
 {
 UINT16 cs;
 UINT8 cs_cnt;
 UINT16 i;
 
 cs = 0;
 cs_cnt = 0;
 
 
 
 cs = ip_checksum(cs, (UINT8)(ipframe->sip >> 24), cs_cnt++);	
 cs = ip_checksum(cs, (UINT8)(ipframe->sip >> 16), cs_cnt++);
 cs = ip_checksum(cs, (UINT8)(ipframe->sip >> 8), cs_cnt++);
 cs = ip_checksum(cs, (UINT8)ipframe->sip, cs_cnt++);
 
 cs = ip_checksum(cs, (UINT8)(ipframe->dip >> 24), cs_cnt++);	
 cs = ip_checksum(cs, (UINT8)(ipframe->dip >> 16), cs_cnt++);
 cs = ip_checksum(cs, (UINT8)(ipframe->dip >> 8), cs_cnt++);
 cs = ip_checksum(cs, (UINT8)ipframe->dip, cs_cnt++);	
 
 cs = ip_checksum(cs, 0, cs_cnt++);
 
 cs = ip_checksum(cs, (UINT8)ipframe->protocol, cs_cnt++);
 
 cs = ip_checksum(cs, (UINT8)(len >> 8), cs_cnt++);
 cs = ip_checksum(cs, (UINT8)len, cs_cnt++);
 
 
 
 for(i=0; i < len; i++)
 cs = ip_checksum(cs, RECEIVE_NETWORK_B(), cs_cnt++);
 
 cs = ~ cs;
 
 if(cs != IP_GOOD_CS) {
 return (0);
 }
 
 
 
 return(1);
 
 
 }