tcp.c.bak

一种操作系统源码核

	    bReceiveSynFlag=0;
    if(ptcp->code & TCPF_FIN) //fin=1
	     bReceiveFinFlag=1;
    else
	    bReceiveFinFlag=0;
   state=pCurrentTcb->state;// getreceive state
   if (state==TCPS_CLOSED)
	{
      TcbListen();  //state=0
      return;
    }
    if ((pCurrentTcb->remote_port_high!=ptcp->local_port_high) ||(pCurrentTcb->remote_port_low!=ptcp->local_port_low))
    {
      TcpReset(); //compare remote port
	  return;
    }
    if(p_memcmp_x2x(pTcb_PeerIP,pPeerIPAddress,4))
    {
      TcpReset();  //compare remote ip
     return;
    }

    if ((state>=TCPS_SYNRCVD)&&(p_memcmp_x2x(pTcb_RcvNext,pTcp_RcvSeq,4)))
    {
        TcbAckit();
        return;
    }
   if (state==TCPS_FINWAIT1)
   {
        TcbFin1();//7
	   	return;
    }
   else if(state<TCPS_FINWAIT1)
    {
      state=state+0xfd ;
      switch (state)
      {
      case 0:
            TcbSynSent(); //3
	        return;
	  case 1:
		   	TcbSynRcvd(); //4
			return;
	  case 2:
		   TcbEstablished();//5
			return;
	  case 3:
		   TcbCloseWait();///6
			 return;
	   default:
		   return;
      }
   }

   //*pCurrentTcb>0x07

       	state=state+0xf8;
        switch (state)
        {
        case 0:
        	   TcbFin2();// 8
			   return;
	    case 1:
			   TcbLastAck();//9
				return;
		case 2:
		      TcbClosing();//10
			    return;
		default:
               return;
	    }
   } //TcbRrun




BOOLEAN TcbClosed(INT8U * ptcb)
{
  struct tcb *tcb_ptr;
   tcb_ptr=(struct tcb *)ptcb;
   if(tcb_ptr->state)
        return TRUE;
   else
       return FALSE;
}

void TcbListen()
{

  if (bReceiveRstFlag)
    return;
  if (bReceiveAckFlag||!bReceiveSynFlag)
  {
   TcpReset();
   return;
   }
   pCurrentTcb->code=TCPF_SYN; //flag=syn    
   RandSting(pTcb_SndNext,4);
   p_memcpy_x2x(pTcb_SndUnAck,pTcb_SndNext,4); 
   pCurrentTcb->state=SYNRCVD; // synrcvd status
   pCurrentTcb->remote_port[0]=*(Adapter_pRcvPacket);
   pCurrentTcb->remote_port[1]=*(Adapter_pRcvPacket+1);  //local port
  //*(pCurrentTcb+4)=*(Adapter_pRcvPacket+2);
  //*(pCurrentTcb+5)=*(Adapter_pRcvPacket+3);
   p_memcpy_x2x(pTcb_RcvNext,pTcp_RcvSeq,4);
   SeqAdd(pTcb_RcvNext,1);
   pCurrentTcb->code |= TCP_ACK |TCP_SYN;// ack=1 syn=1
   pCurrentTcb->flag=TCBF_NEEDOUT; //connect  status =idle  1
   Tcp_bAcceptEvent=1; //send Tcp_bAcceptEvent
   TcpPrepareData();

}


void TcbAckit()
{
  struct tcp *ptcpout;
  ptcpout  =(struct tcp *)Tcp_Packet_Buffer;
  struct tcp	*ptcpin = (struct tcp *)Adapter_pRcvPacket;
  if(bReceiveRstFlag) return;
  if((!Adapter_iRcvLen)&&(!bReceiveSynFlag)&&(!bReceiveFinFlag))//tcp data length=0
     return;
     ptcpout->local_port_high = ptcpin->remote_port_high;
     ptcpout->local_port_low = ptcpin->remote_port_low;
    ptcpout->remote_port_high = ptcpin->local_port_high;
    ptcpout->remote_port_low = ptcpin->local_port_low;

   p_memcpy_x2x(pTcp_SndSeq,pTcb_SndNext,4);//copy Tcp seq
   p_memcpy_x2x(pTcp_SndAck,pTcb_RcvNext,4);//copy tcp ack
   ptcpout->code = TCPF_ACK;
   ptcpout->offset = TCP_MIN_OFFSET;
   ptcpout->tcp_window = TCPMAXPACKETLEN;  //window size=197

   TcbSendPacket();
}

