tcp.c

这是南开大学实验室开发的基于51单片机的TCP-IP通信协议,有较高的参考性

				return;
			}

			/* insert this tcb to tcb list isn't need. because
			this tcb is already insert at TCPSocket()*/

			/* initial new tcb value*/
			pNewTCB->TCPState	= TCP_STATE_SYNRECVD; //进入被动打开状态
			pNewTCB->IPDest		= pIPHead->IPScr;	  //更新当前套接字本地IP不需更新
			pNewTCB->PortDest	= pTCPHead->PortScr;
			pNewTCB->PortScr	= pTCPHead->PortDest;

			pNewTCB->SeqHis = pTCPHead->Seq + 1;	/* syn is use 1 
													sequence */
			pNewTCB->WndHis = pTCPHead->WndSize;

			/* set accept function. when pNewTCB accept this
			connection call pTCB->accetp */
			pNewTCB->accept = pTCB->accept;			

			/* send syn+ack */
			TCPSendSeg(pNewTCB,TCPAllocate(0),TCP_SYN | TCP_ACK);//回法同步确认信号//与窗口大小无关
		}
		break;
	case TCP_STATE_SYNRECVD: //当前处于被动打开状态

		/* ack: to TCP_STATE_ESTABLISHED */
		if((pTCPHead->flag & TCP_ACK) != 0)	 //如果收到的是确认信号
			pTCB->TCPState = TCP_STATE_ESTABLISHED;	//就进入数据传送阶段

		/* call accept. Let user to know and deal more */
		pTCB->accept(pTCB);	     //回调该函数通知客户可以接受数据交换

		break;
	case TCP_STATE_SYNSENT:	  //当前处于主动打开状态
		switch(pTCPHead->flag)
		{
		case TCP_SYN:  //只收到同步信号
			/* syn: to TCP_STATE_SYNRECVD send syn+ack */

			pTCB->TCPState = TCP_STATE_SYNRECVD; //被动打开

			/* ackseq initial */
			pTCB->SeqHis = pTCPHead->Seq + 1;	/* syn use 1 sequence */

			TCPSendSeg(pTCB,TCPAllocate(0),	TCP_SYN | TCP_ACK);	//回送确认信号 同时打开
			break;
		case TCP_SYN | TCP_ACK:			 //收到同步和确认信号
			/* syn+ack: to TCP_STATE_ESTABLISHED send ack */
	
			pTCB->TCPState = TCP_STATE_ESTABLISHED; // 进入数据传送阶段

			/* ackseq initial */
			pTCB->SeqHis = pTCPHead->Seq + 1;	/* syn use 1 sequence */

			TCPSendSeg(pTCB,TCPAllocate(0),TCP_ACK);  //进行第3次握手
			break;
		case TCP_RST | TCP_ACK:  //收到复位和确认信号
			/* rst: to closed */
			pTCB->TCPState = TCP_STATE_CLOSED;	//进入（异常）关闭状态
			TCPRelease(pTCB);
			break;
		}
		break;
	case TCP_STATE_ESTABLISHED:	//当前处于数据传送阶段
		/* fin:to closewait send ack */
		if((pTCPHead->flag & TCP_FIN) != 0)   //收到关闭命令
		{
			pTCB->TCPState = TCP_STATE_CLOSEWAIT;
			TCPSendSeg(pTCB,TCPAllocate(0),	TCP_ACK);  //发送确认命令

			/* call ->close() let user to know he want to close connection 
			user should call TCPClose() to close the connection in ->close */
			pTCB->close(pTCB);
		}
		break;
	case TCP_STATE_CLOSEWAIT:    //服务器被动关闭等待状态         
		/* he want to close, send a fin to close */
		pTCB->TCPState = TCP_STATE_LASTACK;	 // 进入最后握手阶段    
		pTCB->LastAckTimer = TCP_LASTACK_TIME_OUT;
		TCPSendSeg(pTCB,TCPAllocate(0),	TCP_FIN | TCP_ACK);	  //发送关闭确认信号
		break;
	case TCP_STATE_FINWAIT1:  //主动关闭
		switch(pTCPHead->flag)
		{
		case TCP_FIN:     
			/* fin: to TCP_STATE_CLOSING send ack */
			pTCB->TCPState = TCP_STATE_CLOSING;	  //同时关闭状态
			TCPSendSeg(pTCB,TCPAllocate(0),	TCP_ACK);  //发送确认信号
			break;
		case TCP_FIN | TCP_ACK: //同时收到确认和结束信号
			pTCB->TCPState = TCP_STATE_TIMEWAIT;  //进入本地等待
			pTCB->LastAckTimer = TCP_LASTACK_TIME_OUT;	/* start timer */
			TCPSendSeg(pTCB,TCPAllocate(0),	TCP_ACK); //发送最后握手信号
			break;
		case TCP_ACK:
			pTCB->TCPState = TCP_STATE_FINWAIT2;  //进入半关闭
			break;
		}
		break;
	case TCP_STATE_CLOSING:		//同时关闭
		/* ack:to TCP_STATE_CLOSED */
		if(pTCPHead->flag & TCP_ACK)  //如果收到确认信号
		{
			pTCB->TCPState = TCP_STATE_TIMEWAIT;
			pTCB->LastAckTimer = TCP_LASTACK_TIME_OUT;	/* start timer */
		}
		break;
	case TCP_STATE_FINWAIT2:        
		if(pTCPHead->flag & TCP_FIN)
		{
			pTCB->TCPState = TCP_STATE_TIMEWAIT;
			pTCB->LastAckTimer = TCP_LASTACK_TIME_OUT;	/* start timer */
			TCPSendSeg(pTCB,TCPAllocate(0),	TCP_ACK);
		}
		break;
	}

	/*
	 * put tcp data to uper layer 
	 */
	if(TCPDataSize != 0)
	{
		pTCB->recv(MemHead->pStart + TCP_HEAD_LEN(pTCPHead),TCPDataSize);
	}

	/*
	 * free this packet 
	 */
	MemFree(MemHead);
}

