tcp.c

Keil_C51程序,C8051实现的TCP/IP功能源码

//-----------------------------------------------------------------------------
// Net TCP.C
//
// This module handles TCP segments
// Refer to RFC 793, 896, 1122, 1323, 2018, 2581
//
// A "connection" is a unique combination of 4 items:  His IP address,
// his port number, my IP address, and my port number.
//
// Note that a SYN and a FIN count as a byte of data, but a RST does
// not count. Neither do any of the other flags.
// See "TCP/IP Illustrated, Volume 1" Sect 17.3 for info on flags
//-----------------------------------------------------------------------------
#include <string.h>
#include <stdlib.h>
#include <ctype.h>		// toupper
#include "C8051f.h"
#include "net.h"
#include "cksum.h"
#include "serial.h"
#include "ip.h"
#include "http.h"
#include "tcp.h"


// These structures keep track of connection information
CONNECTION xdata conxn[5];

ULONG 	idata initial_sequence_nr;
UINT 	xdata sender_tcpport;
static 	ULONG xdata sender_ipaddr;
UCHAR 	idata just_closed; // Keeps track of when a conxn closed

extern ULONG code my_ipaddr;
extern UCHAR idata debug;
extern char xdata text[];

// Options: MSS (4 bytes), NOPS (2 bytes), Selective ACK (2 bytes) 
UCHAR code opt[10] = {
0x02, 0x04, 0x05, 0xB4,
0x01, 0x01,
0x04, 0x02};



//------------------------------------------------------------------------
// Initialize variables declared in this module
// 初始化tcp 
//------------------------------------------------------------------------
void init_tcp(void)
{
   memset(conxn, 0, sizeof(conxn));
   just_closed = FALSE;
   initial_sequence_nr = 1;
}

//------------------------------------------------------------------------
// This sends a TCP segments that do not include any data.
// http_send() in the HTTP module is used to send data.
// See "TCP/IP Illustrated, Volume 1" Sect 17.3
// 发送一个TCP段，不包括任何数据。http_send()用于发送数据。
//------------------------------------------------------------------------
void tcp_send(UINT flags, UINT hdr_len, UCHAR nr)
{
   	ULONG idata sum, dest;
  	UINT idata result;
   	UCHAR xdata * outbuf;
   	TCP_HEADER xdata * tcp;
   	IP_HEADER xdata * ip;
          
   
   	// Allocate memory for entire outgoing message including
   	// eth & IP headers 
   	outbuf = (UCHAR xdata *)malloc(34 + hdr_len);
   	if (outbuf == NULL)
   	{
      	if (debug) SendCommString("TCP: Oops, out of memory\r");
      	return;
  	}

	   
  	tcp = (TCP_HEADER xdata *)(outbuf + 34);
   	ip = (IP_HEADER xdata *)(outbuf + 14);

   	// If no connection, then message is probably a reset
   	// message which goes back to the sender
   	// Otherwise, use information from the connection.
   	if (nr == NO_CONNECTION)
   	{
      	tcp->source_port = HTTP_PORT;
      	tcp->dest_port = sender_tcpport;
      	tcp->sequence = 0;
      	tcp->ack_number = 0;
      	dest = sender_ipaddr;
   	}
   	else if (nr < 5)
   	{
      	// This message is to connected port
      	tcp->source_port = HTTP_PORT;
      	tcp->dest_port = conxn[nr].port;
      	tcp->sequence = conxn[nr].my_sequence;
      	tcp->ack_number = conxn[nr].his_sequence;
      	dest = conxn[nr].ipaddr;
   	}
   	else
   	{
    	if (debug) SendCommString("TCP: Oops, sock nr out of range\r");
		free(outbuf);
		return;
	}

   	// Total segment length = header length
      
   	// Insert header len
   	tcp->flags = (hdr_len << 10) | flags;
   	tcp->window = 1024;
   	tcp->checksum = 0;
   	tcp->urgent_ptr = 0;//
   
   	// Sending SYN with header options
   	if (hdr_len == 28)
   	{
      	memcpy(&tcp->options, opt, 8);
   	}   
   
   	// Compute checksum including 12 bytes of pseudoheader
	// Must pre-fill 2 items in ip header to do this
	ip->dest_ipaddr = dest;
	ip->source_ipaddr = my_ipaddr;
		
	// Sum source_ipaddr, dest_ipaddr, and entire TCP message 
	sum = (ULONG)cksum(outbuf + 26, 8 + hdr_len);
				
	// Add in the rest of pseudoheader which is
	// protocol id and TCP segment length
	sum += (ULONG)0x0006;
	sum += (ULONG)hdr_len;

	// In case there was a carry, add it back around
	result = (UINT)(sum + (sum >> 16));
	tcp->checksum = ~result;
   
	if (debug) SendCommString("TCP: Sending msg to IP layer\r");
	ip_send(outbuf, dest, TCP_TYPE, hdr_len);

  	// (Re)start TCP retransmit timer
   	conxn[nr].timer = TCP_TIMEOUT;
}


