📄 uip.lst
字号:
539 3 }
540 2 }
541 1 }
542 #endif /* UIP_TCP */
543 /*---------------------------------------------------------------------------*/
544 #if UIP_TCP
545 void
546 uip_listen(u16_t port)
547 {
548 1 for(c = 0; c < UIP_LISTENPORTS; ++c) {
549 2 if(uip_listenports[c] == 0) {
550 3 uip_listenports[c] = port;
C51 COMPILER V9.00 UIP 02/08/2010 20:58:31 PAGE 10
551 3 return;
552 3 }
553 2 }
554 1 }
555 #endif /* UIP_TCP */
556 /*---------------------------------------------------------------------------*/
557 /* XXX: IP fragment reassembly: not well-tested. */
558
559 #if UIP_REASSEMBLY && !UIP_CONF_IPV6
#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)
static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];
static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];
static const u8_t bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f,
0x0f, 0x07, 0x03, 0x01};
static u16_t uip_reasslen;
static u8_t uip_reassflags;
#define UIP_REASS_FLAG_LASTFRAG 0x01
static u8_t uip_reasstmr;
#define IP_MF 0x20
static u8_t
uip_reass(void)
{
u16_t offset, len;
u16_t i;
/* If ip_reasstmr is zero, no packet is present in the buffer, so we
write the IP header of the fragment into the reassembly
buffer. The timer is updated with the maximum age. */
if(uip_reasstmr == 0) {
memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN);
uip_reasstmr = UIP_REASS_MAXAGE;
uip_reassflags = 0;
/* Clear the bitmap. */
memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap));
}
/* Check if the incoming fragment matches the one currently present
in the reasembly buffer. If so, we proceed with copying the
fragment into the buffer. */
if(BUF->srcipaddr[0] == FBUF->srcipaddr[0] &&
BUF->srcipaddr[1] == FBUF->srcipaddr[1] &&
BUF->destipaddr[0] == FBUF->destipaddr[0] &&
BUF->destipaddr[1] == FBUF->destipaddr[1] &&
BUF->ipid[0] == FBUF->ipid[0] &&
BUF->ipid[1] == FBUF->ipid[1]) {
len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;
/* If the offset or the offset + fragment length overflows the
reassembly buffer, we discard the entire packet. */
if(offset > UIP_REASS_BUFSIZE ||
offset + len > UIP_REASS_BUFSIZE) {
uip_reasstmr = 0;
goto nullreturn;
}
/* Copy the fragment into the reassembly buffer, at the right
offset. */
memcpy(&uip_reassbuf[UIP_IPH_LEN + offset],
C51 COMPILER V9.00 UIP 02/08/2010 20:58:31 PAGE 11
(char *)BUF + (int)((BUF->vhl & 0x0f) * 4),
len);
/* Update the bitmap. */
if(offset / (8 * 8) == (offset + len) / (8 * 8)) {
/* If the two endpoints are in the same byte, we only update
that byte. */
uip_reassbitmap[offset / (8 * 8)] |=
bitmap_bits[(offset / 8 ) & 7] &
~bitmap_bits[((offset + len) / 8 ) & 7];
} else {
/* If the two endpoints are in different bytes, we update the
bytes in the endpoints and fill the stuff inbetween with
0xff. */
uip_reassbitmap[offset / (8 * 8)] |=
bitmap_bits[(offset / 8 ) & 7];
for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {
uip_reassbitmap[i] = 0xff;
}
uip_reassbitmap[(offset + len) / (8 * 8)] |=
~bitmap_bits[((offset + len) / 8 ) & 7];
}
/* If this fragment has the More Fragments flag set to zero, we
know that this is the last fragment, so we can calculate the
size of the entire packet. We also set the
IP_REASS_FLAG_LASTFRAG flag to indicate that we have received
the final fragment. */
if((BUF->ipoffset[0] & IP_MF) == 0) {
uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;
uip_reasslen = offset + len;
}
/* Finally, we check if we have a full packet in the buffer. We do
this by checking if we have the last fragment and if all bits
in the bitmap are set. */
if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {
/* Check all bytes up to and including all but the last byte in
the bitmap. */
for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {
if(uip_reassbitmap[i] != 0xff) {
goto nullreturn;
}
}
/* Check the last byte in the bitmap. It should contain just the
right amount of bits. */
if(uip_reassbitmap[uip_reasslen / (8 * 8)] !=
(u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {
goto nullreturn;
}
/* If we have come this far, we have a full packet in the
buffer, so we allocate a pbuf and copy the packet into it. We
also reset the timer. */
uip_reasstmr = 0;
memcpy(BUF, FBUF, uip_reasslen);
/* Pretend to be a "normal" (i.e., not fragmented) IP packet
from now on. */
BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
C51 COMPILER V9.00 UIP 02/08/2010 20:58:31 PAGE 12
BUF->len[0] = uip_reasslen >> 8;
BUF->len[1] = uip_reasslen & 0xff;
BUF->ipchksum = 0;
BUF->ipchksum = ~(uip_ipchksum());
return uip_reasslen;
}
}
nullreturn:
return 0;
}
#endif /* UIP_REASSEMBLY */
688 /*---------------------------------------------------------------------------*/
689 #if UIP_TCP
690 static void
691 uip_add_rcv_nxt(u16_t n)
692 {
693 1 uip_add32(uip_conn->rcv_nxt, n);
694 1 uip_conn->rcv_nxt[0] = uip_acc32[0];
695 1 uip_conn->rcv_nxt[1] = uip_acc32[1];
696 1 uip_conn->rcv_nxt[2] = uip_acc32[2];
697 1 uip_conn->rcv_nxt[3] = uip_acc32[3];
698 1 }
699 #endif /* UIP_TCP */
700 /*---------------------------------------------------------------------------*/
701 void
702 uip_process(u8_t flag)
703 {
704 1 #if UIP_TCP
705 1 register struct uip_conn *uip_connr = uip_conn;
706 1 #endif /* UIP_TCP */
707 1
708 1 #if UIP_UDP
709 1 if(flag == UIP_UDP_SEND_CONN) {
710 2 goto udp_send;
711 2 }
712 1 #endif /* UIP_UDP */
713 1
714 1 uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
715 1
716 1 /* Check if we were invoked because of a poll request for a
717 1 particular connection. */
718 1 #if UIP_TCP
719 1 if(flag == UIP_POLL_REQUEST) {
720 2 if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED &&
721 2 !uip_outstanding(uip_connr)) {
722 3 uip_flags = UIP_POLL;
723 3 UIP_APPCALL();
724 3 goto appsend;
725 3 }
726 2 goto drop;
727 2
728 2 /* Check if we were invoked because of the perodic timer fireing. */
729 2 } else if(flag == UIP_TIMER) {
730 2 #if UIP_REASSEMBLY
if(uip_reasstmr != 0) {
--uip_reasstmr;
}
#endif /* UIP_REASSEMBLY */
735 2 /* Increase the initial sequence number. */
736 2 if(++iss[3] == 0) {
C51 COMPILER V9.00 UIP 02/08/2010 20:58:31 PAGE 13
737 3 if(++iss[2] == 0) {
738 4 if(++iss[1] == 0) {
739 5 ++iss[0];
740 5 }
741 4 }
742 3 }
743 2
744 2 /* Reset the length variables. */
745 2 uip_len = 0;
746 2 uip_slen = 0;
747 2
748 2 /* Check if the connection is in a state in which we simply wait
749 2 for the connection to time out. If so, we increase the
750 2 connection's timer and remove the connection if it times
751 2 out. */
752 2 if(uip_connr->tcpstateflags == UIP_TIME_WAIT ||
753 2 uip_connr->tcpstateflags == UIP_FIN_WAIT_2) {
754 3 ++(uip_connr->timer);
755 3 if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {
756 4 uip_connr->tcpstateflags = UIP_CLOSED;
757 4 }
758 3 } else if(uip_connr->tcpstateflags != UIP_CLOSED) {
759 3 /* If the connection has outstanding data, we increase the
760 3 connection's timer and see if it has reached the RTO value
761 3 in which case we retransmit. */
762 3 if(uip_outstanding(uip_connr)) {
763 4 if(uip_connr->timer-- == 0) {
764 5 if(uip_connr->nrtx == UIP_MAXRTX ||
765 5 ((uip_connr->tcpstateflags == UIP_SYN_SENT ||
766 5 uip_connr->tcpstateflags == UIP_SYN_RCVD) &&
767 5 uip_connr->nrtx == UIP_MAXSYNRTX)) {
768 6 uip_connr->tcpstateflags = UIP_CLOSED;
769 6
770 6 /* We call UIP_APPCALL() with uip_flags set to
771 6 UIP_TIMEDOUT to inform the application that the
772 6 connection has timed out. */
773 6 uip_flags = UIP_TIMEDOUT;
774 6 UIP_APPCALL();
775 6
776 6 /* We also send a reset packet to the remote host. */
777 6 BUF->flags = TCP_RST | TCP_ACK;
778 6 goto tcp_send_nodata;
779 6 }
780 5
781 5 /* Exponential backoff. */
782 5 uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4?
783 5 4:
784 5 uip_connr->nrtx);
785 5 ++(uip_connr->nrtx);
786 5
787 5 /* Ok, so we need to retransmit. We do this differently
788 5 depending on which state we are in. In ESTABLISHED, we
789 5 call upon the application so that it may prepare the
790 5 data for the retransmit. In SYN_RCVD, we resend the
791 5 SYNACK that we sent earlier and in LAST_ACK we have to
792 5 retransmit our FINACK. */
793 5 UIP_STAT(++uip_stat.tcp.rexmit);
794 5 switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
795 6 case UIP_SYN_RCVD:
796 6 /* In the SYN_RCVD state, we should retransmit our
797 6 SYNACK. */
798 6 goto tcp_send_synack;
C51 COMPILER V9.00 UIP 02/08/2010 20:58:31 PAGE 14
799 6
800 6 #if UIP_ACTIVE_OPEN
801 6 case UIP_SYN_SENT:
802 6 /* In the SYN_SENT state, we retransmit out SYN. */
803 6 BUF->flags = 0;
804 6 goto tcp_send_syn;
805 6 #endif /* UIP_ACTIVE_OPEN */
806 6
807 6 case UIP_ESTABLISHED:
808 6 /* In the ESTABLISHED state, we call upon the application
809 6 to do the actual retransmit after which we jump into
810 6 the code for sending out the packet (the apprexmit
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -