tcp.c

opentcp_mcf5282原代码

							return(0);
						}

					}

				 /* It is maybe SYN again so it haven't get our SYN + ACK	*/
				 /* Let our retransmission handle it						*/

				 return(0);


				}

			}

			/* Do we have unacked data?		*/

			if( soc->send_unacked != soc->send_next )
			{
				/* Yep, is the ACK valid?	*/

				if( (ReceivedTCPPacket.hlen_flags & TCP_FLAG_ACK) == 0)
				{
					DEBUGOUT("Packet without ACK and unacked data. Packet not processed\r\n");
					return(0);
				}

				if( ReceivedTCPPacket.ackno == soc->send_next )
				{

					/* We don't have unacked data now	*/

					soc->send_unacked = soc->send_next;

					/* Inform application	*/

					soc->event_listener(sochandle, TCP_EVENT_ACK, soc->rem_ip, soc->remport);

				}


			}

			/* Is the sequence OK	*/

			if(soc->receive_next != ReceivedTCPPacket.seqno)
			{
				/* Out of range, inform what we except	*/

				DEBUGOUT("Too big sequence number received\r\n");

				soc->myflags = TCP_FLAG_ACK;
				tcp_sendcontrol(sochandle);
				return(0);
			}

			/* Generate data event to application	*/

			soc->event_listener(sochandle, TCP_EVENT_DATA, dlen, 0);

			soc->receive_next += dlen;



#if 0

			diff = soc->receive_next - ReceivedTCPPacket.seqno;

			if( diff > TCP_HALF_SEQ_SPACE )
			{
				/* Out of range, inform what we except	*/

				DEBUGOUT("Too big sequence number received\r\n");

				soc->myflags = TCP_FLAG_ACK;
				tcp_sendcontrol(sochandle);
				return(0);
			}

			/* Does the packet contain data that we don't have already	*/

			if( dlen > diff )
			{
				/* Consume old data	*/

				for(i=0; i<diff; i++)
					RECEIVE_NETWORK_B();

				/* Generate data event to application	*/

				soc->event_listener(sochandle, TCP_EVENT_DATA, dlen - diff, 0);

				soc->receive_next += dlen - diff;

			}