//------------------------------------------------------------------------
// This runs every 0.5 seconds.  If the other end has not ACK'd
// everyting we have sent, it re-sends it.  To save RAM space, we 
// regenerate a segment rather than keeping a bunch of segments 
// hanging around eating up RAM.  A connection should not be in an
// opening or closing state when this timer expires, so we simply
// send a reset.
// 每0.5秒运行一次。如果我们这端发送后另外一端没有没有回复的，将重发。
// 为了保证RAM的空间，我们另开了一段RAM，防止互相重叠。当超时时，
// 一次连接不应该是开或者关状态，因此我们简单的重发一次。
// If a connection is in the ESTABLISHED state when the timer expires
// then we have just sent a web page so re-send the page
// 在连接状态时，当超时，我们发送网页，更新它。
//------------------------------------------------------------------------
void tcp_retransmit(void)
{
	static UCHAR idata retries = 0;//重试
	UCHAR idata nr;

   // Scan through all active connections 
	for (nr = 0; nr < 5; nr++)
	{
		if ((conxn[nr].ipaddr != 0) && (conxn[nr].timer))
    	{
        	// Decrement the timer and see if it hit 0
        	conxn[nr].timer--;
        	if (conxn[nr].timer == 0)
        	{
            // Socket just timed out. If we are not in ESTABLISHED state
            // something is amiss so send reset and close connection
            	if (conxn[nr].state != STATE_ESTABLISHED)
            	{
               	// Send reset and close connection
               		if (debug) SendCommString("TCP: Timeout, sending reset\r");
               		tcp_send(FLG_RST, 20, nr);
               		conxn[nr].ipaddr = 0;
               		return;
            	}
            	else
            	{
               	// Socket is in ESTABLISHED state. First make sure his
               	// ack number is not bogus.
               	if (conxn[nr].his_ack > conxn[nr].my_sequence)
               	{
                  	// Send reset and close connection
                  	if (debug) SendCommString("TCP: Timeout, sending reset\r");
                  	tcp_send(FLG_RST, 20, nr);
                  	conxn[nr].ipaddr = 0;
                  	return;
               	}
               
               	// We always increment our sequence number immediately
				// after sending, so the ack number from the other end
				// should be equal to our sequence number.  If it is less,
				// it means he lost some of our data.
               	if (conxn[nr].his_ack < conxn[nr].my_sequence)
				{
                  	retries++;
					if (retries <= 2)
					{
                   	// The only thing we send is a web page, and it looks
                  	// like other end did not get it, so resend
                  	// but do not increase my sequence number
                  		if (debug) SendCommString("TCP: Timeout, resending data\r");
                  		http_server(conxn[nr].query, 0, nr, 1);
			           	conxn[nr].inactivity = INACTIVITY_TIME;
                  	}
					else
					{
					  	if (debug) SendCommString("TCP: Giving up, sending reset\r");
						// Send reset and close connection
               			tcp_send(FLG_RST, 20, nr);
               			conxn[nr].ipaddr = 0;
               		}
               	}
            }
         }
      }
   }
}




