void TCPReceiveRenew(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead,WORD PacketSize)
{
	BYTE page,Pos;
	BYTE AckRetranPackets;	


	tcb.DestinationWindowSize = pTCPHead->WindowSize;
	

	tcb.AckSequence += PacketSize;
	if((pTCPHead->flag & TCP_SYN) != 0 || (pTCPHead->flag & TCP_FIN))
		tcb.AckSequence++;
	

	if((pTCPHead->flag & TCP_ACK) != 0)
	{
		AckRetranPackets = FALSE;

	
		while(tcb.SequenceOfRetransmit[tcb.QueueRetransmit.ReadPos] - pTCPHead->AckSequence >= 0x80000000 )
		{
			Pos = tcb.QueueRetransmit.ReadPos;	

			if((page = ReadQueue(&(tcb.QueueRetransmit),READ_AND_DELETE)) == PAGE_NOT_FOUND)
				break;

			/* 釋放*/
			tcb.QueueRetransmitLength--;
			FreePage(page);

		
			if(tcb.FlagOfRetransmit[Pos] == TRUE)
				AckRetranPackets = TRUE;
		}

	
		while(tcb.QueueRetransmitLength > TRANSMIT_OVER_QUEUE_RETRANSMIT_LENGTH && 
			tcb.FlagOfRetransmit[tcb.QueueRetransmit.ReadPos] == FALSE)
		{
			page = ReadQueue(&(tcb.QueueRetransmit),READ_AND_DELETE);
			FreePage(page);
			tcb.QueueRetransmitLength--;
		}

	
		if(AckRetranPackets == TRUE)
		{
			Pos = tcb.QueueRetransmit.ReadPos;
			
			while(Pos != tcb.QueueRetransmit.WritePos)
			{
				if(tcb.FlagOfRetransmit[Pos] == TRUE)
					break;
				else
				{
					Pos++;
					if(Pos == tcb.QueueRetransmit.QueueSize)
						Pos = 0;
				}
			}

			if(Pos == tcb.QueueRetransmit.WritePos)
			{
			
				TCPTimer.enable = FALSE;
			}
			else
			{
				/* 重設置時鐘*/
				TCPTimer.enable = TRUE;
				TCPTimer.value = TCP_RETRNSMIT_TIME_OUT;
			}
			TCPRetransmitTime = 0;
		}
	}
	
	StateTransformFunc[tcb.TCP_state](pTCPHead,pIPHead);
}


void TCPIn()
{
	BYTE page;
	struct MemHeader xdata *pMemHead;
	struct IPHeader xdata *pIPHead;
	struct TCPHeader xdata *pTCPHead;
	WORD DataSize;
	BYTE IPHeadSize;
	BYTE TCPHeadSize;

	
	if((page = ReadQueue(&(tcb.QueueTCPIn),READ_AND_DELETE)) != PAGE_NOT_FOUND)
	{
		/* 獲得pIPHead */
		pMemHead = (struct MemHeader xdata *)MemPageToPoint(page);
		pIPHead = (struct IPHeader xdata *)pMemHead->StartPos;
		IPHeadSize = (pIPHead->Version_HeadLength & 0x0f)*4;

		/* 獲得pTCPHead */
		pTCPHead = (struct TCPHeader xdata *)((BYTE xdata *)pIPHead + IPHeadSize);
		TCPHeadSize = ((pTCPHead->TCPHeadLength & 0xf0)>>4)*4;
		DataSize = pIPHead->TotalLength - IPHeadSize - TCPHeadSize;

		/* 校驗和ok? */
		if(TCPCheckSum(pIPHead,TCPHeadSize + DataSize) == 0)
		{		
			
			if(TCPPortOK(pTCPHead,pIPHead) == TRUE )
			{
				
			
				if(TCPExpectedPacket(pTCPHead) == TRUE )
				{
			
					/* 更新tcb */
					TCPReceiveRenew(pTCPHead,pIPHead,DataSize);

					
					if(DataSize != 0)
					{		
						pMemHead->StartPos += IPHeadSize + TCPHeadSize;
						TCPOnReceive(pMemHead->StartPos,DataSize);
					}
				}
			}
	
		}
		FreePage(page);
	}
}