INT8U TcbAcked()//check ack
{
   DCHAR i;
   bdata INT8U flag;
   if (!bReceiveAckFlag)
   {
     i=3;
     return i;
   }
   if(!p_memcmp_x2x(pTcp_RcvAck,pTcb_SndNext,4))
   {
     pCurrentTcb->acked=TRUE; //send acked
      p_memcpy_x2x(pTcb_SndUnAck,pTcp_RcvAck,4);
     if(pCurrentTcb->code & TCP_SYN)//syn=1
       pCurrentTcb->code &=~TCP_SYN; //syn=0
    if(pCurrentTcb->code & TCP_FIN) //fin=1
     {
         pCurrentTcb->code &=~TCP_FIN; //fin=0
         pCurrentTcb->flag &=~TCBF_SND_FIN; //server status.4=0  server fin
     }
     i=0;
     return i;
   }
  i=SeqCmp(pTcp_RcvAck,pTcb_SndUnAck);
  if (i==1) //pTcp_RcvAck>pTcb_SndUnAck //error
  {
    TcbAckit();//send ack packet
    i=2;
    return i;
   }
  i=1;
  return i; //pTcp_RcvAck<=pTcb_SndUnAck
}
void TcbData()
{
   DCHAR i;
   i=Adapter_iRcvLen;
   if(i!=0)
   {
      SeqAdd(pTcb_RcvNext,i);
      pCurrentTcb->flag |=TCBF_NEED_OUT;//connect  status
       pCurrentTcb->code |=TCP_ACK;  //ack=1
     Tcp_bDataEvent=TRUE;//send  Tcp_bDataEvent
     
    }
   if (!bReceiveFinFlag) return;
   //if bReceiveFinFlag=1
   pCurrentTcb->flag |=TCBF_RCV_DONE|TCBF_NEED_OUT; //received finished
    pCurrentTcb->code |=TCP_ACK;  //ack=1
    SeqAdd(pTcb_RcvNext,1);
    Tcp_bCloseEvent=TRUE;  //set  Tcp_bCloseEvent
    TcpSend(0);
}
void TcbFin1()
{
    DCHAR i;
	 bdata INT8U status,flag;

   if(CheckRstFlag()) return;
    i=TcbAcked();
    if(i>1)  return; //error
    TcbData();
    if(pCurrentTcb->flag&TCBF_RCV_DONE)  //if no more to receive
    {

      if(pCurrentTcb->code & TCP_FIN) // receive fin=1
         pCurrentTcb->state=TCPS_CLOSING;//enter closing status
      else //fin acked
      {
         TcbDeAlloc();
       //  Tcp_bFreeEvent=1;
      }
     return;
    }

    if(pCurrentTcb->code & TCP_FIN) // fin =1
       return;
    pCurrentTcb->state=TCPS_FINWAIT2; //enter fin2 status
  }
void TcbFin2()
{
    DCHAR i;
    if(CheckRstFlag())  return;
    i=TcbAcked();
    if (i>1)
       return; //error
    TcbData();
     if(!(pCurrentTcb->flag&TCBF_RCV_DONE)) return; //check if server done
    TcbDeAlloc();
    //Tcp_bFreeEvent=1;
 }
void TcbSynSent()
{
  bdata INT8U flag;
   if((bReceiveAckFlag)&&(p_memcmp_x2x(pTcp_RcvAck,pTcb_SndNext,4)))
   {
        TcpReset();
        return;
   }
    if (bReceiveRstFlag)
    {
      TcbDeAlloc();
      return;
    }
    if (!bReceiveSynFlag) return;
    p_memcpy_x2x(pTcb_RcvNext,pTcp_RcvSeq,4);
    SeqAdd(pTcb_RcvNext,1);
    TcbAcked();
    if(pCurrentTcb->code & TCP_SYN)//syn=1
    {
       pCurrentTcb->code|=TCP_ACK|TCP_SYN;//ack=1 syn=1
      pCurrentTcb->state=TCPS_SYNRCVD;//enter syn recvd status
    }
    else
    {
        pCurrentTcb->code |=TCP_ACK; //ack=1
       pCurrentTcb->state=TCPS_ESTABLISHED; //enter TCPS_ESTABLISHED status
        Tcp_bConnectEvent=1; //send Tcp_bConnectEvent
     }
     pCurrentTcb->flag =TCBF_NEED_OUT;
     TcpSend(0);
  }