/* tcp packet in.*/
void TCPInput(struct SMemHead DT_XDATA *MemHead) REENTRANT_SIG	//输入处理模块
{
	struct SIPHead  DT_XDATA *pIPHead;
	struct STCPHead DT_XDATA *pTCPHead;
	struct STCB		DT_XDATA *pNewTCB;
	struct STCB	DT_XDATA *pTCB;
	
	pTCPHead = (struct STCPHead DT_XDATA *)(MemHead->pStart);
	pIPHead	 = (struct SIPHead  DT_XDATA *)(MemHead->pStart - sizeof(struct SIPHead));

	/*
	 * is check sum ok? 
	 */
	if(TCPCheckSum(pIPHead,ntohs(pIPHead->TotalLen) - IP_HEAD_MIN_LEN) != 0)
	{		
		MemFree(MemHead);
		return;
	}

	/* 
	 * is there a connection can accept this tcp packet?
	 */

	/* if is syn packet. a tcb in listen can accept it. */
	if(pTCPHead->flag == TCP_SYN)
	{
		for(pTCB = TCBList; pTCB != NULL; pTCB = pTCB->pNext)
		{
			if(pTCB->TCPState == TCP_STATE_LISTEN &&
				pTCB->PortScr == pTCPHead->PortDest)
			{
				break;
			}
		}
	}
	else
	{
		/* search active connections. TCBState must not the 
		closed and listen state */
		for(pTCB = TCBList; pTCB != NULL; pTCB = pTCB->pNext)
		{
			/* and the source ip, dest ip, source port, dest port
				must equal */								  //寻找可用连接
			if(pTCB->PortScr == pTCPHead->PortDest &&
				pTCB->PortDest == pTCPHead->PortScr &&
				pTCB->TCPState != TCP_STATE_LISTEN &&
				pTCB->TCPState != TCP_STATE_CLOSED &&
				pTCB->IPScr  == pIPHead->IPDest &&
				pTCB->IPDest == pIPHead->IPScr)
				break;
			
		}
	}

	/* can't find, and send a rst */
	if(pTCB == NULL)	  //找不到这样的连接请求复位
	{
		/* allocate a temp tcb for use */
		pNewTCB = TCPSocket(ntohl(pIPHead->IPDest));
		pNewTCB->IPDest 	= pIPHead->IPScr;
		pNewTCB->PortDest 	= pTCPHead->PortScr;
		pNewTCB->PortScr	= pTCPHead->PortDest;
		
		/* set MemFree DataSize to 0 */
		MemHead->pStart = MemHead->pEnd;

		TCPSendSeg(pNewTCB,TCPAllocate(0),TCP_ACK | TCP_RST);

		MemFree(MemHead);
		TCPAbort(pNewTCB);
		return;
	}

	/* 
	 *  is it a expected packet? 
	 */
	/* first change all necessary part to host order */
 #ifndef HOST_ORDER_AS_NET
	pTCPHead->AckSeq	= ntohl(pTCPHead->AckSeq);
	pTCPHead->Seq		= ntohl(pTCPHead->Seq);
	pTCPHead->WndSize	= ntohs(pTCPHead->WndSize);
#endif

	/* if it is the first packet from him, don't check sequence.
	   in connection case: a syn or syn+ack packet. in listen case
	   : a syn packet. so pass all packet contain syn flag */
	if((pTCPHead->flag & TCP_SYN) == 0)
	{
		/* sequence ok? */
		if(pTCB->SeqHis != pTCPHead->Seq)
		{
			/* if this a packet fall within rev window */
			if(TCP_SEQ_COMPARE(pTCPHead->Seq,pTCB->SeqHis) > 0
				&& TCP_SEQ_COMPARE(pTCPHead->Seq,pTCB->SeqHis) < pTCB->WndMine)
			{
				/* write it to QExceedSeq for late receive */
				TCPInsertQ(&(pTCB->QExceedSeq),MemHead,pTCPHead->Seq);
				return;
			}
			else
			{
				/* packet fall outof window, drop it. and send a ack back, because 
				this is probably ocurr when our pre send ack is lose.*/
				MemFree(MemHead);
				TCPSendSeg(pTCB,TCPAllocate(0),TCP_ACK);
				return;
			}
		}/* else sequence equal. ok */
	}/* else is syn packet */
	
	/* deal incoming packet */
	TCPRecvSeg(pTCB,MemHead);  //处理接收的包

	/* if seg in ExceedSeq can receive now? */
	while(pTCB->QExceedSeq != NULL &&
		pTCB->SeqHis == pTCB->QExceedSeq->Seq)
	{
		TCPRecvSeg(pTCB,pTCB->QExceedSeq->MemHead);
		TCPOutQ(&(pTCB->QExceedSeq));
	}
}

