Lines Matching +full:pull +full:- +full:down +full:- +full:adv
1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
142 * non-ACK.
160 if (V_tcp_hhh[HHOOK_TCP_EST_OUT]->hhh_nhooks > 0) {
168 &tp->t_osd);
181 if (CC_ALGO(tp)->after_idle != NULL)
182 CC_ALGO(tp)->after_idle(&tp->t_ccv);
217 const bool isipv6 = (inp->inp_vflag & INP_IPV6) != 0;
220 const bool hw_tls = tp->t_nic_ktls_xmit != 0;
229 if (tp->t_flags & TF_TOE)
238 if ((tp->t_flags & TF_FASTOPEN) &&
239 ((tp->t_state == TCPS_SYN_SENT) ||
240 (tp->t_state == TCPS_SYN_RECEIVED)) &&
241 SEQ_GT(tp->snd_max, tp->snd_una) && /* SYN or SYN|ACK sent */
242 (tp->snd_nxt != tp->snd_una)) /* not a retransmit */
251 idle = (tp->t_flags & TF_LASTIDLE) || (tp->snd_max == tp->snd_una);
252 if (idle && (((ticks - tp->t_rcvtime) >= tp->t_rxtcur) ||
253 (tp->t_sndtime && ((ticks - tp->t_sndtime) >= tp->t_rxtcur))))
255 tp->t_flags &= ~TF_LASTIDLE;
257 if (tp->t_flags & TF_MORETOCOME) {
258 tp->t_flags |= TF_LASTIDLE;
269 if ((tp->t_flags & TF_SACK_PERMIT) &&
270 (tp->sackhint.nexthole != NULL) &&
271 !IN_FASTRECOVERY(tp->t_flags)) {
277 off = tp->snd_nxt - tp->snd_una;
278 sendwin = min(tp->snd_wnd, tp->snd_cwnd + sendwin);
280 flags = tcp_outflags[tp->t_state];
282 * Send any SACK-generated retransmissions. If we're explicitly trying
293 if ((tp->t_flags & TF_SACK_PERMIT) &&
294 (IN_FASTRECOVERY(tp->t_flags) ||
295 (SEQ_LT(tp->snd_nxt, tp->snd_max) && (tp->t_dupacks >= tcprexmtthresh))) &&
299 if (IN_FASTRECOVERY(tp->t_flags)) {
300 cwin = imax(sendwin - tcp_compute_pipe(tp), 0);
302 cwin = imax(sendwin - off, 0);
305 if (SEQ_GT(p->end, tp->snd_recover)) {
311 if (SEQ_GEQ(p->rxmit, tp->snd_recover)) {
316 * moves past p->rxmit.
323 len = SEQ_SUB(tp->snd_recover, p->rxmit);
331 len = SEQ_SUB(p->end, p->rxmit);
339 * but sendwin (expected flightsize) - pipe didn't
342 * length further down by setting sack_rxmit.
347 off = SEQ_SUB(p->rxmit, tp->snd_una);
361 if (tp->t_flags & TF_NEEDFIN)
363 if (tp->t_flags & TF_NEEDSYN)
373 if (tp->t_flags & TF_FORCEDATA) {
391 if (off < sbused(&so->so_snd))
396 tp->t_rxtshift = 0;
405 * acks after fast-retransmit because TCP will reset snd_nxt
406 * to snd_max after the fast-retransmit.
408 * In the normal retransmit-FIN-only case, however, snd_nxt will
416 if ((sack_bytes_rxmt == 0) || SEQ_LT(tp->snd_nxt, tp->snd_max)) {
417 len = imin(sbavail(&so->so_snd), sendwin) - off;
425 imin(sbavail(&so->so_snd), sendwin) -
432 * is SYN-SENT state and if segment contains data and if we don't
435 if ((flags & TH_SYN) && SEQ_GT(tp->snd_nxt, tp->snd_una)) {
436 if (tp->t_state != TCPS_SYN_RECEIVED)
442 if ((tp->t_flags & TF_FASTOPEN) &&
443 (tp->t_state == TCPS_SYN_RECEIVED))
445 off--, len++;
453 if ((flags & TH_SYN) && (tp->t_flags & TF_NOOPT)) {
461 * - When retransmitting SYN|ACK on a passively-created socket
463 * - When retransmitting SYN on an actively created socket
465 * - When sending a zero-length cookie (cookie request) on an
468 * - When the socket is in the CLOSED state (RST is being sent)
470 if ((tp->t_flags & TF_FASTOPEN) &&
471 (((flags & TH_SYN) && (tp->t_rxtshift > 0)) ||
472 ((tp->t_state == TCPS_SYN_SENT) &&
473 (tp->t_tfo_client_cookie_len == 0)) ||
477 /* Without fast-open there should never be data sent on a SYN. */
478 if ((flags & TH_SYN) && !(tp->t_flags & TF_FASTOPEN)) {
488 * cancel pending retransmit, pull snd_nxt back
495 * to send, but a 0-byte window. This makes sure
500 if ((sendwin == 0) && (TCPS_HAVEESTABLISHED(tp->t_state)) &&
501 (off < (int) sbavail(&so->so_snd)) &&
504 tp->t_rxtshift = 0;
505 tp->snd_nxt = tp->snd_una;
521 * presence of TCP-MD5, IP options (IPsec), and possibly SACK
534 * Pre-calculate here as we save another lookup into the darknesses
554 if (inp->inp_options)
555 ipoptlen = inp->inp_options->m_len -
561 if ((tp->t_flags & TF_TSO) && V_tcp_do_tso && len > tp->t_maxseg &&
562 (tp->t_port == 0) &&
563 ((tp->t_flags & TF_SIGNATURE) == 0) &&
566 (tp->t_flags2 & TF2_IPSEC_TSO) != 0)) &&
570 if (SEQ_LT((sack_rxmit ? p->rxmit : tp->snd_nxt) + len,
571 tp->snd_una + sbused(&so->so_snd))) {
575 recwin = lmin(lmax(sbspace(&so->so_rcv), 0),
576 (long)TCP_MAXWIN << tp->rcv_scale);
580 * conditions when len is non-zero:
582 * - We have a full segment (or more with TSO)
583 * - This is the last buffer in a write()/send() and we are
585 * - we've timed out (e.g. persist timer)
586 * - we have more then 1/2 the maximum send window's worth of
588 * - we need to retransmit
591 if (len >= tp->t_maxseg)
601 if ((((tp->t_flags & TF_SIGNATURE) ?
603 ((tp->t_flags & TF_RCVD_TSTMP) ?
605 len) >= tp->t_maxseg)
614 if (!(tp->t_flags & TF_MORETOCOME) && /* normal case */
615 (idle || (tp->t_flags & TF_NODELAY)) &&
616 (uint32_t)len + (uint32_t)off >= sbavail(&so->so_snd) &&
617 (tp->t_flags & TF_NOPUSH) == 0) {
620 if (tp->t_flags & TF_FORCEDATA) /* typ. timeout case */
622 if (len >= tp->max_sndwnd / 2 && tp->max_sndwnd > 0)
624 if (SEQ_LT(tp->snd_nxt, tp->snd_max)) /* retransmit case */
654 * ACK is pending (it will get piggy-backed on it) or the
655 * remote side already has done a half-close and won't send
658 if (recwin > 0 && !(tp->t_flags & TF_NEEDSYN) &&
659 !(tp->t_flags & TF_DELACK) &&
660 !TCPS_HAVERCVDFIN(tp->t_state)) {
662 * "adv" is the amount we could increase the window,
664 * TCP_MAXWIN << tp->rcv_scale.
666 int32_t adv;
669 adv = recwin;
670 if (SEQ_GT(tp->rcv_adv, tp->rcv_nxt)) {
671 oldwin = (tp->rcv_adv - tp->rcv_nxt);
672 if (adv > oldwin)
673 adv -= oldwin;
675 adv = 0;
684 if (oldwin >> tp->rcv_scale >= (adv + oldwin) >> tp->rcv_scale)
687 if (adv >= (int32_t)(2 * tp->t_maxseg) &&
688 (adv >= (int32_t)(so->so_rcv.sb_hiwat / 4) ||
689 recwin <= (so->so_rcv.sb_hiwat / 8) ||
690 so->so_rcv.sb_hiwat <= 8 * tp->t_maxseg ||
691 adv >= TCP_MAXWIN << tp->rcv_scale))
693 if (2 * adv >= (int32_t)so->so_rcv.sb_hiwat)
700 * is also a catch-all for the retransmit timer timeout case.
702 if (tp->t_flags & TF_ACKNOW)
705 ((flags & TH_SYN) && (tp->t_flags & TF_NEEDSYN) == 0))
707 if (SEQ_GT(tp->snd_up, tp->snd_una))
714 ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una))
721 if ((tp->t_flags & TF_SACK_PERMIT) &&
722 SEQ_GT(tp->snd_max, tp->snd_una) &&
738 * (tp->t_flags & TF_FORCEDATA)
750 if (sbavail(&so->so_snd) && !tcp_timer_active(tp, TT_REXMT) &&
752 tp->t_rxtshift = 0;
766 if (len >= tp->t_maxseg)
767 tp->t_flags2 |= TF2_PLPMTU_MAXSEGSNT;
769 tp->t_flags2 &= ~TF2_PLPMTU_MAXSEGSNT;
788 tp->snd_nxt = tp->iss;
794 * segments. Options for SYN-ACK segments are handled in TCP
798 if ((tp->t_flags & TF_NOOPT) == 0) {
801 to.to_mss = tcp_mssopt(&inp->inp_inc);
802 if (tp->t_port)
803 to.to_mss -= V_tcp_udp_tunneling_overhead;
813 if ((tp->t_flags & TF_FASTOPEN) &&
814 (tp->t_rxtshift == 0)) {
815 if (tp->t_state == TCPS_SYN_RECEIVED) {
818 (u_int8_t *)&tp->t_tfo_cookie.server;
821 } else if (tp->t_state == TCPS_SYN_SENT) {
823 tp->t_tfo_client_cookie_len;
825 tp->t_tfo_cookie.client;
840 if ((flags & TH_SYN) && (tp->t_flags & TF_REQ_SCALE)) {
841 to.to_wscale = tp->request_r_scale;
845 if ((tp->t_flags & TF_RCVD_TSTMP) ||
846 ((flags & TH_SYN) && (tp->t_flags & TF_REQ_TSTMP))) {
848 to.to_tsval = curticks + tp->ts_offset;
849 to.to_tsecr = tp->ts_recent;
851 if (tp->t_rxtshift == 1)
852 tp->t_badrxtwin = curticks;
856 if (tp->rfbuf_ts == 0 &&
857 (so->so_rcv.sb_flags & SB_AUTOSIZE))
858 tp->rfbuf_ts = tcp_ts_getticks();
861 if (tp->t_flags & TF_SACK_PERMIT) {
864 else if (TCPS_HAVEESTABLISHED(tp->t_state) &&
865 tp->rcv_numsacks > 0) {
867 to.to_nsacks = tp->rcv_numsacks;
868 to.to_sacks = (u_char *)tp->sackblks;
872 /* TCP-MD5 (RFC2385). */
877 if (tp->t_flags & TF_SIGNATURE)
887 if ((tp->t_flags & TF_FASTOPEN) && wanted_cookie &&
891 if (tp->t_port) {
905 if (len + optlen + ipoptlen > tp->t_maxseg) {
914 if_hw_tsomax = tp->t_tsomax;
915 if_hw_tsomaxsegcount = tp->t_tsomaxsegcount;
916 if_hw_tsomaxsegsize = tp->t_tsomaxsegsize;
932 max_len = if_hw_tsomax - hdrlen -
933 ipsec_optlen - max_linkhdr;
947 max_len = tp->t_maxseg - optlen - ipsec_optlen;
949 sbavail(&so->so_snd)) {
952 len -= moff;
974 if (tp->t_flags & TF_NEEDFIN)
977 if (optlen + ipoptlen >= tp->t_maxseg) {
991 len = tp->t_maxseg - optlen - ipoptlen;
1013 * Before, those had triggered (random) panic conditions further down.
1027 if ((tp->t_flags & TF_FORCEDATA) && len == 1) {
1030 if (SEQ_LT(tp->snd_nxt, tp->snd_max))
1031 stats_voi_update_abs_u32(tp->t_stats,
1034 stats_voi_update_abs_u64(tp->t_stats,
1037 } else if (SEQ_LT(tp->snd_nxt, tp->snd_max) || sack_rxmit) {
1038 tp->t_sndrexmitpack++;
1049 stats_voi_update_abs_u32(tp->t_stats, VOI_TCP_RETXPB,
1056 stats_voi_update_abs_u64(tp->t_stats, VOI_TCP_TXPB,
1074 m->m_data += max_linkhdr;
1075 m->m_len = hdrlen;
1081 mb = sbsndptr_noadv(&so->so_snd, off, &moff);
1082 if (len <= MHLEN - hdrlen - max_linkhdr && !hw_tls) {
1085 if (SEQ_LT(tp->snd_nxt, tp->snd_max))
1086 sbsndptr_adv(&so->so_snd, mb, len);
1087 m->m_len += len;
1091 if (SEQ_LT(tp->snd_nxt, tp->snd_max))
1094 msb = &so->so_snd;
1096 m->m_next = tcp_m_copym(mb, moff,
1101 if (len <= (tp->t_maxseg - optlen)) {
1110 if (m->m_next == NULL) {
1125 if (((uint32_t)off + (uint32_t)len == sbused(&so->so_snd)) &&
1131 if (tp->t_flags & TF_ACKNOW)
1135 else if (SEQ_GT(tp->snd_up, tp->snd_una))
1152 m->m_data += max_linkhdr;
1153 m->m_len = hdrlen;
1156 m->m_pkthdr.rcvif = (struct ifnet *)0;
1163 if (tp->t_port) {
1165 udp->uh_sport = htons(V_tcp_udp_tunneling_port);
1166 udp->uh_dport = tp->t_port;
1167 ulen = hdrlen + len - sizeof(struct ip6_hdr);
1168 udp->uh_ulen = htons(ulen);
1173 tcpip_fillheaders(inp, tp->t_port, ip6, th);
1178 if (tp->t_port) {
1180 udp->uh_sport = htons(V_tcp_udp_tunneling_port);
1181 udp->uh_dport = tp->t_port;
1182 ulen = hdrlen + len - sizeof(struct ip);
1183 udp->uh_ulen = htons(ulen);
1187 tcpip_fillheaders(inp, tp->t_port, ip, th);
1195 if (flags & TH_FIN && tp->t_flags & TF_SENTFIN &&
1196 tp->snd_nxt == tp->snd_max)
1197 tp->snd_nxt--;
1204 if (tp->t_state == TCPS_SYN_SENT && V_tcp_do_ecn) {
1208 if ((TCPS_HAVERCVDSYN(tp->t_state)) &&
1209 (tp->t_flags2 & (TF2_ECN_PERMIT | TF2_ACE_PERMIT))) {
1211 if ((tp->t_state == TCPS_SYN_RECEIVED) &&
1212 (tp->t_flags2 & TF2_ECN_SND_ECE))
1213 tp->t_flags2 &= ~TF2_ECN_SND_ECE;
1216 ip6->ip6_flow &= ~htonl(IPTOS_ECN_MASK << IPV6_FLOWLABEL_LEN);
1217 ip6->ip6_flow |= htonl(ect << IPV6_FLOWLABEL_LEN);
1222 ip->ip_tos &= ~IPTOS_ECN_MASK;
1223 ip->ip_tos |= ect;
1243 th->th_seq = htonl(tp->snd_nxt);
1245 th->th_seq = htonl(tp->snd_max);
1247 th->th_seq = htonl(p->rxmit);
1248 p->rxmit += len;
1255 if ((tp->t_flags & TF_LRD) && SEQ_GEQ(p->rxmit, p->end))
1256 p->rxmit = tp->snd_recover;
1257 tp->sackhint.sack_bytes_rexmit += len;
1259 if (IN_RECOVERY(tp->t_flags)) {
1265 tp->sackhint.prr_out += len;
1267 th->th_ack = htonl(tp->rcv_nxt);
1270 th->th_off = (sizeof (struct tcphdr) + optlen) >> 2;
1280 if (recwin < (so->so_rcv.sb_hiwat / 4) &&
1281 recwin < tp->t_maxseg)
1283 if (SEQ_GT(tp->rcv_adv, tp->rcv_nxt) &&
1284 recwin < (tp->rcv_adv - tp->rcv_nxt))
1285 recwin = (tp->rcv_adv - tp->rcv_nxt);
1293 th->th_win = htons((u_short)
1294 (min(sbspace(&so->so_rcv), TCP_MAXWIN)));
1297 recwin = roundup2(recwin, 1 << tp->rcv_scale);
1298 th->th_win = htons((u_short)(recwin >> tp->rcv_scale));
1302 * Adjust the RXWIN0SENT flag - indicate that we have advertised
1309 if (th->th_win == 0) {
1310 tp->t_sndzerowin++;
1311 tp->t_flags |= TF_RXWIN0SENT;
1313 tp->t_flags &= ~TF_RXWIN0SENT;
1314 if (SEQ_GT(tp->snd_up, tp->snd_nxt)) {
1315 th->th_urp = htons((u_short)(tp->snd_up - tp->snd_nxt));
1319 * If no urgent pointer to send, then we pull
1324 tp->snd_up = tp->snd_una; /* drag it along */
1332 m->m_pkthdr.len = hdrlen + len; /* in6_cksum() need this */
1343 (u_char *)(th + 1) + (to.to_signature - opt))) != 0) {
1359 if (tp->t_port) {
1360 m->m_pkthdr.csum_flags = CSUM_UDP_IPV6;
1361 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
1362 udp->uh_sum = in6_cksum_pseudo(ip6, ulen, IPPROTO_UDP, 0);
1363 th->th_sum = htons(0);
1366 m->m_pkthdr.csum_flags = CSUM_TCP_IPV6;
1367 m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);
1368 th->th_sum = in6_cksum_pseudo(ip6,
1379 if (tp->t_port) {
1380 m->m_pkthdr.csum_flags = CSUM_UDP;
1381 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
1382 udp->uh_sum = in_pseudo(ip->ip_src.s_addr,
1383 ip->ip_dst.s_addr, htons(ulen + IPPROTO_UDP));
1384 th->th_sum = htons(0);
1387 m->m_pkthdr.csum_flags = CSUM_TCP;
1388 m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);
1389 th->th_sum = in_pseudo(ip->ip_src.s_addr,
1390 ip->ip_dst.s_addr, htons(sizeof(struct tcphdr) +
1395 KASSERT(ip->ip_v == IPVERSION,
1396 ("%s: IP version incorrect: %d", __func__, ip->ip_v));
1405 KASSERT(len > tp->t_maxseg - optlen - ipsec_optlen,
1407 m->m_pkthdr.csum_flags |= CSUM_TSO;
1408 m->m_pkthdr.tso_segsz = tp->t_maxseg - optlen - ipsec_optlen;
1426 lgb = tcp_log_event(tp, th, &so->so_rcv, &so->so_snd,
1439 * m->m_pkthdr.len should have been set before checksum calculation,
1450 ip6->ip6_hlim = in6_selecthlim(inp, NULL);
1457 ip6->ip6_plen = htons(m->m_pkthdr.len - sizeof(*ip6));
1459 if (V_path_mtu_discovery && tp->t_maxseg > V_tcp_minmss)
1460 tp->t_flags2 |= TF2_PLPMTU_PMTUD;
1462 tp->t_flags2 &= ~TF2_PLPMTU_PMTUD;
1464 if (tp->t_state == TCPS_SYN_SENT)
1471 tcp_pcap_add(th, m, &(tp->t_outpkts));
1475 error = ip6_output(m, inp->in6p_outputopts, &inp->inp_route6,
1476 ((so->so_options & SO_DONTROUTE) ? IP_ROUTETOIF : 0),
1479 if (error == EMSGSIZE && inp->inp_route6.ro_nh != NULL)
1480 mtu = inp->inp_route6.ro_nh->nh_mtu;
1488 ip->ip_len = htons(m->m_pkthdr.len);
1490 if (inp->inp_vflag & INP_IPV6PROTO)
1491 ip->ip_ttl = in6_selecthlim(inp, NULL);
1501 if (V_path_mtu_discovery && tp->t_maxseg > V_tcp_minmss) {
1502 tp->t_flags2 |= TF2_PLPMTU_PMTUD;
1503 if (tp->t_port == 0 || len < V_tcp_minmss) {
1504 ip->ip_off |= htons(IP_DF);
1507 tp->t_flags2 &= ~TF2_PLPMTU_PMTUD;
1510 if (tp->t_state == TCPS_SYN_SENT)
1517 tcp_pcap_add(th, m, &(tp->t_outpkts));
1520 error = ip_output(m, inp->inp_options, &inp->inp_route,
1521 ((so->so_options & SO_DONTROUTE) ? IP_ROUTETOIF : 0), 0, inp);
1523 if (error == EMSGSIZE && inp->inp_route.ro_nh != NULL)
1524 mtu = inp->inp_route.ro_nh->nh_mtu;
1529 lgb->tlb_errno = error;
1534 tcp_account_for_send(tp, len, (tp->snd_nxt != tp->snd_max), 0, hw_tls);
1543 } else if ((tp->t_flags & TF_FORCEDATA) == 0 ||
1545 tcp_seq startseq = tp->snd_nxt;
1552 tp->snd_nxt++;
1554 tp->snd_nxt++;
1555 tp->t_flags |= TF_SENTFIN;
1560 tp->snd_nxt += len;
1561 if (SEQ_GT(tp->snd_nxt, tp->snd_max)) {
1566 if (tp->snd_una == tp->snd_max)
1567 tp->t_acktime = ticks;
1568 tp->snd_max = tp->snd_nxt;
1573 tp->t_sndtime = ticks;
1574 if (tp->t_rtttime == 0) {
1575 tp->t_rtttime = ticks;
1576 tp->t_rtseq = startseq;
1580 if (!(tp->t_flags & TF_GPUTINPROG) && len) {
1581 tp->t_flags |= TF_GPUTINPROG;
1582 tp->gput_seq = startseq;
1583 tp->gput_ack = startseq +
1584 ulmin(sbavail(&so->so_snd) - off, sendwin);
1585 tp->gput_ts = tcp_ts_getticks();
1592 * and not doing a pure ack or a keep-alive probe.
1594 * round-trip time + 2 * round-trip time variance.
1600 ((sack_rxmit && tp->snd_nxt != tp->snd_max) ||
1601 (tp->snd_nxt != tp->snd_una))) {
1604 tp->t_rxtshift = 0;
1607 } else if (len == 0 && sbavail(&so->so_snd) &&
1613 * 1) A -> B: packet with enough data to fill the window
1614 * 2) B -> A: ACK for #1 + new data (0 window
1616 * 3) A -> B: ACK for #2, 0 len packet
1624 * So, if you send a 0-length packet, but there is data
1629 tp->t_rxtshift = 0;
1642 tp->t_flags |= TF_SENTFIN;
1644 if (SEQ_GT(tp->snd_nxt + xlen, tp->snd_max))
1645 tp->snd_max = tp->snd_nxt + xlen;
1648 (tp->rcv_numsacks > 0) &&
1649 TCPS_HAVEESTABLISHED(tp->t_state) &&
1650 (tp->t_flags & TF_SACK_PERMIT)) {
1656 SEQ_LT(tp->snd_nxt, SEQ_MIN(p->rxmit, p->end))) {
1659 * after an RTO, pull snd_nxt along.
1661 tp->snd_nxt = SEQ_MIN(p->rxmit, p->end);
1677 if (((tp->t_flags & TF_FORCEDATA) == 0 ||
1682 p->rxmit = SEQ_MIN(p->end, p->rxmit) - len;
1683 tp->sackhint.sack_bytes_rexmit -= len;
1684 KASSERT(tp->sackhint.sack_bytes_rexmit >= 0,
1689 tp->snd_nxt -= len;
1691 tp->snd_nxt--;
1693 if (IN_RECOVERY(tp->t_flags))
1694 tp->sackhint.prr_out -= len;
1700 tp->t_softerror = error;
1704 tp->snd_cwnd = tcp_maxseg(tp);
1717 tp->t_flags &= ~TF_TSO;
1719 tcp_mss_update(tp, -1, mtu, NULL, NULL);
1727 if (TCPS_HAVERCVDSYN(tp->t_state)) {
1728 tp->t_softerror = error;
1744 if (SEQ_GT(tp->rcv_nxt + recwin, tp->rcv_adv))
1745 tp->rcv_adv = tp->rcv_nxt + recwin;
1746 tp->last_ack_sent = tp->rcv_nxt;
1747 tp->t_flags &= ~(TF_ACKNOW | TF_DELACK);
1758 int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
1762 tp->t_flags &= ~TF_PREVVALID;
1768 if (tp->t_state == TCPS_CLOSED)
1774 TCPT_RANGESET(tt, t * tcp_backoff[tp->t_rxtshift],
1776 if (TP_MAXUNACKTIME(tp) && tp->t_acktime) {
1777 maxunacktime = tp->t_acktime + TP_MAXUNACKTIME(tp) - ticks;
1784 if (tp->t_rxtshift < V_tcp_retries)
1785 tp->t_rxtshift++;
1795 * The optimal order for a SYN/SYN-ACK segment is:
1803 * we only have 10 bytes for SACK options (40 - (12 + 18)).
1811 if ((to->to_flags & mask) != mask)
1815 switch (to->to_flags & mask) {
1821 if (TCP_MAXOLEN - optlen < TCPOLEN_MAXSEG)
1826 to->to_mss = htons(to->to_mss);
1827 bcopy((u_char *)&to->to_mss, optp, sizeof(to->to_mss));
1828 optp += sizeof(to->to_mss);
1835 if (TCP_MAXOLEN - optlen < TCPOLEN_WINDOW)
1840 *optp++ = to->to_wscale;
1847 if (TCP_MAXOLEN - optlen < TCPOLEN_SACK_PERMITTED)
1858 if (TCP_MAXOLEN - optlen < TCPOLEN_TIMESTAMP)
1863 to->to_tsval = htonl(to->to_tsval);
1864 to->to_tsecr = htonl(to->to_tsecr);
1865 bcopy((u_char *)&to->to_tsval, optp, sizeof(to->to_tsval));
1866 optp += sizeof(to->to_tsval);
1867 bcopy((u_char *)&to->to_tsecr, optp, sizeof(to->to_tsecr));
1868 optp += sizeof(to->to_tsecr);
1872 int siglen = TCPOLEN_SIGNATURE - 2;
1878 if (TCP_MAXOLEN - optlen < TCPOLEN_SIGNATURE) {
1879 to->to_flags &= ~TOF_SIGNATURE;
1885 to->to_signature = optp;
1886 while (siglen--)
1893 struct sackblk *sack = (struct sackblk *)to->to_sacks;
1900 if (TCP_MAXOLEN - optlen < TCPOLEN_SACKHDR + TCPOLEN_SACK)
1904 sackblks = min(to->to_nsacks,
1905 (TCP_MAXOLEN - optlen) / TCPOLEN_SACK);
1907 while (sackblks--) {
1908 sack_seq = htonl(sack->start);
1911 sack_seq = htonl(sack->end);
1925 total_len = TCPOLEN_FAST_OPEN_EMPTY + to->to_tfo_len;
1926 if (TCP_MAXOLEN - optlen < total_len) {
1927 to->to_flags &= ~TOF_FASTOPEN;
1932 if (to->to_tfo_len > 0) {
1933 bcopy(to->to_tfo_cookie, optp, to->to_tfo_len);
1934 optp += to->to_tfo_len;
1952 * "The content of the header beyond the End-of-Option option
1989 if (off == 0 && m->m_flags & M_PKTHDR)
1995 if (off < m->m_len)
1997 off -= m->m_len;
1998 if ((sb) && (m == sb->sb_sndptr)) {
1999 sb->sb_sndptroff += m->m_len;
2000 sb->sb_sndptr = m->m_next;
2002 m = m->m_next;
2008 if (hw_tls && (m->m_flags & M_EXTPG))
2009 tls = m->m_epg_tls;
2025 if (m->m_flags & M_EXTPG)
2026 ntls = m->m_epg_tls;
2044 mlen = min(len, m->m_len - off);
2054 if (m->m_flags & M_EXTPG) {
2077 mlen = (seglimit - frags - 1) * fragsize;
2086 seglimit -= frags;
2091 n = m_gethdr(M_NOWAIT, m->m_type);
2093 n = m_get(M_NOWAIT, m->m_type);
2101 n->m_pkthdr.len -= off0;
2103 n->m_pkthdr.len = len;
2104 pkthdrlen = &n->m_pkthdr.len;
2107 n->m_len = mlen;
2108 len_cp += n->m_len;
2109 if (m->m_flags & (M_EXT | M_EXTPG)) {
2110 n->m_data = m->m_data + off;
2114 (u_int)n->m_len);
2116 if (sb && (sb->sb_sndptr == m) &&
2117 ((n->m_len + off) >= m->m_len) && m->m_next) {
2118 sb->sb_sndptroff += m->m_len;
2119 sb->sb_sndptr = m->m_next;
2123 len -= n->m_len;
2125 m = m->m_next;
2126 np = &n->m_next;
2143 * delay (eg. trans-continental/oceanic links). Setting the
2166 * of available bandwidth (the non-use of it) for wasting some
2175 if (V_tcp_do_autosndbuf && so->so_snd.sb_flags & SB_AUTOSIZE) {
2178 lowat = V_tcp_sendbuf_auto_lowat ? so->so_snd.sb_lowat : 0;
2179 if ((tp->snd_wnd / 4 * 5) >= so->so_snd.sb_hiwat - lowat &&
2180 sbused(&so->so_snd) >=
2181 (so->so_snd.sb_hiwat / 8 * 7) - lowat &&
2182 sbused(&so->so_snd) < V_tcp_autosndbuf_max &&
2183 sendwin >= (sbused(&so->so_snd) -
2184 (tp->snd_nxt - tp->snd_una))) {
2186 min(so->so_snd.sb_hiwat + V_tcp_autosndbuf_inc,
2188 so->so_snd.sb_flags &= ~SB_AUTOSIZE;