单片机以太网上网原代码(keil 工程，用RTS8019)--转载

/* * Copyright (c) 2003 Electric Application Laboratory of NAN KAI University * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. * * Author: Li Zhanglin <wzzlin@nankai.edu.cn> * */ #include "..\GloblDef\GloblDef.h" #include "..\TCPIP\TCPIPmem.h" #include "..\TCPIP\IP.h" #include "..\TCPIP\Netif.h" #include "..\TCPIP\TCP.h" struct STCB DT_XDATA TCBPool[TCP_CONNECTION_MAX_NUM]; struct STCB DT_XDATA * DT_XDATA TCBFreeList; /* free list */ struct STCB DT_XDATA * DT_XDATA TCBList; /* tcb in use */ struct SPacketQueue DT_XDATA QPool[TCP_QUEUE_MAX_NUM]; struct SPacketQueue DT_XDATA * DT_XDATA QFreeList; struct STCB DT_XDATA *TCPGetTCB() REENTRANT_SIG { struct STCB DT_XDATA * pTCB; if((pTCB = TCBFreeList) != NULL) { TCBFreeList = TCBFreeList->pNext; } return pTCB; } void TCPInsertTCB(struct STCB DT_XDATA *pTCB) REENTRANT_SIG { pTCB->pNext = TCBList; TCBList = pTCB; } struct SPacketQueue DT_XDATA * TCPGetQ() REENTRANT_SIG { struct SPacketQueue DT_XDATA * pQ; if((pQ = QFreeList) != NULL) { QFreeList = QFreeList->pNext; } return pQ; } /* insert to the head of *ppQ. Q is a double link chain */ BOOL TCPInsertQ(struct SPacketQueue DT_XDATA * DT_XDATA * ppQ,struct SMemHead DT_XDATA *MemHead, DWORD Seq) REENTRANT_SIG { struct SPacketQueue DT_XDATA *pNewQ; struct SPacketQueue DT_XDATA *pQ; /* allocate a queue to it */ if((pNewQ = TCPGetQ()) == NULL) return FALSE; /* write content */ pNewQ->Seq = Seq; pNewQ->MemHead = MemHead; /* * link in the queue */ /* if is a empty queue */ if(*ppQ == NULL) { *ppQ = pNewQ; /* pNext pPre point to itself when no others in queue */ pNewQ->pNext = pNewQ; pNewQ->pPre = pNewQ; } else { pQ = *ppQ; /* pNext link */ pNewQ->pNext = pQ->pNext; pQ->pNext = pNewQ; /* pPre link */ pNewQ->pNext->pPre = pNewQ; pNewQ->pPre = pQ; } return TRUE; } /* move the last unit in queue outof queue,if the queue is empty return FALSE.actrually last unit is *ppQ */ struct SPacketQueue DT_XDATA * TCPOutQ(struct SPacketQueue DT_XDATA * DT_XDATA * ppQ) REENTRANT_SIG { struct SPacketQueue DT_XDATA *pQ; /* a empty queue? */ if((pQ = *ppQ) == NULL) return NULL; /* after remove it, the queue is empty? */ if(pQ->pNext == pQ) *ppQ = NULL; else { /* relink */ pQ->pPre->pNext = pQ->pNext; pQ->pNext->pPre = pQ->pPre; /* and the queue head *ppQ point to pQ->pPre */ *ppQ = pQ->pPre; } /* relaim it. link to QFreeList */ pQ->pNext = QFreeList; QFreeList = pQ; return pQ; } void TCPInit() REENTRANT_MUL { WORD i; /* move TCBPool to TCBFreeList */ for(i = 0, TCBFreeList = NULL; i<TCP_CONNECTION_MAX_NUM; i++) { TCBPool[i].pNext = TCBFreeList; TCBFreeList = &TCBPool[i]; } /* move QPool to QFreeList */ for(i = 0, QFreeList = NULL; i<TCP_QUEUE_MAX_NUM; i++) { QPool[i].pNext = QFreeList; QFreeList = &QPool[i]; } TCBList = NULL; } /* tcp check sum. return check sum. TCPSize = TCPDataSize + TCPHeadSize*/ WORD TCPCheckSum(struct SIPHead DT_XDATA * pIPHead,WORD TCPSize) REENTRANT_SIG { DWORD sum = 0; WORD DT_XDATA * p; BYTE i; /* clac pseudo-header CheckSum. pseudo-header is: source ip, destination ip, pad 8 bits, protocol, TCP lendth */ sum = 0; /* source ip and dest ip */ p = (WORD DT_XDATA *)(&(pIPHead->IPScr)); for(i=0; i < sizeof(DWORD)/sizeof(WORD)*2; i++,p++) sum += *p; /* pad 8 and protocol */ sum += pIPHead->Protocol; /* tcp lendth */ sum += TCPSize; return CheckSum((WORD DT_XDATA *)((BYTE DT_XDATA *)pIPHead + IP_HEAD_MIN_LEN),TCPSize,sum); } /* this funtion should be called periodically */ void TCPTimer() REENTRANT_MUL { struct STCB DT_XDATA *pTCB; /* go through all tcbs to see if any time out */ for(pTCB = TCBList; pTCB != NULL; pTCB = pTCB->pNext) { /* delayed ack need send now? */ if(pTCB->bNeedAck == TRUE) { if(pTCB->DelayAckTimer == 0) { /* send a ack. bNeedAck will set FLASE in TCPOutput*/ TCPSendSeg(pTCB,TCPAllocate(0),TCP_ACK); } else pTCB->DelayAckTimer--; } /* TCP_STATE_LASTACK TCP_STATE_TIMEWAIT state time out? */ if(pTCB->TCPState == TCP_STATE_LASTACK || pTCB->TCPState == TCP_STATE_TIMEWAIT) { if(pTCB->LastAckTimer == 0) { pTCB->TCPState = TCP_STATE_CLOSED; /* release buf queue and call user close */ TCPRelease(pTCB); /* let pTCB->close(); to be call when they send a fin when we at established */ } else pTCB->LastAckTimer--; } /* if retransmit timer out? */ if(pTCB->QUnacked != NULL) { if(pTCB->RetranTimer == 0) { /* retransmit,pStart set to tcpdata */ IPOutput(pTCB->QUnacked->MemHead); /* timer restart and retransmit times inc */ if(pTCB->RetranTimes == TCP_RETRAN_MAX_TIME) { pTCB->TCPState = TCP_STATE_CLOSED; /* closed by countpart shut down */ TCPRelease(pTCB); } else { pTCB->RetranTimes++; pTCB->RetranTimer = TCP_RETRAN_TIME_OUT; } } else pTCB->RetranTimer--; } } } /* when a TCP close, send too much packet but no replay, connection fail. TCPIP will call TCPRelease to release packet and queue, but will not reclaim TCB. in other word user can use this socket again. */ void TCPRelease(struct STCB DT_XDATA *pTCB) REENTRANT_SIG { struct SPacketQueue DT_XDATA *pQ; /* reclaim Q, and free packet in queue */ while(pQ = TCPOutQ(&(pTCB->QExceedSeq))) MemFree(pQ->MemHead); while(pQ = TCPOutQ(&(pTCB->QUnacked))) MemFree(pQ->MemHead); while(pQ = TCPOutQ(&(pTCB->QUnSend))) MemFree(pQ->MemHead); } /* fill a segment and send it,NOTE MemHead->pStart point to TCPData */ BOOL TCPSendSeg(struct STCB DT_XDATA *pTCB,struct SMemHead DT_XDATA *MemHead,BYTE TCPFlag) REENTRANT_SIG { struct STCPHead DT_XDATA *pTCPHead; struct SIPHead DT_XDATA *pIPHead; WORD SeqInc; /* mem insufficient? */ if(MemHead == NULL) return FALSE; /* SeqMine increasment */ if((TCPFlag & TCP_SYN) || (TCPFlag & TCP_FIN)) { SeqInc = MemHead->pEnd - MemHead->pStart + 1; } else { SeqInc = MemHead->pEnd - MemHead->pStart; } pTCPHead = (struct STCPHead DT_XDATA *)(MemHead->pStart - sizeof(struct STCPHead)); /* fill tcp header */ pTCPHead->PortDest = pTCB->PortDest; pTCPHead->PortScr = pTCB->PortScr; pTCPHead->Seq = htonl(pTCB->SeqMine); pTCPHead->AckSeq = htonl(pTCB->SeqHis); pTCPHead->TCPH