void TcbSynRcvd()
{
  bdata INT8U flag;
   if(CheckRstFlag())   return;
   if (!bReceiveAckFlag) return;
   if(p_memcmp_x2x(pTcp_RcvAck,pTcb_SndNext,4)) return;
   pCurrentTcb->acked=TRUE;//new tcb
   p_memcpy_x2x(pTcb_SndUnAck,pTcp_RcvAck,4);

   if (pCurrentTcb->code & TCP_SYN) //syn=1
     pCurrentTcb->code &=~TCP_SYN; //syn=0
    pCurrentTcb->state=TCPS_ESTABLISHED; //enter established status
	Tcp_bConnectEvent=1;//send Tcp_bConnectEvent
	TcbData();
 }


void TcbEstablished()
{
    if(CheckRstFlag())  return;
    if(TcbAcked()) return; //error
     TcbData();
     if(!(pCurrentTcb->flag&TCBF_RCV_DONE)) return; //server status !=4
   pCurrentTcb->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(pTcb_SndNext,pTcb_SndUnAck,4);
return;
}


void TcbClosing() //等待对Fin 的确认
{
   if(CheckRstFlag())   return;
    TcbAcked();

    if(pCurrentTcb->code& TCP_FIN) return;//fin=1 fin packet unreach
    TcbDeAlloc();
  //  Tcp_bFreeEvent=1;

}
void  TcbSetCurrent(struct tcb *ptcb)
{
pCurrentTcb=ptcb;
pTcb_RcvNext=pCurrentTcb->rcv_next;
pTcb_SndNext=pCurrentTcb->snd_next;
pTcb_SndUnAck=pCurrentTcb->snd_unack;
pTcb_PeerIP=pCurrentTcb->remote_ip;

}

void TcbSendPacket()
{
 INT32U ip_cksum;
 INT16U cksum;
 struct tcp_packet *ptcp;

 ptcp=(sruct tcp_packet *)Tcp_Packet_Buffer;

  p_memcpy_x2x(ptcp->ep_dst,pPeerMacAddress,EP_ALEN);//copy dst mac address
  p_memcpy_x2x(pTcp_PeerIp,pPeerIPAddress,IP_ALEN);
  ptcp->ip_len=IPMHLEN+TCPMHLEN; //ip_len=40
  ip_cksum=pTcp_IpCkSum;
  IpModifyCheckSum(pPeerIPAddress,&ip_cksum);
  IpCheckSum(pEp_EpData,ip_cksum);
   ptcp->tcp_cksum[0]=0;
     ptcp->tcp_cksum[1]=0;
     cksum=TcpCheckSum(Tcp_Packet_Buffer,TCPMHLEN);

    ptcp->tcp_cksum[0]=P_HIBYTE(cksum);
     ptcp->tcp_cksum[1]=P_LOBYTE(cksum);

   Ne2000Send(EP_MIN_LEN,Tcp_Packet_Buffer);//send len=54 (mac+ip +tcp)header
}
INT8U	TcbGetLocalPortHi(struct tcb * ptcb)
{
   return (ptcb->local_port_high);
}
INT8U *	TcbGetPeerIP(struct tcb *  ptcb)
{
 INT8U * ip_ptr;
 ip_ptr=&(pCurrentTcb->remote_ip_high)
  return ip_ptr;
}
INT8U	TcbGetLocalPortLo(struct tcb *  ptcb)
{
     return (ptcb->local_port_low);
}
INT8U	TcbGetPeerPortHi(struct tcb * ptcb)
{
return (ptcb->remote_port_high);
}
INT8U	TcbGetPeerPortLo(struct tcb *  ptcb)
{
return (ptcb->remote_port_low);
}
INT8U SeqCmp(INT8U * pSource,INT8U * pDst)
{
    DLONG lTemp1,lTemp2;
  lTemp1=INT8U *2INT32U(pSource);
  lTemp2=INT8U *2INT32U(pDst);
  lTemp1-=lTemp2;
   if (lTemp1==0) return 0;
   lTemp2=0x80000000;
   if (lTemp1>lTemp2)
         return 1;
   return 2;

}

void SeqAdd(INT8U * pData,INT8U Len)
  {
   INT32U iTemp;
   iTemp=INT8U *2INT32U(pData)+(INT32U)Len;
   INT32U2PINT8U(iTemp,pData);
   }
BOOLEAN CheckRstFlag()
{
  if (bReceiveRstFlag)
  {
      TcbDeAlloc();
	     return  TRUE;
   }
   if (bReceiveSynFlag)
   {
      TcpReset();
	  TcbDeAlloc();

	  return TRUE;
   }

   return FALSE;
 }