void TCPOut()
{
	BYTE page;
	BYTE Pos;
	

	if(TCPTimer.enable == TRUE && TCPTimer.value == 0)
	{

		for(Pos = tcb.QueueRetransmit.ReadPos;tcb.FlagOfRetransmit[Pos] == FALSE;)
		{
			Pos++;
			if(Pos == tcb.QueueRetransmit.QueueSize)
				Pos = 0;
		}

		page = tcb.QueueRetransmit.pQueue[Pos];
		WriteQueue(page,&(tcb.QueueTCPOut));

		TCPRetransmitTime++;
		TCPTimer.value = TCP_RETRNSMIT_TIME_OUT;
	}

	
	/* closed, listen, syn recvd, syn sent state, */
	if(tcb.TCP_state <= TCP_STATE_SYNSENT)
		return;


	if(tcb.QueueRetransmitLength > ALARM_QUEUE_RETRANSMIT_LENGTH)
		return;


	if((page = ReadQueue(&(tcb.QueueApplicationOut),READ_AND_DELETE)) == PAGE_NOT_FOUND)
		return;


	TCPSendPacket(page,TCP_ACK);
}


void TCPIPProcess()
{
	RTLReceivePacket();
	TCPOut();
	IPProcess();
	NetInProcess();
	TCPIn();
}

/*假如對方想關閉連接 */
BYTE TCPPeerClosing()
{
	
	if(ARPRetrasmitTime >= ARP_MAX_RETRNSMIT_TIME)
	{
		TCPReleaseBuffer();
		return ARP_RETRANSMIT_TOO_MUCH;
	}

	/
	if(TCPRetransmitTime >= TCP_MAX_RETRNSMIT_TIME)
	{
		TCPReleaseBuffer();
		return TCP_RETRANSMIT_TOO_MUCH;
	}
	
	/* 假如對方想關閉連接 */
	if(tcb.TCP_state >= TCP_STATE_CLOSEWAIT)
		return PEER_WANT_TO_CLOSE;

	return TCP_NO_PROBLEM;
}
/* 初始化 socket */
void TCPSocket()
{
	QueueInitial(&(tcb.QueueApplicationOut),QUEUE_SIZE_APPLICATION_OUT);
	QueueInitial(&(tcb.QueueRetransmit),QUEUE_SIZE_RETRANSMIT);
	QueueInitial(&(tcb.QueueTCPIn),QUEUE_SIZE_TCP_IN);
	QueueInitial(&(tcb.QueueTCPOut),QUEUE_SIZE_TCP_OUT);
}

/* 綁定.*/
void TCPBind(WORD scrPort)
{
	/* 清空對列 */
	tcb.QueueApplicationOut.ReadPos = tcb.QueueApplicationOut.WritePos = 0;
	tcb.QueueRetransmit.ReadPos = tcb.QueueRetransmit.WritePos = 0;
	tcb.QueueTCPIn.ReadPos = tcb.QueueTCPIn.WritePos = 0;
	tcb.QueueTCPOut.ReadPos = tcb.QueueTCPOut.WritePos = 0;

	/*重傳初始化*/
	tcb.QueueRetransmitLength = 0;

	/* 端口*/
	tcb.SourcePort = scrPort;

	/* 對列 */
	tcb.Sequence = 0;

	/* 窗口大小*/
	tcb.SourceWindowSize = TCP_SOURCE_WINDOW_SIZE;

	/*狀態(tài)*/
	tcb.TCP_state = TCP_STATE_CLOSED;

	/* 初始化時鐘 */
	TCPTimer.enable = FALSE;
	TCPRetransmitTime = 0;
}

/* 用戶連接*/
BYTE TCPConnect(DWORD DestIP,WORD DestPort)
{


	/* tcb 更新 */
	tcb.DestinationIP = DestIP;
	tcb.DestinationPort = DestPort;
	
	/* state 變換 */
	tcb.TCP_state = TCP_STATE_SYNSENT;

	/* 發(fā)送同步 */
	TCPSendPacket(TCPAllocateWithoutData(),TCP_SYN);

	/*等待建立*/
	while(TRUE)
	{
		
		TCPIPProcess();
		TCPIPProcess();

		if(tcb.TCP_state == TCP_STATE_ESTABLISHED)
			return TRUE;


		if(tcb.TCP_state == TCP_STATE_CLOSED)
		{
			TCPReleaseBuffer();
			return FALSE;
		}

		if(TCPPeerClosing() != TCP_NO_PROBLEM)
		{
			TCPReleaseBuffer();
			return FALSE;
		}
	}
}