//------------------------------------------------------------------------
// This runs every 0.5 seconds.  If the connection has had no activity
// it initiates closing the connection.
// 这个程序每0.5秒运行。如果连接没有活动，就关闭连接。
//------------------------------------------------------------------------
void tcp_inactivity(void)
{
	UCHAR idata nr;
   
	// Look for active connections in the established state
	for (nr = 0; nr < 5; nr++)
	{
    	if ((conxn[nr].ipaddr != 0) && 
          (conxn[nr].state == STATE_ESTABLISHED) &&
          (conxn[nr].inactivity))
      	{
        	// Decrement the timer and see if it hit 0
        	conxn[nr].inactivity--;
        	if (conxn[nr].inactivity == 0)
        	{
            // Inactivity timer has just timed out.
            // Initiate close of connection
            	tcp_send((FLG_ACK | FLG_FIN), 20, nr);
            	conxn[nr].my_sequence++;    // For my FIN
            	conxn[nr].state = STATE_FIN_WAIT_1;
            	if (debug) SendCommString("TCP: Entered FIN_WAIT_1 state\r");	
         	}
      	}
   	}
}


//------------------------------------------------------------------------
// This handles incoming TCP messages and manages the TCP state machine
// Note - both the SYN and FIN flags consume a sequence number.
// See "TCP/IP Illustrated, Volume 1" Sect 18.6 for info on TCP states
// See "TCP/IP Illustrated, Volume 1" Sect 17.3 for info on flags
// 处理收到的TCP信息和管理TCP状态机。
//------------------------------------------------------------------------
void tcp_rcve(UCHAR xdata * inbuf, UINT len)
{
	UCHAR idata i, j, nr;
	UINT idata result, header_len, data_len;
	TCP_HEADER xdata * tcp;
	IP_HEADER xdata * ip;
	ULONG idata sum;
   
   	// IP header is always 20 bytes so message starts at index 34      
   	tcp = (TCP_HEADER xdata *)(inbuf + 34);
   	ip = (IP_HEADER xdata *)(inbuf + 14);
				   
	// Compute TCP checksum including 12 byte pseudoheader
	// Sum source_ipaddr, dest_ipaddr, and entire TCP message 
	sum = (ULONG)cksum(inbuf + 26, 8 + len);
		
	// Add in the rest of pseudoheader which is
	// protocol id and TCP segment length
	sum += (ULONG)0x0006;     
	sum += (ULONG)len;

	// In case there was a carry, add it back around
	result = (UINT)(sum + (sum >> 16));
		
	if (result != 0xFFFF)
	{
		if (debug) SendCommString("TCP: Error, bad cksum\r");
		return;
	}

	if (debug) SendCommString("TCP: Msg rcvd with good cksum\r");
   
	// See if message is for http server
	// 需要HTTP服务，
	if (tcp->dest_port != HTTP_PORT)	
	{
    	if (debug)
    	{
        	SendCommString("TCP: Error, msg to port ");
        	memset(text, 0, 10);
        	itoa(tcp->dest_port, text, 10);
        	SendCommString(text);
			SendCommString("\r");
      	}
      	tcp_send(FLG_RST, 20, NO_CONNECTION);
      	return;
   	}
   
   	// Capture sender's IP address and port number
   	sender_ipaddr = ip->source_ipaddr;
   	sender_tcpport = tcp->source_port;
   
   	// See if the TCP segment is from someone we are already
   	// connected to. 
   	for (i=0; i < 5; i++)
   	{
      	if ((ip->source_ipaddr == conxn[i].ipaddr) &&
         (tcp->source_port == conxn[i].port))
      	{   
         	nr = i;
         	if (debug) SendCommString("TCP: Rcvd msg from existing conxn\r");
         	break;
      	}       
   	}