tcp.c

arm嵌入式常用模块的程序源代码

#include "GloblDef.h"
#include "RTL8019.h"
#include "NetIntef.h"
#include "IP.h"
#include "ARP.h"
#include "timer.h"
#include "TCP.h"

extern void MemCopy(BYTE xdata * to,BYTE xdata * from,WORD size);
extern BYTE xdata * MemPageToPoint(BYTE page);
extern BYTE MemAllocation(WORD size);
extern void FreePage(BYTE page);
extern BYTE QueueInitial(struct Queue xdata * pq,BYTE size);
extern BYTE WriteQueue(BYTE page,struct Queue xdata *pQueue);
extern BYTE ReadQueue(struct Queue xdata *pQueue,BYTE DeleteOrNot);

extern WORD CheckSum(WORD xdata * buff,WORD size,DWORD InSum);
extern BYTE xdata PageAllocationFlag[SMALL_PAGE_NUM + LARGE_PAGE_NUM];

extern void NetInProcess();
extern void IPProcess();
extern void TCPIn();
extern void TCPOut();
extern void TCPOnReceive(BYTE xdata *buff,WORD size);
extern void RTLReceivePacket();

extern BYTE ARPRetrasmitTime;	          /* arp 重传时间 */
extern struct s_timer xdata ARPTimer;	  /* arp 时钟*/

struct s_TCB xdata tcb;
struct s_timer xdata TCPTimer;	        /* tcp 时钟 */
BYTE TCPRetransmitTime;		              /* tcp包重传时钟 */

void TCPStateClosed(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead);
void TCPStateListen(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead);
void TCPStateSynrecvd(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead);
void TCPStateSynSent(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead);
void TCPStateEstablished(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead);
void TCPStateClosewait(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead);
void TCPStateFinwait1(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead);
void TCPStateClosing(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead);
void TCPStateFinwait2(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead);

typedef void (code *StateTrasType)(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead);

StateTrasType xdata StateTransformFunc[]={
	TCPStateClosed,
	TCPStateListen,
	TCPStateSynrecvd,
	TCPStateSynSent,
	TCPStateEstablished,
	TCPStateClosewait,
	TCPStateFinwait1,
	TCPStateClosing,
	TCPStateFinwait2
	};

/* tcp 校验和 */
WORD TCPCheckSum(struct IPHeader xdata *pIPHead,WORD TCPSize)
{
	DWORD sum = 0;
	WORD xdata * p;
	int i;

	/* 
	   源 ip, 目的 ip,  8 bits, 协议, TCP包长 */
	sum = 0;

	/* 源 ip, 目的 ip */
	p = (WORD xdata *)(&(pIPHead->SourceIP));
	for(i=0; i < sizeof(DWORD)/sizeof(WORD)*2; i++,p++)
		sum += *p;
	
	/* 协议 */
	sum += pIPHead->Protocol;

	/* TCP包长 */
	sum += TCPSize;

	return CheckSum((WORD xdata *)((BYTE xdata *)pIPHead + (pIPHead->Version_HeadLength & 0x0f)*4),TCPSize,sum);
}


/*分配一个tcp 包为空 */
BYTE TCPAllocateWithoutData()
{
	BYTE page;
	struct MemHeader xdata *pMemHead;

	/* 分配 */
	page = MemAllocation(sizeof(struct TCPHeader)+sizeof(struct IPHeader)+sizeof(struct MACHeader));
	if(page == PAGE_NOT_FOUND)
		return page;
	
	/* 设置pos */
	pMemHead = (struct MemHeader xdata *)MemPageToPoint(page);
	pMemHead->StartPos = (BYTE xdata *)pMemHead + sizeof(struct TCPHeader)+sizeof(struct IPHeader)+sizeof(struct MACHeader)+sizeof(struct MemHeader);
	pMemHead->StopPos = pMemHead->StartPos;

	return page;
	
}

/* 这些情况下释放buffer, 包括:
   1.TCPConnection 失败
   2.TCPClose 结束
   3.TCPPeerClosing 发现问题 */
void TCPReleaseBuffer()
{
	BYTE page;


	while((page = ReadQueue(&(tcb.QueueRetransmit),READ_AND_DELETE)) != PAGE_NOT_FOUND)
	{
		FreePage(page);
	}

	
	ARPTimer.enable = FALSE;
	TCPTimer.enable = FALSE;
}

