tcb.c.bak

一种操作系统源码核

#define	TCBF_NEED_OUT	0x01	/* we need output			*/
#define	TCBF_FIRST_SND	0x02	/* no data to ACK			*/
#define	TCBF_RDONE	0x04	/* no more to receive			*/
#define	TCBF_RCV_DONE	0x08	/* no more receive data to process	*/
#define	TCBF_SND_DONE	0x10	/* no more snd data allowed		*/
#define	TCBF_DELAY_ACK	0x20	/* do delayed ACK's			*/
#define	TCBF_BUFFER	0x40	/* do TCP buffering (default no)	*/
#define	TCBF_SND_FIN	0x80	/* user process has closed; snd a FIN	*/

#include "p_tcpip.h"
DCHAR	Tcp_iReceiveHeaderLen;

UCHAR SeqCmp(PXCHAR pData1,PXCHAR pData2);
void  TcbListen();
BOOLEAN CheckRstFlag();
void TcbAckit();
UCHAR TcbAcked();
void TcbData();
void  TcbFin1();
void TcbFin2();
void TcbSynSent();
void 	TcbSynRcvd();
void TcbEstablished();
void TcbCloseWait();
void  TcbLastAck();
void TcbClosing();
void  TcbSetCurrent(PXCHAR pDataBuf)
{
pCurrTcb=pDataBuf;
pTcbRcvNext=pCurrTcb+0x000c;
pTcbSndNext=pCurrTcb+0x0010;
pCurrTcbSendUnackSeq=pCurrTcb+0x0014;
pCurrTcbRemoteIP=pCurrTcb+0x0008;

}


void TcbSendPacket()
{   
 ULONG lHeaderSum,lCHECKSUM;
 DSHORT iCheckSum;
  p_memcpy_x2x(pTcpData,Adapter_pReceiveMacAddress,6); 
  p_memcpy_x2x(pCurrTcbPacket_IP_DST,Adapter_pReceiveIPAddress,4);  
  pTcpData[0x0f]=0x28; //ip_len=40
  lHeaderSum=PXCHAR2ULONG(pTcpHeaderCkSum);
  lCHECKSUM=IpModifyCheckSum(lHeaderSum,Adapter_pReceiveIPAddress);
  IpCheckSum(lCHECKSUM,pCurrTcbPacket_EP_DATA);
   pTcpData[0x30]=0;
   pTcpData[0x31]=0;
   iCheckSum=TcpCheckSum(0x14,pTcpData); 
   pTcpData[0x30]=P_HIBYTE(iCheckSum);
   pTcpData[0x31]=P_LOBYTE(iCheckSum);
   Ne2000Send(0x36,pTcpData);//send len=54 (mac+ip +tcp)header
}
void TcbAlloc()  //init syn packet and state
{
pCurrTcb->state=01; //client   closed=1
pCurrTcb->flags=FREE; //server state free
pCurrTcb->code=2; //flag=syn 
RandSting(pTcbSndNext,4);
p_memcpy_x2x(pCurrTcbSendUnackSeq,pTcbSndNext,4);

}

void TcbDeAlloc()  
{
pCurrTcb->state=0; //receive status=0 closed
*(pCurrTcb+0x18)=01; //tcps_free  =1 ff=use  
Tcp_bCloseEvent=1;
}
BOOLEAN	TcbInit(PXCHAR ptcb, UCHAR iListenPortHi, UCHAR iListenPortLo)
{
  
   pBuf=ptcb;
   ptcb->local_port_hi=iListenPortHi;
  ptcb->local_port_lo=iListenPortLo;
  ptcb->state=0;  //listen
    *(pBuf+0x18)=0x01; 
   ptcb->snd_size=0;  //send size
    
   return (TRUE);
}
 //check receive packet if is  Local port
BOOLEAN	TcbCheckData(PXCHAR pData)
{
   
    if((*(Adapter_pReceivePacket+2)) ^ (*(pData+4)))
    {
  	 return FALSE;
	 }
	 if((*(Adapter_pReceivePacket+3)) ^ (*(pData+5)))
    {
     return FALSE;
	 }
     
    return TRUE;
}