BOOL TCPSendEx(struct STCB DT_XDATA * pTCB,struct SMemHead DT_XDATA *MemHead) REENTRANT_MUL
{
	/* if state is "closed, listen, syn recvd, syn sent", 	  //快速发送模块
	need connected first */
	if(pTCB->TCPState <= TCP_STATE_SYNSENT)	//如果没有建立连接就释放内存并返回
	{
		MemFree(MemHead);
		return FALSE;
	}
	
	/* if unsend queue is empty */
	if(pTCB->QUnSend == NULL)  //如果上次不存在未发出队列
	{
		/* if this packet send completely? */
		if(TCPSendSegJudgeWnd(pTCB,MemHead) == FALSE)  //发送数据带有窗口检测
		{
			/* insert the remain for later sending */
			return TCPInsertQ(&(pTCB->QUnSend),MemHead,0);//表示本次发送失败
		}
		else
			return TRUE;	//表示发送成功
	}
	else
		return TCPInsertQ(&(pTCB->QUnSend),MemHead,0);
}

BOOL TCPSend(struct STCB DT_XDATA * pTCB,void DT_XDATA *buf,WORD DataSize) REENTRANT_MUL
{
	struct SMemHead DT_XDATA *MemHead;
	
	/* allocate */
	if((MemHead = TCPAllocate(DataSize)) == NULL) //分配缓冲区
		return FALSE;

	/* copy */
	MemCopy(MemHead->pStart,buf,DataSize);	//把数据导入pStart开始的地方

	return TCPSendEx(pTCB,MemHead);	//把数据发到套节字指定的TCP插口
}
								  //建立连接