/*填充 tcp 头*/
void TCPFillHead(struct TCPHeader xdata *pTCPHead,BYTE TCPFlag)
{
	/* 填充*/
	pTCPHead->AckSequence = tcb.AckSequence;
	pTCPHead->CheckSum = 0;
	pTCPHead->DestinationPort = tcb.DestinationPort;
	pTCPHead->flag = TCPFlag;
	pTCPHead->Sequence = tcb.Sequence;
	pTCPHead->SourcePort = tcb.SourcePort;
	pTCPHead->TCPHeadLength = (BYTE)(((BYTE)sizeof(struct TCPHeader)/4)<<4);
	pTCPHead->UrgentPoint = 0;
	pTCPHead->WindowSize = tcb.SourceWindowSize;


}

/* 发送包. 发送成功返回 TRUE. */
BYTE TCPSendPacket(BYTE page,BYTE TCPFlag)
{
	struct MemHeader xdata *pMemHead;
	struct IPHeader xdata *pIPHead;
	struct TCPHeader xdata *pTCPHead;
	WORD DataSize;
	BYTE WritePosition;

	/*内存不足 */
	if(page == PAGE_NOT_FOUND)
		return SEND_STATE_MEM_INSUFFICIENT;

	/* 获得 pHead */
	pMemHead = (struct MemHeader xdata *)MemPageToPoint(page);
	pTCPHead = (struct TCPHeader xdata *)(pMemHead->StartPos - sizeof(struct TCPHeader));
	pIPHead = (struct IPHeader xdata *)(pMemHead->StartPos - sizeof(struct TCPHeader) - sizeof(struct IPHeader));
	DataSize = pMemHead->StopPos - pMemHead->StartPos;


	if(WriteQueue(page,&(tcb.QueueRetransmit)) == PAGE_NOT_FOUND)
		return SEND_STATE_RETRANSMIT_FULL;
	if(tcb.QueueRetransmit.WritePos == 0)
		WritePosition = tcb.QueueRetransmit.QueueSize - 1;
	else
		WritePosition = tcb.QueueRetransmit.WritePos - 1;
	tcb.SequenceOfRetransmit[WritePosition] = tcb.Sequence;	
	tcb.QueueRetransmitLength++;	/


	if(DataSize != 0 || (TCPFlag & (TCP_SYN | TCP_FIN)) != 0)
	{
		tcb.FlagOfRetransmit[WritePosition] = TRUE;

		if(TCPTimer.enable == FALSE)
		{
			TCPTimer.enable = TRUE;
			TCPTimer.value = TCP_RETRNSMIT_TIME_OUT;
		}
	}
	else
	{
		tcb.FlagOfRetransmit[WritePosition] = FALSE;
	}

	/* 填充tcp 头*/
	TCPFillHead(pTCPHead,TCPFlag);


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

	/* 设置 ip*/
	pIPHead->DestinationIP = tcb.DestinationIP;


	pMemHead->StartPos -= sizeof(struct TCPHeader) + sizeof(struct IPHeader);
	

	if(WriteQueue(page,&(tcb.QueueTCPOut)) == PAGE_NOT_FOUND)
	{
		return SEND_STATE_TCP_OUT_FULL;
	}
	else
	{
		return SEND_STATE_SUCCESS;
	}
}

BYTE TCPPortOK(struct TCPHeader xdata * pTCPHead,struct IPHeader xdata *pIPHead)
{

	if(pTCPHead->flag == TCP_SYN)
	{

		if(tcb.TCP_state == TCP_STATE_LISTEN)
		{
			if(tcb.SourcePort == pTCPHead->DestinationPort)
				return TRUE;
		}
	}
	else
	{

		if(tcb.TCP_state != TCP_STATE_CLOSED && tcb.TCP_state != TCP_STATE_LISTEN)
		{

			if(tcb.SourcePort == pTCPHead->DestinationPort &&
				tcb.DestinationPort == pTCPHead->SourcePort &&
				tcb.DestinationIP == pIPHead->SourceIP)
				return TRUE;
		}
	}
	return FALSE;
}