void	TcbRun(PXCHAR pCurrTcbBuf)// tcb input module 
{
     DCHAR Tcp_iReceiveHeaderLen;
   DCHAR istate;
    TcbSetCurrent(pCurrTcbBuf);
    Tcp_iReceiveHeaderLen=((*(Adapter_pReceivePacket+0x0c)&0xf0)>>2);//get tcp header size
    Adapter_pReceiveTcpData=Adapter_pReceivePacket+Tcp_iReceiveHeaderLen;//tcp data
	if(Adapter_iReceiveLen<Tcp_iReceiveHeaderLen) //receive data size<tcp header size
	    TcpReset();
	 Adapter_iReceiveLen-=Tcp_iReceiveHeaderLen; 
    if(*(Adapter_pReceivePacket+0x0d)&0x10) //ack=1
	    bReceiveAckFlag=1;
	else 
	    bReceiveAckFlag=0;
   if(*(Adapter_pReceivePacket+0x0d)&0x04) //rst=1
	     bReceiveRstFlag=1;
	else 
	    bReceiveRstFlag=0;
	if(*(Adapter_pReceivePacket+0x0d)&0x02) //syn=1
	     bReceiveSynFlag=1;
	else 
	    bReceiveSynFlag=0;
	if(*(Adapter_pReceivePacket+0x0d)&0x01) //fin=1
	     bReceiveFinFlag=1;
	else 
	    bReceiveFinFlag=0;
   istate=pCurrTcb->state;// getreceive state
   if (!istate)
	{ 
      TcbListen();  //state=0
      return;
    }
    if ((*(pCurrTcb+0x06)!=*(Adapter_pReceivePacket))||(*(pCurrTcb+0x07)!=*(Adapter_pReceivePacket+1)))
    {
      TcpReset(); //compare remote port
	  return;
    }  
    if(p_memcmp_x2x(pCurrTcbRemoteIP,Adapter_pReceiveIPAddress,4))
    {
      TcpReset();  //compare remote ip
     return;
    }
    	
    if ((istate>=0x04)&&(p_memcmp_x2x(pTcbRcvNext,pTcpRcvSeq,4)))
    {
        TcbAckit();
        return;
    } 
   	if (istate==0x07)
   {
        TcbFin1();//7
	   	return;
    }
   else if(istate<0x07)
    {
      istate=istate+0xfd ; 
      switch (istate)
      {
      case 0: 
            TcbSynSent(); //3
	        return;
	  case 1:	 
		   	TcbSynRcvd(); //4
			return;
	  case 2:						
		   TcbEstablished();//5
			return;
	  case 3:	
		   TcbCloseWait();///6
			 return;
	   default:
		   return;
      }  
   }
  
   //*pCurrTcb>0x07
  
       	istate=istate+0xf8;
        switch (istate)
        {
        case 0: 
        	   TcbFin2();// 8
			   return;
	    case 1:	   
			   TcbLastAck();//9
				return;
		case 2:
		      TcbClosing();//10
			    return;
		default:
               return;
	    }	
   } //TcbRrun  
BOOLEAN TcbHandleTimer(PXCHAR pBuf)
{
 DCHAR i;
 DCHAR iRemotePortHigh,iRemotePortLow;
 PXCHAR iRemoteIp;
 TcbSetCurrent(pBuf);
 i=*(pCurrTcb+0x1b);//rexmitcount
 i--;
 if(!i)
 {
       i=3;
        if(*(pCurrTcb+0x1a)<5)
        {
          iRemoteIp=TcbGetRemoteIP(pCurrTcb);
          iRemotePortHigh=TcbGetRemotePortHi(pCurrTcb); 
          iRemotePortLow=TcbGetRemotePortLo(pCurrTcb); 
       //   DebugString1(iRemoteIp,iRemotePortHigh,0x1022);
          *(pCurrTcb+0x1a)=*(pCurrTcb+0x1a)+1;
	   	  Ne2000WaitPacket();
		  Ne2000Send(*(pCurrTcb+0x19),pTcpSendPacket);
		}
		else
		  return FALSE;
  }

    *(pCurrTcb+0x1b)=i;    
     return TRUE;
}
     
UCHAR SeqCmp(PXCHAR pSource,PXCHAR pDst)
{
    DLONG lTemp1,lTemp2;
  lTemp1=PXCHAR2ULONG(pSource);
  lTemp2=PXCHAR2ULONG(pDst); 
  lTemp1-=lTemp2;
   if (lTemp1==0) return 0;
   lTemp2=0x80000000;
   if (lTemp1>lTemp2) 
         return 1;
   return 2;
  
}