/*發(fā)送*/
BYTE TCPSend(BYTE xdata *buff,WORD size)
{
	BYTE page;
	BYTE HeadSize;
	struct MemHeader xdata *pMemHead;

	HeadSize = sizeof(struct MACHeader)+sizeof(struct IPHeader)+sizeof(struct TCPHeader);

	/* 分配一頁，發(fā)送 */
	if((page = MemAllocation(HeadSize+size)) == PAGE_NOT_FOUND)
		return FALSE;
	pMemHead = (struct MemHeader xdata *)MemPageToPoint(page);
	pMemHead->StartPos = (BYTE xdata *)pMemHead + HeadSize + sizeof(struct MemHeader);
	pMemHead->StopPos = pMemHead->StartPos + size;
	MemCopy(pMemHead->StartPos,buff,size);
	if(WriteQueue(page,&(tcb.QueueApplicationOut)) == PAGE_NOT_FOUND)
	{
		FreePage(page);
		return FALSE;
	}
	else
	{
		return TRUE;
	}
}

BYTE xdata *UserAllocate(BYTE data * pPage,WORD size)
{
	int AllHeadSize;
	AllHeadSize = sizeof(struct MACHeader)+sizeof(struct IPHeader)+sizeof(struct TCPHeader)+ sizeof(struct MemHeader);

	if((*pPage = MemAllocation(AllHeadSize - sizeof(struct MemHeader) + size)) == PAGE_NOT_FOUND)
		return NULL;
	else
		return MemPageToPoint(*pPage) + AllHeadSize;
}

BYTE TCPFastSend(BYTE page,WORD size)
{
	struct MemHeader xdata *pMemHead;
	
	if(tcb.TCP_state < TCP_STATE_ESTABLISHED)
		return FALSE;
	
	pMemHead = (struct MemHeader xdata *)MemPageToPoint(page);
	pMemHead->StartPos = (BYTE xdata *)pMemHead + sizeof(struct MACHeader)
		+ sizeof(struct IPHeader) + sizeof(struct TCPHeader) + sizeof(struct MemHeader);
	pMemHead->StopPos = pMemHead->StartPos + size;
	if(WriteQueue(page,&(tcb.QueueApplicationOut)) == PAGE_NOT_FOUND)
	{
		return FALSE;
	}
	else
	{
		return TRUE;
	}
}
/* 用戶close*/
void TCPClose()
{
	BYTE PeerState;

	/* state: listen,Synrecvd,synsent,established,closewait */
	while(tcb.TCP_state != TCP_STATE_CLOSED)
	{
		/* 延時*/
		

		switch(tcb.TCP_state)
		{
		case TCP_STATE_LISTEN:
			tcb.TCP_state = TCP_STATE_CLOSED;
			break;
		case TCP_STATE_SYNRECVD:
			tcb.TCP_state = TCP_STATE_FINWAIT1;
			TCPSendPacket(TCPAllocateWithoutData(),TCP_FIN | TCP_ACK);
			break;
		case TCP_STATE_SYNSENT:
			tcb.TCP_state = TCP_STATE_CLOSED;
			break;
		case TCP_STATE_ESTABLISHED:
			tcb.TCP_state = TCP_STATE_FINWAIT1;
			TCPSendPacket(TCPAllocateWithoutData(),TCP_FIN | TCP_ACK);
			break;
		case TCP_STATE_CLOSEWAIT:
			tcb.TCP_state = TCP_STATE_CLOSED;
			TCPSendPacket(TCPAllocateWithoutData(),TCP_FIN | TCP_ACK);
			break;
		}

	
		TCPIPProcess();
		TCPIPProcess();
		TCPIPProcess();
		PeerState = TCPPeerClosing();
		if(PeerState == TCP_RETRANSMIT_TOO_MUCH || PeerState == ARP_RETRANSMIT_TOO_MUCH)
			break;
	}
	TCPReleaseBuffer();	/* 關閉 */
}

void TCPListen()
{
	

	tcb.TCP_state = TCP_STATE_LISTEN;
	
}