tcp.c

44B0+8019系统

//-----------------------------------------------------------------------------
// 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 "..\44blibs\int_onoff.h"

#include "net.h"
#include "cksum.h"
#include "ip.h"
#include "http.h"
#include "tcp.h"

#define ENABLE()    EnableInt()
#define DISABLE()   DisableInt() 

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

unsigned int initial_sequence_nr;
unsigned char sender_tcpport;
static unsigned int sender_ipaddr;
unsigned char just_closed; // Keeps track of when a conxn closed


extern unsigned int  my_ipaddr;

/*
typedef struct
{
   unsigned short int  source_port;
   unsigned short int  dest_port;
   unsigned int        sequence;
   unsigned int        ack_number;
   unsigned short int  flags;
   unsigned short int  window;
   unsigned short int  checksum;
   unsigned short int  urgent_ptr;
	unsigned char       options;
} TCP_HEADER;
*/

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



//========================================================================
void tcp_getHader(void *inbuf,void *h)
{
   unsigned char *pinbuf = (unsigned char*)inbuf;
   unsigned char *pBuf;
   TCP_HEADER *ph = (TCP_HEADER*)h;

   //=========================================
   ph->source_port = get__int16(pinbuf + 34);
   ph->dest_port   = get__int16(pinbuf + 36);
   ph->sequence    = get__int32(pinbuf + 38);
   ph->ack_number  = get__int32(pinbuf + 42);

   ph->flags       = get__int16(pinbuf + 46);
   ph->window      = get__int16(pinbuf + 48);
   ph->checksum    = get__int16(pinbuf + 50);
   ph->urgent_ptr  = get__int16(pinbuf + 52);
   
   ph->options     = pinbuf[54];
   //ph->options     = pinbuf + 54;
}

void tcp_setHader(void *inbuf,void *h)
{
   unsigned char *pinbuf = (unsigned char*)inbuf;
   unsigned char *pBuf;
   TCP_HEADER *ph = (TCP_HEADER*)h;

   //=========================================
   set__int16(pinbuf + 34,ph->source_port);
   set__int16(pinbuf + 36,ph->dest_port);
   set__int32(pinbuf + 38,ph->sequence);
   set__int32(pinbuf + 42,ph->ack_number);

   set__int16(pinbuf + 46,ph->flags);
   set__int16(pinbuf + 48,ph->window);
   set__int16(pinbuf + 50,ph->checksum);
   set__int16(pinbuf + 52,ph->urgent_ptr);
   
   pinbuf[54] = ph->options;
}

//------------------------------------------------------------------------
//  Initialize variables declared in this module
//
//------------------------------------------------------------------------
void init_tcp()
{
   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
//------------------------------------------------------------------------
void tcp_send(unsigned short int flags, unsigned short int hdr_len, unsigned char nr)
{
   unsigned int sum, dest;
  	unsigned short int result;
   unsigned char outbuf[1520];
   TCP_HEADER *tcp,tcph;
   IP_HEADER *ip,iph;

   tcp = &tcph;
   ip = &iph;

	   
   tcp_getHader(outbuf,tcp);
   ip_getHader(outbuf,ip);

   // 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) serial_send("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( outbuf + 54 , opt, 8);
      tcp->options = opt[0];
   }   
   
   // 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 
	tcp_setHader(outbuf,tcp);
   ip_setHader(outbuf,ip);
   sum = (unsigned int)cksum(outbuf + 26, 8 + hdr_len);
				
	// Add in the rest of pseudoheader which is
	// protocol id and TCP segment length
	sum += (unsigned int)0x0006;
	sum += (unsigned int)hdr_len;

	// In case there was a carry, add it back around
	result = (unsigned short int)(sum + (sum >> 16));

   tcp_getHader(outbuf,tcp);
   ip_getHader(outbuf,ip);

	tcp->checksum = ~result;

   tcp_setHader(outbuf,tcp);
   ip_setHader(outbuf,ip);
   
   //if (debug) serial_send("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.
//
//	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()
{
   static unsigned char retries = 0;
   unsigned char 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) serial_send("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) serial_send("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) serial_send("TCP: Timeout, resending data\r");
                  	
                     http_server((unsigned char*)conxn[nr].query, 0, nr, 1);
			            conxn[nr].inactivity = INACTIVITY_TIME;
                  }
						else
						{
						  	//if (debug) serial_send("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.
//
//------------------------------------------------------------------------
void tcp_inactivity()
{
   unsigned char 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) serial_send("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
//------------------------------------------------------------------------
void tcp_rcve(unsigned char *inbuf, unsigned short int len)
{
   unsigned char i, j, nr;
   unsigned short int result, header_len, data_len;
   TCP_HEADER *tcp,tcph;
   IP_HEADER *ip,iph;
   unsigned int sum;
   
   // IP header is always 20 bytes so message starts at index 34      
   ip = &iph;
   tcp = &tcph;
   
   tcp_getHader(inbuf,tcp);
   ip_getHader(inbuf,ip);
   
				   
	// Compute TCP checksum including 12 byte pseudoheader
	// Sum source_ipaddr, dest_ipaddr, and entire TCP message 
	sum = (unsigned int)cksum(inbuf + 26, 8 + len);
		
	// Add in the rest of pseudoheader which is
	// protocol id and TCP segment length
	sum += (unsigned int)0x0006;     
	sum += (unsigned int)len;

	// In case there was a carry, add it back around
	result = (unsigned short int)(sum + (sum >> 16));
	//if (result != 0xFFFF)
	//{
	//	return;
   //}
   
	// See if message is for http server
	if (tcp->dest_port != HTTP_PORT)	
   {
      /*
      if (debug)
      {
         serial_send("TCP: Error, msg to port ");
         memset(text, 0, 10);