BYTE TCPExpectedPacket(struct TCPHeader xdata *pTCPHead)
{

	if(pTCPHead->flag & TCP_SYN)
		return TRUE;

	/* sequence ok */
	if(tcb.AckSequence == pTCPHead->Sequence)
		return TRUE;
	else
	{

		if(tcb.TCP_state > TCP_STATE_SYNSENT || tcb.TCP_state == TCP_STATE_SYNRECVD)
		{
			TCPSendPacket(TCPAllocateWithoutData(),TCP_ACK);
		}
		return FALSE;
	}
}



/* TCP state closed */
void TCPStateClosed(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead)
{
}
/* TCP state listen */
void TCPStateListen(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead)
{

	if(pTCPHead->flag == TCP_SYN)
	{
		tcb.TCP_state = TCP_STATE_SYNRECVD;
		tcb.DestinationIP = pIPHead->SourceIP;
		tcb.DestinationPort = pTCPHead->SourcePort;
		
	
		tcb.AckSequence = pTCPHead->Sequence + 1;	/* syn is use 1 sequence */

	
		TCPSendPacket(TCPAllocateWithoutData(),TCP_SYN | TCP_ACK);
	}
}

void TCPStateSynrecvd(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead)
{

	if((pTCPHead->flag & TCP_RST) != 0)
		tcb.TCP_state = TCP_STATE_LISTEN;


	if((pTCPHead->flag & TCP_ACK) != 0)
		tcb.TCP_state = TCP_STATE_ESTABLISHED;
}

void TCPStateSynSent(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead)
{

	if(pTCPHead->flag == TCP_SYN)
	{
		tcb.TCP_state = TCP_STATE_SYNRECVD;

		/* 响应初始化 */
		tcb.AckSequence = pTCPHead->Sequence + 1;	/* syn is use 1 sequence */

		TCPSendPacket(TCPAllocateWithoutData(),TCP_SYN | TCP_ACK);
	}

	
	if(pTCPHead->flag == (TCP_SYN | TCP_ACK))
	{
		tcb.TCP_state = TCP_STATE_ESTABLISHED;

		
		tcb.AckSequence = pTCPHead->Sequence + 1;	

		TCPSendPacket(TCPAllocateWithoutData(),TCP_ACK);
	}


	if((pTCPHead->flag & TCP_RST) != 0)
	{
		tcb.TCP_state = TCP_STATE_CLOSED;
		return;
	}
}
/* 建立 */
void TCPStateEstablished(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead)
{
	WORD DataSize;
	BYTE IPHeadSize,TCPHeadSize;

	
	if((pTCPHead->flag & TCP_FIN) != 0)
	{
		tcb.TCP_state = TCP_STATE_CLOSEWAIT;
		TCPSendPacket(TCPAllocateWithoutData(),TCP_ACK);
	}


	IPHeadSize = (pIPHead->Version_HeadLength & 0x0f)*4;
	TCPHeadSize = ((pTCPHead->TCPHeadLength & 0xf0)>>4)*4;
	DataSize = pIPHead->TotalLength - IPHeadSize - TCPHeadSize;
	if(DataSize != 0)
		TCPSendPacket(TCPAllocateWithoutData(),TCP_ACK);
}

void TCPStateClosewait(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead)
{
}

void TCPStateFinwait1(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead)
{

	if(pTCPHead->flag == TCP_FIN)
	{
		tcb.TCP_state = TCP_STATE_CLOSING;
		TCPSendPacket(TCPAllocateWithoutData(),TCP_ACK);
		return;
	}


	if(pTCPHead->flag == (TCP_FIN | TCP_ACK))
	{
		tcb.TCP_state = TCP_STATE_CLOSED;
		TCPSendPacket(TCPAllocateWithoutData(),TCP_ACK);
		return;
	}
	

	if(pTCPHead->flag == TCP_ACK)
	{
		tcb.TCP_state = TCP_STATE_FINWAIT2;
	}

}

void TCPStateClosing(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead)
{
	
	if((pTCPHead->flag & TCP_ACK) != 0)
	{
		tcb.TCP_state = TCP_STATE_CLOSED;
	}
}

void TCPStateFinwait2(struct TCPHeader xdata *pTCPHead,struct IPHeader xdata *pIPHead)
{
	if((pTCPHead->flag & TCP_FIN) != 0)
	{
		tcb.TCP_state = TCP_STATE_CLOSED;
		TCPSendPacket(TCPAllocateWithoutData(),TCP_ACK);
	}
}

/* 接收一个包， tcb 需要更新. */