Revision 31a60e22 slirp/tcp_input.c
| b/slirp/tcp_input.c | ||
|---|---|---|
| 79 | 79 |
tp->t_flags |= TF_DELACK; \ |
| 80 | 80 |
(tp)->rcv_nxt += (ti)->ti_len; \ |
| 81 | 81 |
flags = (ti)->ti_flags & TH_FIN; \ |
| 82 |
tcpstat.tcps_rcvpack++;\
|
|
| 83 |
tcpstat.tcps_rcvbyte += (ti)->ti_len;\
|
|
| 82 |
STAT(tcpstat.tcps_rcvpack++); \
|
|
| 83 |
STAT(tcpstat.tcps_rcvbyte += (ti)->ti_len); \
|
|
| 84 | 84 |
if (so->so_emu) { \
|
| 85 | 85 |
if (tcp_emu((so),(m))) sbappend((so), (m)); \ |
| 86 | 86 |
} else \ |
| ... | ... | |
| 99 | 99 |
tp->t_flags |= TF_DELACK; \ |
| 100 | 100 |
(tp)->rcv_nxt += (ti)->ti_len; \ |
| 101 | 101 |
flags = (ti)->ti_flags & TH_FIN; \ |
| 102 |
tcpstat.tcps_rcvpack++;\
|
|
| 103 |
tcpstat.tcps_rcvbyte += (ti)->ti_len;\
|
|
| 102 |
STAT(tcpstat.tcps_rcvpack++); \
|
|
| 103 |
STAT(tcpstat.tcps_rcvbyte += (ti)->ti_len); \
|
|
| 104 | 104 |
if (so->so_emu) { \
|
| 105 | 105 |
if (tcp_emu((so),(m))) sbappend(so, (m)); \ |
| 106 | 106 |
} else \ |
| ... | ... | |
| 150 | 150 |
i = q->ti_seq + q->ti_len - ti->ti_seq; |
| 151 | 151 |
if (i > 0) {
|
| 152 | 152 |
if (i >= ti->ti_len) {
|
| 153 |
tcpstat.tcps_rcvduppack++;
|
|
| 154 |
tcpstat.tcps_rcvdupbyte += ti->ti_len;
|
|
| 153 |
STAT(tcpstat.tcps_rcvduppack++);
|
|
| 154 |
STAT(tcpstat.tcps_rcvdupbyte += ti->ti_len);
|
|
| 155 | 155 |
m_freem(m); |
| 156 | 156 |
/* |
| 157 | 157 |
* Try to present any queued data |
| ... | ... | |
| 167 | 167 |
} |
| 168 | 168 |
q = (struct tcpiphdr *)(q->ti_next); |
| 169 | 169 |
} |
| 170 |
tcpstat.tcps_rcvoopack++;
|
|
| 171 |
tcpstat.tcps_rcvoobyte += ti->ti_len;
|
|
| 170 |
STAT(tcpstat.tcps_rcvoopack++);
|
|
| 171 |
STAT(tcpstat.tcps_rcvoobyte += ti->ti_len);
|
|
| 172 | 172 |
REASS_MBUF(ti) = (mbufp_32) m; /* XXX */ |
| 173 | 173 |
|
| 174 | 174 |
/* |
| ... | ... | |
| 275 | 275 |
} |
| 276 | 276 |
|
| 277 | 277 |
|
| 278 |
tcpstat.tcps_rcvtotal++;
|
|
| 278 |
STAT(tcpstat.tcps_rcvtotal++);
|
|
| 279 | 279 |
/* |
| 280 | 280 |
* Get IP and TCP header together in first mbuf. |
| 281 | 281 |
* Note: IP leaves IP header in first mbuf. |
| ... | ... | |
| 308 | 308 |
* ti->ti_sum = cksum(m, len); |
| 309 | 309 |
* if (ti->ti_sum) { */
|
| 310 | 310 |
if(cksum(m, len)) {
|
| 311 |
tcpstat.tcps_rcvbadsum++;
|
|
| 311 |
STAT(tcpstat.tcps_rcvbadsum++);
|
|
| 312 | 312 |
goto drop; |
| 313 | 313 |
} |
| 314 | 314 |
|
| ... | ... | |
| 318 | 318 |
*/ |
| 319 | 319 |
off = ti->ti_off << 2; |
| 320 | 320 |
if (off < sizeof (struct tcphdr) || off > tlen) {
|
| 321 |
tcpstat.tcps_rcvbadoff++;
|
|
| 321 |
STAT(tcpstat.tcps_rcvbadoff++);
|
|
| 322 | 322 |
goto drop; |
| 323 | 323 |
} |
| 324 | 324 |
tlen -= off; |
| ... | ... | |
| 375 | 375 |
ti->ti_dst, ti->ti_dport); |
| 376 | 376 |
if (so) |
| 377 | 377 |
tcp_last_so = so; |
| 378 |
++tcpstat.tcps_socachemiss;
|
|
| 378 |
STAT(tcpstat.tcps_socachemiss++);
|
|
| 379 | 379 |
} |
| 380 | 380 |
|
| 381 | 381 |
/* |
| ... | ... | |
| 503 | 503 |
/* |
| 504 | 504 |
* this is a pure ack for outstanding data. |
| 505 | 505 |
*/ |
| 506 |
++tcpstat.tcps_predack;
|
|
| 506 |
STAT(tcpstat.tcps_predack++);
|
|
| 507 | 507 |
/* if (ts_present) |
| 508 | 508 |
* tcp_xmit_timer(tp, tcp_now-ts_ecr+1); |
| 509 | 509 |
* else |
| ... | ... | |
| 511 | 511 |
SEQ_GT(ti->ti_ack, tp->t_rtseq)) |
| 512 | 512 |
tcp_xmit_timer(tp, tp->t_rtt); |
| 513 | 513 |
acked = ti->ti_ack - tp->snd_una; |
| 514 |
tcpstat.tcps_rcvackpack++;
|
|
| 515 |
tcpstat.tcps_rcvackbyte += acked;
|
|
| 514 |
STAT(tcpstat.tcps_rcvackpack++);
|
|
| 515 |
STAT(tcpstat.tcps_rcvackbyte += acked);
|
|
| 516 | 516 |
sbdrop(&so->so_snd, acked); |
| 517 | 517 |
tp->snd_una = ti->ti_ack; |
| 518 | 518 |
m_freem(m); |
| ... | ... | |
| 556 | 556 |
* with nothing on the reassembly queue and |
| 557 | 557 |
* we have enough buffer space to take it. |
| 558 | 558 |
*/ |
| 559 |
++tcpstat.tcps_preddat;
|
|
| 559 |
STAT(tcpstat.tcps_preddat++);
|
|
| 560 | 560 |
tp->rcv_nxt += ti->ti_len; |
| 561 |
tcpstat.tcps_rcvpack++;
|
|
| 562 |
tcpstat.tcps_rcvbyte += ti->ti_len;
|
|
| 561 |
STAT(tcpstat.tcps_rcvpack++);
|
|
| 562 |
STAT(tcpstat.tcps_rcvbyte += ti->ti_len);
|
|
| 563 | 563 |
/* |
| 564 | 564 |
* Add data to socket buffer. |
| 565 | 565 |
*/ |
| ... | ... | |
| 726 | 726 |
tp->t_flags |= TF_ACKNOW; |
| 727 | 727 |
tp->t_state = TCPS_SYN_RECEIVED; |
| 728 | 728 |
tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT; |
| 729 |
tcpstat.tcps_accepts++;
|
|
| 729 |
STAT(tcpstat.tcps_accepts++);
|
|
| 730 | 730 |
goto trimthenstep6; |
| 731 | 731 |
} /* case TCPS_LISTEN */ |
| 732 | 732 |
|
| ... | ... | |
| 767 | 767 |
tcp_rcvseqinit(tp); |
| 768 | 768 |
tp->t_flags |= TF_ACKNOW; |
| 769 | 769 |
if (tiflags & TH_ACK && SEQ_GT(tp->snd_una, tp->iss)) {
|
| 770 |
tcpstat.tcps_connects++;
|
|
| 770 |
STAT(tcpstat.tcps_connects++);
|
|
| 771 | 771 |
soisfconnected(so); |
| 772 | 772 |
tp->t_state = TCPS_ESTABLISHED; |
| 773 | 773 |
|
| ... | ... | |
| 801 | 801 |
m_adj(m, -todrop); |
| 802 | 802 |
ti->ti_len = tp->rcv_wnd; |
| 803 | 803 |
tiflags &= ~TH_FIN; |
| 804 |
tcpstat.tcps_rcvpackafterwin++;
|
|
| 805 |
tcpstat.tcps_rcvbyteafterwin += todrop;
|
|
| 804 |
STAT(tcpstat.tcps_rcvpackafterwin++);
|
|
| 805 |
STAT(tcpstat.tcps_rcvbyteafterwin += todrop);
|
|
| 806 | 806 |
} |
| 807 | 807 |
tp->snd_wl1 = ti->ti_seq - 1; |
| 808 | 808 |
tp->rcv_up = ti->ti_seq; |
| ... | ... | |
| 873 | 873 |
*/ |
| 874 | 874 |
tp->t_flags |= TF_ACKNOW; |
| 875 | 875 |
todrop = ti->ti_len; |
| 876 |
tcpstat.tcps_rcvduppack++;
|
|
| 877 |
tcpstat.tcps_rcvdupbyte += todrop;
|
|
| 876 |
STAT(tcpstat.tcps_rcvduppack++);
|
|
| 877 |
STAT(tcpstat.tcps_rcvdupbyte += todrop);
|
|
| 878 | 878 |
} else {
|
| 879 |
tcpstat.tcps_rcvpartduppack++;
|
|
| 880 |
tcpstat.tcps_rcvpartdupbyte += todrop;
|
|
| 879 |
STAT(tcpstat.tcps_rcvpartduppack++);
|
|
| 880 |
STAT(tcpstat.tcps_rcvpartdupbyte += todrop);
|
|
| 881 | 881 |
} |
| 882 | 882 |
m_adj(m, todrop); |
| 883 | 883 |
ti->ti_seq += todrop; |
| ... | ... | |
| 896 | 896 |
if ((so->so_state & SS_NOFDREF) && |
| 897 | 897 |
tp->t_state > TCPS_CLOSE_WAIT && ti->ti_len) {
|
| 898 | 898 |
tp = tcp_close(tp); |
| 899 |
tcpstat.tcps_rcvafterclose++;
|
|
| 899 |
STAT(tcpstat.tcps_rcvafterclose++);
|
|
| 900 | 900 |
goto dropwithreset; |
| 901 | 901 |
} |
| 902 | 902 |
|
| ... | ... | |
| 906 | 906 |
*/ |
| 907 | 907 |
todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd); |
| 908 | 908 |
if (todrop > 0) {
|
| 909 |
tcpstat.tcps_rcvpackafterwin++;
|
|
| 909 |
STAT(tcpstat.tcps_rcvpackafterwin++);
|
|
| 910 | 910 |
if (todrop >= ti->ti_len) {
|
| 911 |
tcpstat.tcps_rcvbyteafterwin += ti->ti_len;
|
|
| 911 |
STAT(tcpstat.tcps_rcvbyteafterwin += ti->ti_len);
|
|
| 912 | 912 |
/* |
| 913 | 913 |
* If a new connection request is received |
| 914 | 914 |
* while in TIME_WAIT, drop the old connection |
| ... | ... | |
| 931 | 931 |
*/ |
| 932 | 932 |
if (tp->rcv_wnd == 0 && ti->ti_seq == tp->rcv_nxt) {
|
| 933 | 933 |
tp->t_flags |= TF_ACKNOW; |
| 934 |
tcpstat.tcps_rcvwinprobe++;
|
|
| 934 |
STAT(tcpstat.tcps_rcvwinprobe++);
|
|
| 935 | 935 |
} else |
| 936 | 936 |
goto dropafterack; |
| 937 | 937 |
} else |
| 938 |
tcpstat.tcps_rcvbyteafterwin += todrop;
|
|
| 938 |
STAT(tcpstat.tcps_rcvbyteafterwin += todrop);
|
|
| 939 | 939 |
m_adj(m, -todrop); |
| 940 | 940 |
ti->ti_len -= todrop; |
| 941 | 941 |
tiflags &= ~(TH_PUSH|TH_FIN); |
| ... | ... | |
| 976 | 976 |
/* so->so_error = ECONNRESET; */ |
| 977 | 977 |
close: |
| 978 | 978 |
tp->t_state = TCPS_CLOSED; |
| 979 |
tcpstat.tcps_drops++;
|
|
| 979 |
STAT(tcpstat.tcps_drops++);
|
|
| 980 | 980 |
tp = tcp_close(tp); |
| 981 | 981 |
goto drop; |
| 982 | 982 |
|
| ... | ... | |
| 1015 | 1015 |
if (SEQ_GT(tp->snd_una, ti->ti_ack) || |
| 1016 | 1016 |
SEQ_GT(ti->ti_ack, tp->snd_max)) |
| 1017 | 1017 |
goto dropwithreset; |
| 1018 |
tcpstat.tcps_connects++;
|
|
| 1018 |
STAT(tcpstat.tcps_connects++);
|
|
| 1019 | 1019 |
tp->t_state = TCPS_ESTABLISHED; |
| 1020 | 1020 |
/* |
| 1021 | 1021 |
* The sent SYN is ack'ed with our sequence number +1 |
| ... | ... | |
| 1072 | 1072 |
|
| 1073 | 1073 |
if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {
|
| 1074 | 1074 |
if (ti->ti_len == 0 && tiwin == tp->snd_wnd) {
|
| 1075 |
tcpstat.tcps_rcvdupack++;
|
|
| 1075 |
STAT(tcpstat.tcps_rcvdupack++);
|
|
| 1076 | 1076 |
DEBUG_MISC((dfd," dup ack m = %lx so = %lx \n", |
| 1077 | 1077 |
(long )m, (long )so)); |
| 1078 | 1078 |
/* |
| ... | ... | |
| 1140 | 1140 |
tp->snd_cwnd = tp->snd_ssthresh; |
| 1141 | 1141 |
tp->t_dupacks = 0; |
| 1142 | 1142 |
if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
|
| 1143 |
tcpstat.tcps_rcvacktoomuch++;
|
|
| 1143 |
STAT(tcpstat.tcps_rcvacktoomuch++);
|
|
| 1144 | 1144 |
goto dropafterack; |
| 1145 | 1145 |
} |
| 1146 | 1146 |
acked = ti->ti_ack - tp->snd_una; |
| 1147 |
tcpstat.tcps_rcvackpack++;
|
|
| 1148 |
tcpstat.tcps_rcvackbyte += acked;
|
|
| 1147 |
STAT(tcpstat.tcps_rcvackpack++);
|
|
| 1148 |
STAT(tcpstat.tcps_rcvackbyte += acked);
|
|
| 1149 | 1149 |
|
| 1150 | 1150 |
/* |
| 1151 | 1151 |
* If we have a timestamp reply, update smoothed |
| ... | ... | |
| 1284 | 1284 |
/* keep track of pure window updates */ |
| 1285 | 1285 |
if (ti->ti_len == 0 && |
| 1286 | 1286 |
tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd) |
| 1287 |
tcpstat.tcps_rcvwinupd++;
|
|
| 1287 |
STAT(tcpstat.tcps_rcvwinupd++);
|
|
| 1288 | 1288 |
tp->snd_wnd = tiwin; |
| 1289 | 1289 |
tp->snd_wl1 = ti->ti_seq; |
| 1290 | 1290 |
tp->snd_wl2 = ti->ti_ack; |
| ... | ... | |
| 1616 | 1616 |
DEBUG_ARG("tp = %lx", (long)tp);
|
| 1617 | 1617 |
DEBUG_ARG("rtt = %d", rtt);
|
| 1618 | 1618 |
|
| 1619 |
tcpstat.tcps_rttupdated++;
|
|
| 1619 |
STAT(tcpstat.tcps_rttupdated++);
|
|
| 1620 | 1620 |
if (tp->t_srtt != 0) {
|
| 1621 | 1621 |
/* |
| 1622 | 1622 |
* srtt is stored as fixed point with 3 bits after the |
Also available in: Unified diff