BOOLEAN TcbClosed(PXCHAR pCurrTcb)
{
  PXCHAR pBuf;
  pBuf=pCurrTcb;
   if(pCurrTcb->state)
        return TRUE; 
   else
       return FALSE; 
}
UCHAR	TcbGetLocalPortHi(PXCHAR pCurrTcb)
{
   return *(pCurrTcb+4);
}
PXCHAR	TcbGetRemoteIP(PXCHAR pCurrTcb)
{  
  return (pCurrTcb+0x08);
}
UCHAR	TcbGetLocalPortLo(PXCHAR pCurrTcb)
{
     return *(pCurrTcb+5);
}
UCHAR	TcbGetRemotePortHi(PXCHAR pCurrTcb)
{
return *(pCurrTcb+0x06);
}
UCHAR	TcbGetRemotePortLo(PXCHAR pCurrTcb)
{
return *(pCurrTcb+0x07);
}
void TcbListen()
{
  if (bReceiveRstFlag) 
    return;
  if (bReceiveAckFlag||!bReceiveSynFlag) 
  {
   TcpReset();
   return;
   }
  // Tcp_bAcceptEvent=1;
   TcbAlloc();
   pCurrTcb->state=SYNRCVD ; // synrcvd status 
   *(pCurrTcb+6)=*(Adapter_pReceivePacket);
   *(pCurrTcb+7)=*(Adapter_pReceivePacket+1);  //local port
  //*(pCurrTcb+4)=*(Adapter_pReceivePacket+2);
  //*(pCurrTcb+5)=*(Adapter_pReceivePacket+3);
   p_memcpy_x2x(pTcbRcvNext,pTcpRcvSeq,4);
   SeqAdd(1,pTcbRcvNext);
   pCurrTcb->code |= TCP_ACK |TCP_SYN;// ack=1 syn=1
   pCurrTcb->flags=TCBF_NEEDOUT; //connect  status =idle  1  
   Tcp_bAcceptEvent=1; //send Tcp_bAcceptEvent 
   TcpPrepareData();

}
void SeqAdd(UCHAR Len,PXCHAR pData)
  {
   ULONG iTemp;
   iTemp=PXCHAR2ULONG(pData)+(ULONG)Len;
   ULONG2PUCHAR(iTemp,pData);
   }
BOOLEAN CheckRstFlag()
{
  if (bReceiveRstFlag)
  {     
      TcbDeAlloc();
	     return  TRUE;
   }
   if (bReceiveSynFlag)
   {
      TcpReset();
	  TcbDeAlloc();
	  
	  return TRUE;
   }
   
   return FALSE;
 }

void TcbAckit()
{
  if(bReceiveRstFlag) return; 
  if((!Adapter_iReceiveLen)&&(!bReceiveSynFlag)&&(!bReceiveFinFlag))//tcp data length=0
     return;  
   *(pTcpData+0x20)=*(Adapter_pReceivePacket+2);
   *(pTcpData+0x21)=*(Adapter_pReceivePacket+3);// copy souce port
   *(pTcpData+0x22)=*(Adapter_pReceivePacket); 
   *(pTcpData+0x23)=*(Adapter_pReceivePacket+1);//copy dst port
   p_memcpy_x2x(pCurrTcbPacket_TCP_SEQ,pTcbSndNext,4);//copy Tcp seq
   p_memcpy_x2x(pCurrTcbPacket_TCP_ACK,pTcbRcvNext,4);//copy tcp ack
   *(pTcpData+0x2d)=0x10; //ack=1
   *(pTcpData+0x2f)=TCPMAXPACKETLEN;  //window size=197
   *(pTcpData+0x2c)=0x50; //data offset
   TcbSendPacket();
}

UCHAR TcbAcked()//check ack 
{
   DCHAR i;
   bdata UCHAR flags;
   if (!bReceiveAckFlag) 
   { 
     i=3;    
     return i;
   }
   if(!p_memcmp_x2x(pTcpRcvAckSeq,pTcbSndNext,4))
   {
     *(pCurrTcb+0x18)=0x01; //send acked
      p_memcpy_x2x(pCurrTcbSendUnackSeq,pTcpRcvAckSeq,4);
     if(pCurrTcb->code & TCP_SYN)//syn=1
       pCurrTcb->code &=~TCP_SYN; //syn=0
    if(pCurrTcb->code & TCP_FIN) //fin=1
     {
         pCurrTcb->code &=~TCP_FIN; //fin=0
         pCurrTcb->flags &=~TCBF_SND_DONE; //server status.4=0  server fin
     }
     i=0;
     return i;
   }    
  i=SeqCmp(pTcpRcvAckSeq,pCurrTcbSendUnackSeq);
  if (i==1) //pTcpRcvAckSeq>pCurrTcbSendUnackSeq //error
  {
    TcbAckit();//send ack packet
    i=2;
    return i;
   }
  i=1;
  return i; //pTcpRcvAckSeq<=pCurrTcbSendUnackSeq
}
void TcbData()
{
   DCHAR i;
   i=Adapter_iReceiveLen;
   if(i!=0)
   {
      SeqAdd(i,pTcbRcvNext);
      pCurrTcb->flags |=TCBF_NEED_OUT;//connect  status 
       pCurrTcb->code |=TCP_ACK;  //ack=1
      Tcp_bDataEvent=TRUE;//send  Tcp_bDataEvent
    }
   if (!bReceiveFinFlag) return;
   //if bReceiveFinFlag=1
   pCurrTcb->flags |=TCBF_RDONE|TCBF_NEED_OUT; //received finished      
    pCurrTcb->code |=TCP_ACK;  //ack=1
    SeqAdd(1,pTcbRcvNext);
    Tcp_bCloseEvent=TRUE;  //set  Tcp_bCloseEvent
} 
void TcbFin1()
{
    DCHAR i;  
	 bdata UCHAR status,flags;

   if(CheckRstFlag()) return;
    i=TcbAcked();
    if(i>1)  return; //error
    TcbData();
    if(pCurrTcb->flags&TCBF_RDONE)  //if no more to receive
    {
     
      if(pCurrTcb->code & TCP_FIN) // receive fin=1
         pCurrTcb->state=CLOSING;//enter closing status
      else //fin acked
      {
         TcbDeAlloc(); 
       //  Tcp_bFreeEvent=1;
      }
     return;
    }
  
    if(pCurrTcb->code & TCP_FIN) // fin =1
       return;
    pCurrTcb->state=TCPS_FINWAIT2; //enter fin2 status
  } 