BOOL TCPConnect(struct STCB DT_XDATA * pTCB, DWORD DestIP, WORD DestPort,						
						void (DT_CODE * recv)(void DT_XDATA * buf,WORD size) REENTRANT_MUL,
						void (DT_CODE * close)(struct STCB DT_XDATA * pSocket) REENTRANT_MUL) REENTRANT_SIG
{
	/* is it in closed state? */
	if(pTCB->TCPState != TCP_STATE_CLOSED) //如果处于关闭状态返回错误标志
		return FALSE;

	/* tcb renew */
	pTCB->IPDest	= htonl(DestIP);  //刷新套节字
	pTCB->PortDest  = htons(DestPort);
	pTCB->recv	 = recv;
	pTCB->close	 = close;

	/* send syn */
	if(TCPSendSeg(pTCB,TCPAllocate(0),TCP_SYN) == TRUE)
	{
		pTCB->TCPState = TCP_STATE_SYNSENT;	//主动打开状态

		/* wait for establish */
		while(TRUE)
		{
			switch(pTCB->TCPState)
			{
			case TCP_STATE_ESTABLISHED:	//正常等待进入数据传送状态
				return TRUE;
			case TCP_STATE_CLOSED:   //异常进入关闭状态
				/* 1. if receive a rst packet from him
				   2. retransmittimes exceed sreshold */
				return FALSE;
			}
		}
	}
	else
		return FALSE;
}
/* call this func to innitiate closing a connection. connection
will not close unless peer send a fin also.*/
void TCPClose(struct STCB DT_XDATA *pTCB) REENTRANT_MUL
{
	if(pTCB->TCPState != TCP_STATE_CLOSED)	//目前处于非关闭状态
	{
		switch(pTCB->TCPState)
		{
		case TCP_STATE_LISTEN:	 //监听状态（服务器）
			/* close right now */
			pTCB->TCPState = TCP_STATE_CLOSED;
			break;
		case TCP_STATE_SYNRECVD: //被动打开
			/* close when peer send a fin */
			pTCB->TCPState = TCP_STATE_FINWAIT1;
			TCPSendSeg(pTCB,TCPAllocate(0),TCP_FIN | TCP_ACK); //发送关闭，确认命令	同时关闭？？？？
			break;
		case TCP_STATE_SYNSENT:	//主动打开
			/* close right now */
			pTCB->TCPState = TCP_STATE_CLOSED; //内部关闭并释放内存
			TCPRelease(pTCB);
			break;
		case TCP_STATE_ESTABLISHED:	 //数据交换
			/* close when peer send a fin */
			pTCB->TCPState = TCP_STATE_FINWAIT1; //主动关闭等待
			TCPSendSeg(pTCB,TCPAllocate(0),TCP_FIN | TCP_ACK);
			break;
		case TCP_STATE_CLOSEWAIT:	  //被动关闭  （服务器）
			/* close when lastack time out */
			pTCB->TCPState = TCP_STATE_LASTACK;
			pTCB->LastAckTimer = TCP_LASTACK_TIME_OUT;
			TCPSendSeg(pTCB,TCPAllocate(0),TCP_FIN | TCP_ACK);
			break;
		}
	}
}

