tcp.i

cs8900 c51应用

 
 
 if(check_timer(soc->persist_timerh) == 0) {
 
 soc->myflags = TCP_FLAG_ACK | TCP_FLAG_FIN;
 soc->send_next++;
 tcp_sendcontrol(handle);
 tcp_newstate(soc, TCP_STATE_FINW1);	
 
 
 
 soc->event_listener(handle, TCP_EVENT_CLOSE, soc->rem_ip, soc->remport);
 
 handle++;
 
 return;			
 }	
 
 
 
 if(temp == 0)
 break;
 
 
 
 if( check_timer(soc->retransmit_timerh) != 0 )
 break;
 
 
 
 if(soc->retries_left == 0) {
 
 
 TCP_DEBUGOUT("Retries used up, resetting\r\n");
 
 soc->myflags = TCP_FLAG_RESET;
 tcp_sendcontrol(handle);
 
 
 
 soc->event_listener(handle, 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);
 
 handle++;
 
 return;										
 }
 
 soc->retries_left--;
 init_timer(soc->retransmit_timerh, TCP_DEF_RETRY_TOUT*TIMERTIC);
 
 
 
 
 if(temp>soc->send_mtu)
 temp = soc->send_mtu;
 
 
 
 
 soc->send_next = soc->send_unacked;
 
 
 
 
 
 old_retries = soc->retries_left;
 
 temp = soc->event_listener(handle, TCP_EVENT_REGENERATE, (UINT32)temp, 0);
 
 soc->retries_left = old_retries;
 
 if(temp <= 0) {
 
 
 soc->myflags = TCP_FLAG_RESET;
 tcp_sendcontrol(handle);
 
 
 
 soc->event_listener(handle, 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);
 
 handle++;
 
 return;					
 
 }
 
 
 
 handle++;
 
 return;
 
 
 case TCP_STATE_SYN_SENT:
 case TCP_STATE_SYN_RECEIVED:
 
 
 if( check_timer(soc->retransmit_timerh) != 0 )
 break;
 
 TCP_DEBUGOUT("Timeout\r\n");
 
 
 if( soc->retries_left ) {
 soc->retries_left--;
 init_timer(soc->retransmit_timerh, TCP_DEF_RETRY_TOUT*TIMERTIC);
 tcp_sendcontrol(handle);
 
 handle++;
 
 return;				
 } else {
 
 TCP_DEBUGOUT("Retries used up, resetting\r\n");
 
 if(soc->type & TCP_TYPE_SERVER )
 tcp_newstate(soc, TCP_STATE_LISTENING);
 else
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 soc->myflags = TCP_FLAG_RESET;
 tcp_sendcontrol(handle);
 
 
 
 soc->event_listener(handle, TCP_EVENT_ABORT, soc->rem_ip, soc->remport);
 
 handle++;
 
 return;
 }
 
 break;
 
 case TCP_STATE_TIMED_WAIT:
 
 
 
 if( check_timer(soc->retransmit_timerh) != 0 )
 break;
 
 TCP_DEBUGOUT("Timeout\r\n");
 
 if(soc->retries_left) {
 soc->retries_left--;
 init_timer(soc->retransmit_timerh, TCP_DEF_RETRY_TOUT*TIMERTIC);
 break;
 }
 
 if(soc->type & TCP_TYPE_SERVER )
 tcp_newstate(soc, TCP_STATE_LISTENING);
 else
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 break;
 
 case TCP_STATE_LAST_ACK:
 case TCP_STATE_FINW1:
 case TCP_STATE_CLOSING:
 
 
 
 if( check_timer(soc->retransmit_timerh) != 0 )
 break;
 
 TCP_DEBUGOUT("Timeout\r\n");		
 
 
 
 if( soc->retries_left ) {
 soc->retries_left--;
 init_timer(soc->retransmit_timerh, TCP_DEF_RETRY_TOUT*TIMERTIC);
 soc->myflags = TCP_FLAG_FIN | TCP_FLAG_ACK;
 tcp_sendcontrol(handle);
 
 handle++;
 
 
 return;				
 } else {
 
 TCP_DEBUGOUT("Retries used up, resetting\r\n");
 
 if(soc->type & TCP_TYPE_SERVER )
 tcp_newstate(soc, TCP_STATE_LISTENING);
 else
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 soc->myflags = TCP_FLAG_RESET;
 tcp_sendcontrol(handle);
 
 
 
 soc->event_listener(handle, TCP_EVENT_ABORT, soc->rem_ip, soc->remport);
 
 handle++;
 
 return;
 }			
 
 break;
 
 case TCP_STATE_FINW2:
 
 
 
 if( check_timer(soc->retransmit_timerh) != 0 )
 break;
 
 TCP_DEBUGOUT("Timeout\r\n");		
 
 
 
 if( soc->retries_left )	{
 
 
 soc->retries_left--;
 init_timer(soc->retransmit_timerh, TCP_DEF_RETRY_TOUT*TIMERTIC);
 break;			
 } else {
 
 TCP_DEBUGOUT("Retries used up, resetting\r\n");
 
 if(soc->type & TCP_TYPE_SERVER )
 tcp_newstate(soc, TCP_STATE_LISTENING);
 else
 tcp_newstate(soc, TCP_STATE_CLOSED);
 
 soc->myflags = TCP_FLAG_RESET;
 tcp_sendcontrol(handle);
 
 
 
 soc->event_listener(handle, TCP_EVENT_ABORT, soc->rem_ip, soc->remport);
 
 handle++;
 
 return;
 }	
 
 break;
 
 default:
 break;	
 
 }
 
 
 
 handle++;
 
 }
 
 }
 
 
 
















 
 INT8 tcp_init (void)
 {
 UINT16 i;
 INT16 h;
 struct tcb* soc;
 
 if( NO_OF_TCPSOCKETS < 0 )
 return(-1);
 
 if( NO_OF_TCPSOCKETS == 0 )
 return(0);
 
 TCP_DEBUGOUT("Initializing TCP");
 
 for(i=0; i < NO_OF_TCPSOCKETS; i++) {
 soc = &tcp_socket[i];			 
 h = -1;
 
 soc->state = TCP_STATE_FREE;
 soc->type = TCP_TYPE_NONE;
 soc->flags = 0;
 soc->rem_ip = 0;
 soc->remport = 0;
 soc->locport = 0;
 soc->myflags = 0;
 soc->send_mtu = TCP_DEF_MTU;
 soc->tos = 0;
 soc->tout = 0;
 soc->event_listener = 0;
 
 
 
 h = get_timer();
 





 
 
 init_timer(h,0);					 
 
 soc->persist_timerh = h;
 
 h = get_timer();
 





 
 
 init_timer(h,0);					 
 
 soc->retransmit_timerh = h;
 
 soc->retries_left = 0;		 
 
 TCP_DEBUGOUT(".");
 
 
 }
 
 TCP_DEBUGOUT("\n\rTCP Initialized\n\r");
 
 
 
 return(i+1);
 
 
 }
 
 
 
 
 
 
 
 
 













 
 INT16 process_tcp_in (struct ip_frame* frame, UINT16 len)
 {
 struct tcb* soc;
 UINT16 hlen;
 UINT8 olen;
 UINT16 dlen;
 UINT32 diff;
 UINT16 i;
 INT8 sochandle;	
 INT16 temp;
 
 
 
 TCP_DEBUGOUT("Processing TCP...\n\r");
 
 if( frame->protocol != IP_TCP ) {
 TCP_DEBUGOUT("ERROR: The protocol is not TCP\n\r");
 return(-1);
 }
 
 
 
 
 NETWORK_RECEIVE_INITIALIZE(frame->buf_index);
 
 if( tcp_check_cs(frame, len) == 1) {
 TCP_DEBUGOUT("TCP Checksum OK\n\r");
 } else {
 TCP_DEBUGOUT("ERROR:TCP Checksum failed\r\n");
 return(-1);
 } 
 
 
 
 NETWORK_RECEIVE_INITIALIZE(frame->buf_index);
 
 received_tcp_packet.sport = ((UINT16)RECEIVE_NETWORK_B()) << 8;
 received_tcp_packet.sport |= RECEIVE_NETWORK_B();
 
 received_tcp_packet.dport = ((UINT16)RECEIVE_NETWORK_B()) << 8;
 received_tcp_packet.dport |= RECEIVE_NETWORK_B();
 
 received_tcp_packet.seqno = (((UINT32)RECEIVE_NETWORK_B()) << 24);
 received_tcp_packet.seqno |= (((UINT32)RECEIVE_NETWORK_B()) << 16);
 received_tcp_packet.seqno |= (((UINT32)RECEIVE_NETWORK_B()) << 8);
 received_tcp_packet.seqno |= RECEIVE_NETWORK_B();
 
 received_tcp_packet.ackno = (((UINT32)RECEIVE_NETWORK_B()) << 24);
 received_tcp_packet.ackno |= (((UINT32)RECEIVE_NETWORK_B()) << 16);
 received_tcp_packet.ackno |= (((UINT32)RECEIVE_NETWORK_B()) << 8);
 received_tcp_packet.ackno |= RECEIVE_NETWORK_B();
 
 received_tcp_packet.hlen_flags = ((UINT16)RECEIVE_NETWORK_B()) << 8;
 received_tcp_packet.hlen_flags |= RECEIVE_NETWORK_B();
 
 received_tcp_packet.window = ((UINT16)RECEIVE_NETWORK_B()) << 8;
 received_tcp_packet.window |= RECEIVE_NETWORK_B();
 
 received_tcp_packet.checksum = ((UINT16)RECEIVE_NETWORK_B()) << 8;
 received_tcp_packet.checksum |= RECEIVE_NETWORK_B();
 
 received_tcp_packet.urgent = ((UINT16)RECEIVE_NETWORK_B()) << 8;
 received_tcp_packet.urgent |= RECEIVE_NETWORK_B();
 
 
 
 hlen = received_tcp_packet.hlen_flags & 0xF000;
 hlen >>= 10;
 
 if( hlen < MIN_TCP_HLEN ) {
 TCP_DEBUGOUT("ERROR: Received TCP Header too short\r\n");
 return(-1);
 }
 
 if(hlen == MIN_TCP_HLEN)
 TCP_DEBUGOUT("TCP does not contain options\r\n");
 
 olen = hlen - MIN_TCP_HLEN;
 
 if( olen > MAX_TCP_OPTLEN ) {
 TCP_DEBUGOUT("ERROR: Received TCP header contains too long option field\r\n");
 return(-1);
 }
 
 
 
 if( hlen > len ) {
 TCP_DEBUGOUT("ERROR: TCP header longer than packet\r\n");
 return(-1);
 }
 
 dlen = len - hlen - olen;
 
 
 
 for(i=0; i<olen;i++)
 received_tcp_packet.opt[i] = RECEIVE_NETWORK_B();
 
 
 
 sochandle = tcp_mapsocket(frame, &received_tcp_packet);
 
 if(sochandle < 0) {
 TCP_DEBUGOUT("ERROR: Processing TCP packet failed\r\n");
 tcp_sendreset(&received_tcp_packet, frame->sip);
 return(-1);
 }
 
 received_tcp_packet.buf_index = frame->buf_index + hlen;
 NETWORK_RECEIVE_INITIALIZE(received_tcp_packet.buf_index);
 
 
 
 
 
 soc = &tcp_socket[sochandle];
 
 
 
 switch(soc->state) {
 case TCP_STATE_CONNECTED:
 
 TCP_DEBUGOUT("CONNECTED 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_SYN )	{
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_ACK )	{
 
 
 if( (received_tcp_packet.seqno + 1) == soc->receive_next ) {
 
 if( received_tcp_packet.ackno == soc->send_next ) {
 
 TCP_DEBUGOUT("Received SYN+ACK again\r\n");
 
 
 soc->myflags = TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);
 return(0);
 }
 
 }
 
 
 
 
 return(0);
 
 
 }
 
 }
 
 
 
 if( soc->send_unacked != soc->send_next ) {
 
 
 
 if( (received_tcp_packet.hlen_flags & TCP_FLAG_ACK) == 0) {
 
 TCP_DEBUGOUT("Packet without ACK and unacked data. Packet not processed\r\n");
 return(0);
 }
 
 if( received_tcp_packet.ackno == soc->send_next ) {
 
 
 
 soc->send_unacked = soc->send_next;
 
 
 
 soc->event_listener(sochandle, TCP_EVENT_ACK, soc->rem_ip, soc->remport);
 
 }
 
 
 }
 
 
 
 if(soc->receive_next != received_tcp_packet.seqno)
 {
 
 
 DEBUGOUT("Too big sequence number received\r\n");
 
 soc->myflags = TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);
 return(0);
 }
 
 
 {			
 
 soc->event_listener(sochandle, TCP_EVENT_DATA, dlen, 0);
 
 soc->receive_next += dlen;
 }
 
 
 
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_FIN )	{
 TCP_DEBUGOUT("Other end want's to close\r\n");
 
 
 
 if( soc->send_unacked == soc->send_next) {
 
 soc->event_listener(sochandle, TCP_EVENT_CLOSE, soc->rem_ip, soc->remport);
 
 
 
 soc->receive_next++;
 soc->send_next++;
 soc->myflags = TCP_FLAG_ACK | TCP_FLAG_FIN;
 
 tcp_newstate(soc, TCP_STATE_LAST_ACK);
 tcp_sendcontrol(sochandle);
 
 return(0);
 }
 }
 
 
 
 if(dlen) {
 soc->myflags = TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);
 }
 
 tcp_newstate(soc, TCP_STATE_CONNECTED);			
 
 
 return(0);
 
 
 break;
 
 case TCP_STATE_FREE:
 
 
 tcp_sendreset(&received_tcp_packet, frame->sip);
 return(-1);
 
 break;
 
 case TCP_STATE_CLOSED:
 
 
 tcp_sendreset(&received_tcp_packet, frame->sip);
 return(-1);		
 
 break;
 
 case TCP_STATE_LISTENING:
 
 TCP_DEBUGOUT("LISTENING State...\r\n");
 
 
 
 if(received_tcp_packet.hlen_flags & TCP_FLAG_RESET) {
 TCP_DEBUGOUT("ERROR:Reset received\r\n");
 tcp_newstate(soc, TCP_STATE_LISTENING);
 return(-1);
 }
 
 if(received_tcp_packet.hlen_flags & TCP_FLAG_ACK) {
 TCP_DEBUGOUT("ERROR:Ack received\r\n");
 tcp_newstate(soc, TCP_STATE_LISTENING);
 
 tcp_sendreset(&received_tcp_packet, frame->sip);
 return(-1);	
 }
 
 if((received_tcp_packet.hlen_flags & TCP_FLAG_SYN) == 0) {
 TCP_DEBUGOUT("ERROR:No SYN set on packet\r\n");
 tcp_newstate(soc, TCP_STATE_LISTENING);
 
 tcp_sendreset(&received_tcp_packet, frame->sip);
 return(-1);
 }
 
 
 
 
 
 temp = (INT16)soc->event_listener(sochandle, TCP_EVENT_CONREQ, soc->rem_ip, soc->remport);
 
 if( temp == -1)	{
 TCP_DEBUGOUT("Application disregarded connection request\r\n");
 tcp_sendreset(&received_tcp_packet, frame->sip);
 return(-1);
 }
 
 if( temp == -2 ) {
 TCP_DEBUGOUT("Application wants to think about accepting conreq\r\n");
 return(1);
 }
 
 
 
 TCP_DEBUGOUT("Next state SYN_RECEIVED\r\n");
 if(soc->flags & TCP_INTFLAGS_CLOSEPENDING)
 soc->flags ^= TCP_INTFLAGS_CLOSEPENDING;
 tcp_newstate(soc, TCP_STATE_SYN_RECEIVED);
 soc->receive_next = received_tcp_packet.seqno + 1;	 
 soc->send_unacked = tcp_initseq();
 
 soc->myflags = TCP_FLAG_SYN | TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);
 soc->send_next = soc->send_unacked + 1;
 
 return(1);
 
 break;
 
 case TCP_STATE_SYN_RECEIVED:
 
 TCP_DEBUGOUT("SYN_RECEIVED 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_SYN) &&
 (received_tcp_packet.hlen_flags & TCP_FLAG_ACK)	) {			
 
 if( received_tcp_packet.ackno != soc->send_next ) {
 TCP_DEBUGOUT("SYN+ACK received but wrong Ack\n\r");
 return(-1);
 }
 
 TCP_DEBUGOUT("SYN+ACK received, this side established\n\r");
 
 
 
 soc->receive_next =  received_tcp_packet.seqno;
 soc->receive_next++;							 
 
 
 
 soc->send_unacked = soc->send_next;
 
 tcp_newstate(soc, TCP_STATE_CONNECTED);
 soc->myflags = TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);
 
 
 
 soc->event_listener(sochandle, TCP_EVENT_CONNECTED, soc->rem_ip, soc->remport);
 
 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);
 }
 
 if( received_tcp_packet.seqno != soc->receive_next ) {
 TCP_DEBUGOUT("ACK received but Wrong SEQ number\n\r");
 return(-1);
 }
 
 TCP_DEBUGOUT("ACK received, this side CONNECTED\r\n");
 
 
 
 soc->send_unacked = soc->send_next;
 
 tcp_newstate(soc, TCP_STATE_CONNECTED);
 
 
 
 soc->event_listener(sochandle, TCP_EVENT_CONNECTED, soc->rem_ip, soc->remport);
 
 return(0);
 
 }
 
 
 
 if( received_tcp_packet.hlen_flags & TCP_FLAG_SYN ) {
 TCP_DEBUGOUT("Repeated SYN\r\n");
 return(0);
 }
 
 
 
 TCP_DEBUGOUT("Unrecognized packet\n\r");
 
 tcp_sendreset(&received_tcp_packet, frame->sip);
 
 return(-1);
 
 break;
 
 case TCP_STATE_SYN_SENT:
 
 TCP_DEBUGOUT("SYN_SENT 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_SYN) &&
 (received_tcp_packet.hlen_flags & TCP_FLAG_ACK)	) {
 
 
 if( received_tcp_packet.ackno != soc->send_next ) {
 TCP_DEBUGOUT("SYN+ACK received but wrong Ack\n\r");
 return(-1);
 }
 
 TCP_DEBUGOUT("SYN+ACK received, this side established\n\r");
 
 
 
 soc->receive_next =  received_tcp_packet.seqno;
 soc->receive_next++;							 
 
 
 
 soc->send_unacked = soc->send_next;
 
 tcp_newstate(soc, TCP_STATE_CONNECTED);
 soc->myflags = TCP_FLAG_ACK;
 tcp_sendcontrol(sochandle);
 
 
 
 soc->event_listener(sochandle, TCP_EVENT_CONNECTED, soc->rem_ip, soc->remport);
 
 return(0);