void TcbFin2()
{
    DCHAR i;  
    if(CheckRstFlag())  return;
    i=TcbAcked();
    if (i>1)
       return; //error
    TcbData();
     if(!(pCurrTcb->flags&TCBF_RDONE)) return; //check if server done
    TcbDeAlloc();
    //Tcp_bFreeEvent=1;
 } 
void TcbSynSent()
{
  bdata UCHAR flags;
   if((bReceiveAckFlag)&&(p_memcmp_x2x(pTcpRcvAckSeq,pTcbSndNext,4)))
   { 
        TcpReset();
        return;
   }
    if (bReceiveRstFlag)
    {
      TcbDeAlloc();
      return;
    }
    if (!bReceiveSynFlag) return;
    p_memcpy_x2x(pTcbRcvNext,pTcpRcvSeq,4);
    SeqAdd(1,pTcbRcvNext);
    TcbAcked();
    if(pCurrTcb->code & TCP_SYN)//syn=1 
    {
       pCurrTcb->code|=TCP_ACK|TCP_SYN;//ack=1 syn=1
      pCurrTcb->state=SYNRECVD;//enter syn recvd status
    }
    else
    {
        pCurrTcb->code |=TCP_ACK; //ack=1
       pCurrTcb->state=EATABLISHED; //enter eatablished status
        Tcp_bConnectEvent=1; //send Tcp_bConnectEvent
     }
     pCurrTcb->flags=TCBF_NEED_OUT; 
  }

void TcbSynRcvd()
{ 
  bdata UCHAR flags;
   if(CheckRstFlag())   return;
   if (!bReceiveAckFlag) return;
   if(p_memcmp_x2x(pTcpRcvAckSeq,pTcbSndNext,4)) return;
   *(pCurrTcb+0x18)=1;//new tcb
   p_memcpy_x2x(pCurrTcbSendUnackSeq,pTcpRcvAckSeq,4);
  
   if (pCurrTcb->code & TCP_SYN) //syn=1
     pCurrTcb->code &=~TCP_SYN; //syn=0
    pCurrTcb->state=TCPS_ESTABLISHED; //enter established status
	Tcp_bConnectEvent=1;//send Tcp_bConnectEvent
	TcbData();
 }


void TcbEstablished()
{
    if(CheckRstFlag())  return;
    if(TcbAcked()) return; //error
     TcbData();
     if(!(pCurrTcb->flags&TCBF_RDONE)) return; //server status !=4
   pCurrTcb->state=TCPS_CLOSEWAIT;//enter closewait status
 }

void TcbCloseWait()
{
    if(CheckRstFlag())   return;
   TcbAcked();//ack fin
}

void TcbLastAck()
{ 
  DCHAR i;
  if(CheckRstFlag())  return ;
   i=TcbAcked();
    if(!i)
   { 
      TcbDeAlloc();
     // Tcp_bFreeEvent=1;
	  return;
   }
   if (i!=1) return;
p_memcmp_x2x(pTcbSndNext,pCurrTcbSendUnackSeq,4);
return;  
}


void TcbClosing() //等待对Fin 的确认
{
   if(CheckRstFlag())   return;
    TcbAcked();
  
    if(pCurrTcb->code& TCP_FIN) return;//fin=1 fin packet unreach
    TcbDeAlloc();
  //  Tcp_bFreeEvent=1;

}