BOOL TCPListen(struct STCB DT_XDATA *pTCB,WORD ScrPort,
			   void (DT_CODE * accept)(struct STCB DT_XDATA *pNewTCB) REENTRANT_MUL) REENTRANT_MUL
{
	struct STCB DT_XDATA *pTCBt;

	/* is it in closed state? */
	if(pTCB->TCPState != TCP_STATE_CLOSED)	//只有当前状态处于关闭时方可进入监听状态
		return FALSE;

	ScrPort = htons(ScrPort);

	/* is there any other socket already listen in this port? */
	for(pTCBt = TCBList; pTCBt != NULL; pTCBt = pTCBt->pNext) //是否已经有套节字征用了此端口
	{
		if(pTCBt->PortScr == ScrPort)						 //如果有就报错
			return FALSE;
	}

	/* renew tcb */
	pTCB->PortScr = ScrPort;
	pTCB->TCPState = TCP_STATE_LISTEN;
	pTCB->accept   = accept;

	return TRUE;
}

struct STCB DT_XDATA * TCPSocket(IP_ADDR ScrIP) REENTRANT_SIG  //套节字
{															   //返回一个套节字
	struct STCB DT_XDATA * pTCB;
	struct STCB DT_XDATA * pTCBt;
	WORD MaxScrPort;	/* max port number in use */

	/* get a tcb */
	if((pTCB = TCPGetTCB()) == NULL)
	{
		return NULL;
	}

	/* allocate a scrport. that is number of 
	the highest	number of port in use add 1 */
	for(pTCBt = TCBList,MaxScrPort = TCP_DEFAULT_PORT;
		pTCBt != NULL; pTCBt = pTCBt->pNext)
	{
		if(ntohs(pTCBt->PortScr) > MaxScrPort)   //找出最大客户端口号
			MaxScrPort = ntohs(pTCBt->PortScr);
	}
	pTCB->PortScr = htons((WORD)(MaxScrPort + 1)); //最大端口号加1

	/* other tcb set */
	pTCB->TCPState	= TCP_STATE_CLOSED;
	pTCB->IPScr		= htonl(ScrIP);
	pTCB->WndMine	= MemFreeSize();	      //最大空余缓存
	pTCB->bNeedAck	= FALSE;				  //无须确认
	pTCB->QExceedSeq	= NULL;
	pTCB->QUnacked		= NULL;
	pTCB->QUnSend		= NULL;

	/* Insert int tcb */
	TCPInsertTCB(pTCB);

	return pTCB;
}

/* reclaim TCB */
void TCPAbort(struct STCB DT_XDATA *pTCB) REENTRANT_SIG	 //释放套接字
{
	struct STCB DT_XDATA *pTCBt;

	TCPRelease(pTCB);		  //释放内存

	/*
	 * search through the tcb list and delete it from list
	 */
	/* if it is the hear of the list */
	if(TCBList == pTCB)	             
	{
		TCBList = TCBList->pNext;
	}
	else
	{
		/* else search start from the second one */
		for(pTCBt = TCBList; pTCBt != NULL; pTCBt = pTCBt->pNext)
		{
			if(pTCBt->pNext == pTCB)
			{
				pTCBt->pNext = pTCB->pNext;
				break;
			}
		}
	}

	/* reclaim it. link it to TCBFreelist */
	pTCB->pNext = TCBFreeList;
	TCBFreeList = pTCB;
}
/* this func is called by user to allocate a packet and pstart
point to TCPplayload */
struct SMemHead DT_XDATA *TCPAllocate(WORD size) REENTRANT_SIG
{
	struct SMemHead DT_XDATA * MemHead;
	if((MemHead = MemAllocate((WORD)(ALL_HEAD_SIZE + size))) == NULL)
		return NULL;
	else
	{
		/* point to the tcp data */
		MemHead->pStart += ALL_HEAD_SIZE;
		return MemHead;
	}
}