#endif
			/* Is the FIN flag set?	*/

			if( ReceivedTCPPacket.hlen_flags & TCP_FLAG_FIN )
			{
				DEBUGOUT("Other end want's to close\r\n");

				/* Inform application if we don't have unacked data	*/

				if( soc->send_unacked == soc->send_next)
				{
					soc->event_listener(sochandle, TCP_EVENT_CLOSE, soc->rem_ip, soc->remport);

					/* ACK FIN and set our own FIN	*/

					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);
				}
			}

			/* ACK the data if there was it	*/

			if(dlen)
			{
				soc->myflags = TCP_FLAG_ACK;
				tcp_sendcontrol(sochandle);
			}

			/* Keep our socket from timeout	*/

			tcp_newstate(soc, TCP_STATE_CONNECTED);

			//init_timer(soc->persist_timerh, soc->tout);

			return(0);


			break;

		case TCP_STATE_FREE:

			/* Reset connection	*/
			tcp_sendreset(&ReceivedTCPPacket, frame->sip);
			return(-1);

			break;

		case TCP_STATE_CLOSED:

			/* Reset connection	*/
			tcp_sendreset(&ReceivedTCPPacket, frame->sip);
			return(-1);

			break;

		case TCP_STATE_LISTENING:

			DEBUGOUT("LISTENING State...\r\n");

			/* Check Flags	*/

			if(ReceivedTCPPacket.hlen_flags & TCP_FLAG_RESET)
			{
				DEBUGOUT("ERROR:Reset received\r\n");
				tcp_newstate(soc, TCP_STATE_LISTENING);
				return(-1);
			}

			if(ReceivedTCPPacket.hlen_flags & TCP_FLAG_ACK)
			{
				DEBUGOUT("ERROR:Ack received\r\n");
				tcp_newstate(soc, TCP_STATE_LISTENING);
				/* Reset connection	*/
				tcp_sendreset(&ReceivedTCPPacket, frame->sip);
				return(-1);
			}

			if((ReceivedTCPPacket.hlen_flags & TCP_FLAG_SYN) == 0)
			{
				DEBUGOUT("ERROR:No SYN set on packet\r\n");
				tcp_newstate(soc, TCP_STATE_LISTENING);
				/* Reset connection	*/
				tcp_sendreset(&ReceivedTCPPacket, frame->sip);
				return(-1);
			}

			/* OK, SYN received	*/

			/* Inform application and see if accepted	*/

			temp = (INT16)soc->event_listener(sochandle, TCP_EVENT_CONREQ, soc->rem_ip, soc->remport);

			if( temp == -1)
			{
				DEBUGOUT("Application disregarded connection request\r\n");
				tcp_sendreset(&ReceivedTCPPacket, frame->sip);
				return(-1);
			}

			if( temp == -2 )
			{
				DEBUGOUT("Application wants to think about accepting conreq\r\n");
				return(1);
			}

			/* The connection request was accepted	*/

			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 = ReceivedTCPPacket.seqno + 1;	/* Ack SYN		*/
			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:

			DEBUGOUT("SYN_RECEIVED State...\r\n");

			/* Check Flags	*/

			if(ReceivedTCPPacket.hlen_flags & TCP_FLAG_RESET)
			{
				DEBUGOUT("ERROR:Reset received\r\n");

				/* Inform application	*/

				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);
			}

			/* Is it SYN+ACK (if we are the because of simultaneous open)	*/

			if( (ReceivedTCPPacket.hlen_flags & TCP_FLAG_SYN) &&
				(ReceivedTCPPacket.hlen_flags & TCP_FLAG_ACK)	)
			{

				if( ReceivedTCPPacket.ackno != soc->send_next )
				{
					DEBUGOUT("SYN+ACK received but wrong Ack\n\r");
					return(-1);
				}

				DEBUGOUT("SYN+ACK received, this side established\n\r");

				/* Get peer's seq number	*/

				soc->receive_next =  ReceivedTCPPacket.seqno;
				soc->receive_next++;							/* ACK SYN	*/

				/* We have no unacked data	*/

				soc->send_unacked = soc->send_next;

				tcp_newstate(soc, TCP_STATE_CONNECTED);
				soc->myflags = TCP_FLAG_ACK;
				tcp_sendcontrol(sochandle);

				/* Inform application	*/

				soc->event_listener(sochandle, TCP_EVENT_CONNECTED, soc->rem_ip, soc->remport);

				return(0);

			}

			/* Is it ACK?		*/

			if( ReceivedTCPPacket.hlen_flags & TCP_FLAG_ACK )
			{
				if( ReceivedTCPPacket.ackno != soc->send_next )
				{
					DEBUGOUT("ACK received but wrong Ack\n\r");
					return(-1);
				}

				if( ReceivedTCPPacket.seqno != soc->receive_next )
				{
					DEBUGOUT("ACK received but Wrong SEQ number\n\r");
					return(-1);
				}

				DEBUGOUT("ACK received, this side CONNECTED\r\n");

				/* We have no unacked data	*/

				soc->send_unacked = soc->send_next;

				tcp_newstate(soc, TCP_STATE_CONNECTED);

				/* Inform application	*/

				soc->event_listener(sochandle, TCP_EVENT_CONNECTED, soc->rem_ip, soc->remport);

				return(0);

			}

			/* Is it SYN?		*/

			if( ReceivedTCPPacket.hlen_flags & TCP_FLAG_SYN )
			{
				DEBUGOUT("Repeated SYN\r\n");
				return(0);
			}

			/* We didn't understood this one, keep on trying but info with RESET	*/

			DEBUGOUT("Unrecognized packet\n\r");

			tcp_sendreset(&ReceivedTCPPacket, frame->sip);

			return(-1);

			break;

		case TCP_STATE_SYN_SENT:

			DEBUGOUT("SYN_SENT State\r\n");

			/* Check for RESET	*/

			if(ReceivedTCPPacket.hlen_flags & TCP_FLAG_RESET)
			{
				DEBUGOUT("ERROR:Reset received\r\n");

				/* Inform application	*/

				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);
			}

			/* Is it SYN+ACK?	*/

			if( (ReceivedTCPPacket.hlen_flags & TCP_FLAG_SYN) &&
				(ReceivedTCPPacket.hlen_flags & TCP_FLAG_ACK)	)
			{
				/* Rigth ACK?	*/

				if( ReceivedTCPPacket.ackno != soc->send_next )
				{
					DEBUGOUT("SYN+ACK received but wrong Ack\n\r");
					return(-1);
				}

				DEBUGOUT("SYN+ACK received, this side established\n\r");

				/* Get peer's seq number	*/

				soc->receive_next =  ReceivedTCPPacket.seqno;
				soc->receive_next++;							/* ACK SYN	*/

				/* We have no unacked data	*/

				soc->send_unacked = soc->send_next;

				tcp_newstate(soc, TCP_STATE_CONNECTED);
				soc->myflags = TCP_FLAG_ACK;
				tcp_sendcontrol(sochandle);

				/* Inform application	*/

				soc->event_listener(sochandle, TCP_EVENT_CONNECTED, soc->rem_ip, soc->remport);

				return(0);

			}

			/* Is it SYN (simultaneous open)	*/

			if(ReceivedTCPPacket.hlen_flags & TCP_FLAG_SYN)
			{
				DEBUGOUT("Simultaneous open, next SYN_RECEIVED\r\n");

				/* Get peer's seq number	*/

				soc->receive_next =  ReceivedTCPPacket.seqno;
				soc->receive_next++;							/* ACK SYN	*/

				tcp_newstate(soc, TCP_STATE_SYN_RECEIVED);
				soc->myflags = TCP_FLAG_SYN | TCP_FLAG_ACK;
				tcp_sendcontrol(sochandle);

				return(0);

			}

			/* This is something we didn't understood, maybe the other peer has	*/
			/* still old connection on or something								*/

			tcp_sendreset(&ReceivedTCPPacket, frame->sip);

			return(-1);

			break;

		case TCP_STATE_FINW1:

			DEBUGOUT("FINW1 State\r\n");

			/* Check for RESET	*/

			if(ReceivedTCPPacket.hlen_flags & TCP_FLAG_RESET)
			{
				DEBUGOUT("ERROR:Reset received\r\n");

				/* Inform application	*/

				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);
			}

			/* Is it FIN+ACK?			*/

			if( (ReceivedTCPPacket.hlen_flags & TCP_FLAG_FIN) &&
				(ReceivedTCPPacket.hlen_flags & TCP_FLAG_ACK)	)
			{
				/* Rigth ACK?	*/

				if( ReceivedTCPPacket.ackno != soc->send_next )
				{
					DEBUGOUT("FIN+ACK received but wrong Ack\n\r");
					return(-1);
				}

				DEBUGOUT("FIN+ACK received, next TIMED_WAIT\n\r");

				/* ACK FIN and all data	*/

				soc->receive_next = ReceivedTCPPacket.seqno;
				soc->receive_next++;
				soc->receive_next += dlen;

				/* We have no unacked data	*/

				soc->send_unacked = soc->send_next;

				tcp_newstate(soc, TCP_STATE_TIMED_WAIT);
				soc->myflags = TCP_FLAG_ACK;
				tcp_sendcontrol(sochandle);

				return(0);

			}

			/* Is it just FIN	*/

			if( ReceivedTCPPacket.hlen_flags & TCP_FLAG_FIN	)
			{

				DEBUGOUT("Simultaneous close, next CLOSING\n\r");

				/* ACK FIN and all data	*/

				soc->receive_next = ReceivedTCPPacket.seqno;
				soc->receive_next++;
				soc->receive_next += dlen;

				tcp_newstate(soc, TCP_STATE_CLOSING);
				soc->myflags = TCP_FLAG_ACK;
				tcp_sendcontrol(sochandle);
				return(0);

			}

			/* Is it just ACK?	*/

			if( ReceivedTCPPacket.hlen_flags & TCP_FLAG_ACK	)
			{
				/* Rigth ACK?	*/

				if( ReceivedTCPPacket.ackno != soc->send_next )
				{
					DEBUGOUT("ACK received but wrong Ack\n\r");
					return(-1);
				}

				DEBUGOUT("Our FIN is ACKed but peer don't agree to disconnect yet\r\n");
				DEBUGOUT("Next FINW2\r\n");

				/* We have no unacked data	*/

				soc->send_unacked = soc->send_next;

				tcp_newstate(soc, TCP_STATE_FINW2);

				return(0);

			}

			tcp_sendreset(&ReceivedTCPPacket, frame->sip);

			return(-1);

			break;

		case TCP_STATE_FINW2:

			DEBUGOUT("FINW2 State\r\n");

			/* Check for RESET	*/

			if(ReceivedTCPPacket.hlen_flags & TCP_FLAG_RESET)
			{
				DEBUGOUT("ERROR:Reset received\r\n");

				/* Inform application	*/

				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);
			}

			/* Do we finally get FIN?	*/

			if( ReceivedTCPPacket.hlen_flags & TCP_FLAG_FIN	)
			{

				DEBUGOUT("FIN received, next TIMED_WAIT\n\r");

				/* ACK FIN and all data	*/

				soc->receive_next = ReceivedTCPPacket.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);

			}

			tcp_sendreset(&ReceivedTCPPacket, frame->sip);

			return(-1);

			break;

		case TCP_STATE_CLOSING:

			DEBUGOUT("CLOSING State...\r\n");

			/* Check for RESET	*/

			if(ReceivedTCPPacket.hlen_flags & TCP_FLAG_RESET)
			{
				DEBUGOUT("ERROR:Reset received\r\n");

				/* Inform application	*/

				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);
			}

			/* Is it ACK?			*/

			if( ReceivedTCPPacket.hlen_flags & TCP_FLAG_ACK	)
			{
				/* Rigth ACK?	*/

				if( ReceivedTCPPacket.ackno != soc->send_next )
				{
					DEBUGOUT("ACK received but wrong Ack\n\r");
					return(-1);
				}

				DEBUGOUT("Our FIN is ACKed and peer wants to close too\r\n");
				DEBUGOUT("Next TIMED_WAIT\r\n");

				/* We have no unacked data	*/

				soc->send_unacked = soc->send_next;

				tcp_newstate(soc, TCP_STATE_TIMED_WAIT);

				return(0);

			}

			/* Is it repeated FIN?	*/

			if( ReceivedTCPPacket.hlen_flags & TCP_FLAG_FIN	)
			{

				DEBUGOUT("Repeated FIN, repeat ACK\n\r");

				/* ACK FIN and all data	*/

				soc->receive_next = ReceivedTCPPacket.seqno;
				soc->receive_next++;
				soc->receive_next += dlen;

				soc->myflags = TCP_FLAG_ACK;
				tcp_sendcontrol(sochandle);

				return(0);

			}

			tcp_sendreset(&ReceivedTCPPacket, frame->sip);

			return(-1);

			break;

		case TCP_STATE_LAST_ACK:

			DEBUGOUT("LAST_ACK State...\r\n");

			/* Check for RESET	*/

			if(ReceivedTCPPacket.hlen_flags & TCP_FLAG_RESET)
			{
				DEBUGOUT("ERROR:Reset received\r\n");

				/* Inform application	*/

				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);
			}

			/* Is it ACK?	*/

			if( ReceivedTCPPacket.hlen_flags & TCP_FLAG_ACK	)
			{
				/* Rigth ACK?	*/