Return to tcp_input.c CVS log

Up to [Net/2] / Net2 / netinet

Annotation of Net2/netinet/tcp_input.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms, with or without
        !             6:  * modification, are permitted provided that the following conditions
        !             7:  * are met:
        !             8:  * 1. Redistributions of source code must retain the above copyright
        !             9:  *    notice, this list of conditions and the following disclaimer.
        !            10:  * 2. Redistributions in binary form must reproduce the above copyright
        !            11:  *    notice, this list of conditions and the following disclaimer in the
        !            12:  *    documentation and/or other materials provided with the distribution.
        !            13:  * 3. All advertising materials mentioning features or use of this software
        !            14:  *    must display the following acknowledgement:
        !            15:  *     This product includes software developed by the University of
        !            16:  *     California, Berkeley and its contributors.
        !            17:  * 4. Neither the name of the University nor the names of its contributors
        !            18:  *    may be used to endorse or promote products derived from this software
        !            19:  *    without specific prior written permission.
        !            20:  *
        !            21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            31:  * SUCH DAMAGE.
        !            32:  *
        !            33:  *     @(#)tcp_input.c 7.25 (Berkeley) 6/30/90
        !            34:  */
        !            35: 
        !            36: #include "param.h"
        !            37: #include "systm.h"
        !            38: #include "malloc.h"
        !            39: #include "mbuf.h"
        !            40: #include "protosw.h"
        !            41: #include "socket.h"
        !            42: #include "socketvar.h"
        !            43: #include "errno.h"
        !            44: 
        !            45: #include "../net/if.h"
        !            46: #include "../net/route.h"
        !            47: 
        !            48: #include "in.h"
        !            49: #include "in_systm.h"
        !            50: #include "ip.h"
        !            51: #include "in_pcb.h"
        !            52: #include "ip_var.h"
        !            53: #include "tcp.h"
        !            54: #include "tcp_fsm.h"
        !            55: #include "tcp_seq.h"
        !            56: #include "tcp_timer.h"
        !            57: #include "tcp_var.h"
        !            58: #include "tcpip.h"
        !            59: #include "tcp_debug.h"
        !            60: 
        !            61: int    tcprexmtthresh = 3;
        !            62: int    tcppredack;     /* XXX debugging: times hdr predict ok for acks */
        !            63: int    tcppreddat;     /* XXX # times header prediction ok for data packets */
        !            64: int    tcppcbcachemiss;
        !            65: struct tcpiphdr tcp_saveti;
        !            66: struct inpcb *tcp_last_inpcb = &tcb;
        !            67: 
        !            68: struct tcpcb *tcp_newtcpcb();
        !            69: 
        !            70: /*
        !            71:  * Insert segment ti into reassembly queue of tcp with
        !            72:  * control block tp.  Return TH_FIN if reassembly now includes
        !            73:  * a segment with FIN.  The macro form does the common case inline
        !            74:  * (segment is the next to be received on an established connection,
        !            75:  * and the queue is empty), avoiding linkage into and removal
        !            76:  * from the queue and repetition of various conversions.
        !            77:  * Set DELACK for segments received in order, but ack immediately
        !            78:  * when segments are out of order (so fast retransmit can work).
        !            79:  */
        !            80: #define        TCP_REASS(tp, ti, m, so, flags) { \
        !            81:        if ((ti)->ti_seq == (tp)->rcv_nxt && \
        !            82:            (tp)->seg_next == (struct tcpiphdr *)(tp) && \
        !            83:            (tp)->t_state == TCPS_ESTABLISHED) { \
        !            84:                tp->t_flags |= TF_DELACK; \
        !            85:                (tp)->rcv_nxt += (ti)->ti_len; \
        !            86:                flags = (ti)->ti_flags & TH_FIN; \
        !            87:                tcpstat.tcps_rcvpack++;\
        !            88:                tcpstat.tcps_rcvbyte += (ti)->ti_len;\
        !            89:                sbappend(&(so)->so_rcv, (m)); \
        !            90:                sorwakeup(so); \
        !            91:        } else { \
        !            92:                (flags) = tcp_reass((tp), (ti), (m)); \
        !            93:                tp->t_flags |= TF_ACKNOW; \
        !            94:        } \
        !            95: }
        !            96: 
        !            97: tcp_reass(tp, ti, m)
        !            98:        register struct tcpcb *tp;
        !            99:        register struct tcpiphdr *ti;
        !           100:        struct mbuf *m;
        !           101: {
        !           102:        register struct tcpiphdr *q;
        !           103:        struct socket *so = tp->t_inpcb->inp_socket;
        !           104:        int flags;
        !           105: 
        !           106:        /*
        !           107:         * Call with ti==0 after become established to
        !           108:         * force pre-ESTABLISHED data up to user socket.
        !           109:         */
        !           110:        if (ti == 0)
        !           111:                goto present;
        !           112: 
        !           113:        /*
        !           114:         * Find a segment which begins after this one does.
        !           115:         */
        !           116:        for (q = tp->seg_next; q != (struct tcpiphdr *)tp;
        !           117:            q = (struct tcpiphdr *)q->ti_next)
        !           118:                if (SEQ_GT(q->ti_seq, ti->ti_seq))
        !           119:                        break;
        !           120: 
        !           121:        /*
        !           122:         * If there is a preceding segment, it may provide some of
        !           123:         * our data already.  If so, drop the data from the incoming
        !           124:         * segment.  If it provides all of our data, drop us.
        !           125:         */
        !           126:        if ((struct tcpiphdr *)q->ti_prev != (struct tcpiphdr *)tp) {
        !           127:                register int i;
        !           128:                q = (struct tcpiphdr *)q->ti_prev;
        !           129:                /* conversion to int (in i) handles seq wraparound */
        !           130:                i = q->ti_seq + q->ti_len - ti->ti_seq;
        !           131:                if (i > 0) {
        !           132:                        if (i >= ti->ti_len) {
        !           133:                                tcpstat.tcps_rcvduppack++;
        !           134:                                tcpstat.tcps_rcvdupbyte += ti->ti_len;
        !           135:                                m_freem(m);
        !           136:                                return (0);
        !           137:                        }
        !           138:                        m_adj(m, i);
        !           139:                        ti->ti_len -= i;
        !           140:                        ti->ti_seq += i;
        !           141:                }
        !           142:                q = (struct tcpiphdr *)(q->ti_next);
        !           143:        }
        !           144:        tcpstat.tcps_rcvoopack++;
        !           145:        tcpstat.tcps_rcvoobyte += ti->ti_len;
        !           146:        REASS_MBUF(ti) = m;             /* XXX */
        !           147: 
        !           148:        /*
        !           149:         * While we overlap succeeding segments trim them or,
        !           150:         * if they are completely covered, dequeue them.
        !           151:         */
        !           152:        while (q != (struct tcpiphdr *)tp) {
        !           153:                register int i = (ti->ti_seq + ti->ti_len) - q->ti_seq;
        !           154:                if (i <= 0)
        !           155:                        break;
        !           156:                if (i < q->ti_len) {
        !           157:                        q->ti_seq += i;
        !           158:                        q->ti_len -= i;
        !           159:                        m_adj(REASS_MBUF(q), i);
        !           160:                        break;
        !           161:                }
        !           162:                q = (struct tcpiphdr *)q->ti_next;
        !           163:                m = REASS_MBUF((struct tcpiphdr *)q->ti_prev);
        !           164:                remque(q->ti_prev);
        !           165:                m_freem(m);
        !           166:        }
        !           167: 
        !           168:        /*
        !           169:         * Stick new segment in its place.
        !           170:         */
        !           171:        insque(ti, q->ti_prev);
        !           172: 
        !           173: present:
        !           174:        /*
        !           175:         * Present data to user, advancing rcv_nxt through
        !           176:         * completed sequence space.
        !           177:         */
        !           178:        if (TCPS_HAVERCVDSYN(tp->t_state) == 0)
        !           179:                return (0);
        !           180:        ti = tp->seg_next;
        !           181:        if (ti == (struct tcpiphdr *)tp || ti->ti_seq != tp->rcv_nxt)
        !           182:                return (0);
        !           183:        if (tp->t_state == TCPS_SYN_RECEIVED && ti->ti_len)
        !           184:                return (0);
        !           185:        do {
        !           186:                tp->rcv_nxt += ti->ti_len;
        !           187:                flags = ti->ti_flags & TH_FIN;
        !           188:                remque(ti);
        !           189:                m = REASS_MBUF(ti);
        !           190:                ti = (struct tcpiphdr *)ti->ti_next;
        !           191:                if (so->so_state & SS_CANTRCVMORE)
        !           192:                        m_freem(m);
        !           193:                else
        !           194:                        sbappend(&so->so_rcv, m);
        !           195:        } while (ti != (struct tcpiphdr *)tp && ti->ti_seq == tp->rcv_nxt);
        !           196:        sorwakeup(so);
        !           197:        return (flags);
        !           198: }
        !           199: 
        !           200: /*
        !           201:  * TCP input routine, follows pages 65-76 of the
        !           202:  * protocol specification dated September, 1981 very closely.
        !           203:  */
        !           204: tcp_input(m, iphlen)
        !           205:        register struct mbuf *m;
        !           206:        int iphlen;
        !           207: {
        !           208:        register struct tcpiphdr *ti;
        !           209:        register struct inpcb *inp;
        !           210:        struct mbuf *om = 0;
        !           211:        int len, tlen, off;
        !           212:        register struct tcpcb *tp = 0;
        !           213:        register int tiflags;
        !           214:        struct socket *so;
        !           215:        int todrop, acked, ourfinisacked, needoutput = 0;
        !           216:        short ostate;
        !           217:        struct in_addr laddr;
        !           218:        int dropsocket = 0;
        !           219:        int iss = 0;
        !           220: 
        !           221:        tcpstat.tcps_rcvtotal++;
        !           222:        /*
        !           223:         * Get IP and TCP header together in first mbuf.
        !           224:         * Note: IP leaves IP header in first mbuf.
        !           225:         */
        !           226:        ti = mtod(m, struct tcpiphdr *);
        !           227:        if (iphlen > sizeof (struct ip))
        !           228:                ip_stripoptions(m, (struct mbuf *)0);
        !           229:        if (m->m_len < sizeof (struct tcpiphdr)) {
        !           230:                if ((m = m_pullup(m, sizeof (struct tcpiphdr))) == 0) {
        !           231:                        tcpstat.tcps_rcvshort++;
        !           232:                        return;
        !           233:                }
        !           234:                ti = mtod(m, struct tcpiphdr *);
        !           235:        }
        !           236: 
        !           237:        /*
        !           238:         * Checksum extended TCP header and data.
        !           239:         */
        !           240:        tlen = ((struct ip *)ti)->ip_len;
        !           241:        len = sizeof (struct ip) + tlen;
        !           242:        ti->ti_next = ti->ti_prev = 0;
        !           243:        ti->ti_x1 = 0;
        !           244:        ti->ti_len = (u_short)tlen;
        !           245:        HTONS(ti->ti_len);
        !           246:        if (ti->ti_sum = in_cksum(m, len)) {
        !           247:                tcpstat.tcps_rcvbadsum++;
        !           248:                goto drop;
        !           249:        }
        !           250: 
        !           251:        /*
        !           252:         * Check that TCP offset makes sense,
        !           253:         * pull out TCP options and adjust length.              XXX
        !           254:         */
        !           255:        off = ti->ti_off << 2;
        !           256:        if (off < sizeof (struct tcphdr) || off > tlen) {
        !           257:                tcpstat.tcps_rcvbadoff++;
        !           258:                goto drop;
        !           259:        }
        !           260:        tlen -= off;
        !           261:        ti->ti_len = tlen;
        !           262:        if (off > sizeof (struct tcphdr)) {
        !           263:                if (m->m_len < sizeof(struct ip) + off) {
        !           264:                        if ((m = m_pullup(m, sizeof (struct ip) + off)) == 0) {
        !           265:                                tcpstat.tcps_rcvshort++;
        !           266:                                return;
        !           267:                        }
        !           268:                        ti = mtod(m, struct tcpiphdr *);
        !           269:                }
        !           270:                om = m_get(M_DONTWAIT, MT_DATA);
        !           271:                if (om == 0)
        !           272:                        goto drop;
        !           273:                om->m_len = off - sizeof (struct tcphdr);
        !           274:                { caddr_t op = mtod(m, caddr_t) + sizeof (struct tcpiphdr);
        !           275:                  bcopy(op, mtod(om, caddr_t), (unsigned)om->m_len);
        !           276:                  m->m_len -= om->m_len;
        !           277:                  m->m_pkthdr.len -= om->m_len;
        !           278:                  bcopy(op+om->m_len, op,
        !           279:                   (unsigned)(m->m_len-sizeof (struct tcpiphdr)));
        !           280:                }
        !           281:        }
        !           282:        tiflags = ti->ti_flags;
        !           283: 
        !           284:        /*
        !           285:         * Convert TCP protocol specific fields to host format.
        !           286:         */
        !           287:        NTOHL(ti->ti_seq);
        !           288:        NTOHL(ti->ti_ack);
        !           289:        NTOHS(ti->ti_win);
        !           290:        NTOHS(ti->ti_urp);
        !           291: 
        !           292:        /*
        !           293:         * Locate pcb for segment.
        !           294:         */
        !           295: findpcb:
        !           296:        inp = tcp_last_inpcb;
        !           297:        if (inp->inp_lport != ti->ti_dport ||
        !           298:            inp->inp_fport != ti->ti_sport ||
        !           299:            inp->inp_faddr.s_addr != ti->ti_src.s_addr ||
        !           300:            inp->inp_laddr.s_addr != ti->ti_dst.s_addr) {
        !           301:                inp = in_pcblookup(&tcb, ti->ti_src, ti->ti_sport,
        !           302:                    ti->ti_dst, ti->ti_dport, INPLOOKUP_WILDCARD);
        !           303:                if (inp)
        !           304:                        tcp_last_inpcb = inp;
        !           305:                ++tcppcbcachemiss;
        !           306:        }
        !           307: 
        !           308:        /*
        !           309:         * If the state is CLOSED (i.e., TCB does not exist) then
        !           310:         * all data in the incoming segment is discarded.
        !           311:         * If the TCB exists but is in CLOSED state, it is embryonic,
        !           312:         * but should either do a listen or a connect soon.
        !           313:         */
        !           314:        if (inp == 0)
        !           315:                goto dropwithreset;
        !           316:        tp = intotcpcb(inp);
        !           317:        if (tp == 0)
        !           318:                goto dropwithreset;
        !           319:        if (tp->t_state == TCPS_CLOSED)
        !           320:                goto drop;
        !           321:        so = inp->inp_socket;
        !           322:        if (so->so_options & (SO_DEBUG|SO_ACCEPTCONN)) {
        !           323:                if (so->so_options & SO_DEBUG) {
        !           324:                        ostate = tp->t_state;
        !           325:                        tcp_saveti = *ti;
        !           326:                }
        !           327:                if (so->so_options & SO_ACCEPTCONN) {
        !           328:                        so = sonewconn(so, 0);
        !           329:                        if (so == 0)
        !           330:                                goto drop;
        !           331:                        /*
        !           332:                         * This is ugly, but ....
        !           333:                         *
        !           334:                         * Mark socket as temporary until we're
        !           335:                         * committed to keeping it.  The code at
        !           336:                         * ``drop'' and ``dropwithreset'' check the
        !           337:                         * flag dropsocket to see if the temporary
        !           338:                         * socket created here should be discarded.
        !           339:                         * We mark the socket as discardable until
        !           340:                         * we're committed to it below in TCPS_LISTEN.
        !           341:                         */
        !           342:                        dropsocket++;
        !           343:                        inp = (struct inpcb *)so->so_pcb;
        !           344:                        inp->inp_laddr = ti->ti_dst;
        !           345:                        inp->inp_lport = ti->ti_dport;
        !           346: #if BSD>=43
        !           347:                        inp->inp_options = ip_srcroute();
        !           348: #endif
        !           349:                        tp = intotcpcb(inp);
        !           350:                        tp->t_state = TCPS_LISTEN;
        !           351:                }
        !           352:        }
        !           353: 
        !           354:        /*
        !           355:         * Segment received on connection.
        !           356:         * Reset idle time and keep-alive timer.
        !           357:         */
        !           358:        tp->t_idle = 0;
        !           359:        tp->t_timer[TCPT_KEEP] = tcp_keepidle;
        !           360: 
        !           361:        /*
        !           362:         * Process options if not in LISTEN state,
        !           363:         * else do it below (after getting remote address).
        !           364:         */
        !           365:        if (om && tp->t_state != TCPS_LISTEN) {
        !           366:                tcp_dooptions(tp, om, ti);
        !           367:                om = 0;
        !           368:        }
        !           369:        /* 
        !           370:         * Header prediction: check for the two common cases
        !           371:         * of a uni-directional data xfer.  If the packet has
        !           372:         * no control flags, is in-sequence, the window didn't
        !           373:         * change and we're not retransmitting, it's a
        !           374:         * candidate.  If the length is zero and the ack moved
        !           375:         * forward, we're the sender side of the xfer.  Just
        !           376:         * free the data acked & wake any higher level process
        !           377:         * that was blocked waiting for space.  If the length
        !           378:         * is non-zero and the ack didn't move, we're the
        !           379:         * receiver side.  If we're getting packets in-order
        !           380:         * (the reassembly queue is empty), add the data to
        !           381:         * the socket buffer and note that we need a delayed ack.
        !           382:         */
        !           383:        if (tp->t_state == TCPS_ESTABLISHED &&
        !           384:            (tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK &&
        !           385:            ti->ti_seq == tp->rcv_nxt &&
        !           386:            ti->ti_win && ti->ti_win == tp->snd_wnd &&
        !           387:            tp->snd_nxt == tp->snd_max) {
        !           388:                if (ti->ti_len == 0) {
        !           389:                        if (SEQ_GT(ti->ti_ack, tp->snd_una) &&
        !           390:                            SEQ_LEQ(ti->ti_ack, tp->snd_max) &&
        !           391:                            tp->snd_cwnd >= tp->snd_wnd) {
        !           392:                                /*
        !           393:                                 * this is a pure ack for outstanding data.
        !           394:                                 */
        !           395:                                ++tcppredack;
        !           396:                                if (tp->t_rtt && SEQ_GT(ti->ti_ack,tp->t_rtseq))
        !           397:                                        tcp_xmit_timer(tp);
        !           398:                                acked = ti->ti_ack - tp->snd_una;
        !           399:                                tcpstat.tcps_rcvackpack++;
        !           400:                                tcpstat.tcps_rcvackbyte += acked;
        !           401:                                sbdrop(&so->so_snd, acked);
        !           402:                                tp->snd_una = ti->ti_ack;
        !           403:                                m_freem(m);
        !           404: 
        !           405:                                /*
        !           406:                                 * If all outstanding data are acked, stop
        !           407:                                 * retransmit timer, otherwise restart timer
        !           408:                                 * using current (possibly backed-off) value.
        !           409:                                 * If process is waiting for space,
        !           410:                                 * wakeup/selwakeup/signal.  If data
        !           411:                                 * are ready to send, let tcp_output
        !           412:                                 * decide between more output or persist.
        !           413:                                 */
        !           414:                                if (tp->snd_una == tp->snd_max)
        !           415:                                        tp->t_timer[TCPT_REXMT] = 0;
        !           416:                                else if (tp->t_timer[TCPT_PERSIST] == 0)
        !           417:                                        tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
        !           418: 
        !           419:                                if (so->so_snd.sb_flags & SB_NOTIFY)
        !           420:                                        sowwakeup(so);
        !           421:                                if (so->so_snd.sb_cc)
        !           422:                                        (void) tcp_output(tp);
        !           423:                                return;
        !           424:                        }
        !           425:                } else if (ti->ti_ack == tp->snd_una &&
        !           426:                    tp->seg_next == (struct tcpiphdr *)tp &&
        !           427:                    ti->ti_len <= sbspace(&so->so_rcv)) {
        !           428:                        /*
        !           429:                         * this is a pure, in-sequence data packet
        !           430:                         * with nothing on the reassembly queue and
        !           431:                         * we have enough buffer space to take it.
        !           432:                         */
        !           433:                        ++tcppreddat;
        !           434:                        tp->rcv_nxt += ti->ti_len;
        !           435:                        tcpstat.tcps_rcvpack++;
        !           436:                        tcpstat.tcps_rcvbyte += ti->ti_len;
        !           437:                        /*
        !           438:                         * Drop TCP and IP headers then add data
        !           439:                         * to socket buffer
        !           440:                         */
        !           441:                        m->m_data += sizeof(struct tcpiphdr);
        !           442:                        m->m_len -= sizeof(struct tcpiphdr);
        !           443:                        sbappend(&so->so_rcv, m);
        !           444:                        sorwakeup(so);
        !           445:                        tp->t_flags |= TF_DELACK;
        !           446:                        return;
        !           447:                }
        !           448:        }
        !           449: 
        !           450:        /*
        !           451:         * Drop TCP and IP headers; TCP options were dropped above.
        !           452:         */
        !           453:        m->m_data += sizeof(struct tcpiphdr);
        !           454:        m->m_len -= sizeof(struct tcpiphdr);
        !           455: 
        !           456:        /*
        !           457:         * Calculate amount of space in receive window,
        !           458:         * and then do TCP input processing.
        !           459:         * Receive window is amount of space in rcv queue,
        !           460:         * but not less than advertised window.
        !           461:         */
        !           462:        { int win;
        !           463: 
        !           464:        win = sbspace(&so->so_rcv);
        !           465:        if (win < 0)
        !           466:                win = 0;
        !           467:        tp->rcv_wnd = max(win, (int)(tp->rcv_adv - tp->rcv_nxt));
        !           468:        }
        !           469: 
        !           470:        switch (tp->t_state) {
        !           471: 
        !           472:        /*
        !           473:         * If the state is LISTEN then ignore segment if it contains an RST.
        !           474:         * If the segment contains an ACK then it is bad and send a RST.
        !           475:         * If it does not contain a SYN then it is not interesting; drop it.
        !           476:         * Don't bother responding if the destination was a broadcast.
        !           477:         * Otherwise initialize tp->rcv_nxt, and tp->irs, select an initial
        !           478:         * tp->iss, and send a segment:
        !           479:         *     <SEQ=ISS><ACK=RCV_NXT><CTL=SYN,ACK>
        !           480:         * Also initialize tp->snd_nxt to tp->iss+1 and tp->snd_una to tp->iss.
        !           481:         * Fill in remote peer address fields if not previously specified.
        !           482:         * Enter SYN_RECEIVED state, and process any other fields of this
        !           483:         * segment in this state.
        !           484:         */
        !           485:        case TCPS_LISTEN: {
        !           486:                struct mbuf *am;
        !           487:                register struct sockaddr_in *sin;
        !           488: 
        !           489:                if (tiflags & TH_RST)
        !           490:                        goto drop;
        !           491:                if (tiflags & TH_ACK)
        !           492:                        goto dropwithreset;
        !           493:                if ((tiflags & TH_SYN) == 0)
        !           494:                        goto drop;
        !           495:                if (m->m_flags & M_BCAST)
        !           496:                        goto drop;
        !           497:                am = m_get(M_DONTWAIT, MT_SONAME);      /* XXX */
        !           498:                if (am == NULL)
        !           499:                        goto drop;
        !           500:                am->m_len = sizeof (struct sockaddr_in);
        !           501:                sin = mtod(am, struct sockaddr_in *);
        !           502:                sin->sin_family = AF_INET;
        !           503:                sin->sin_len = sizeof(*sin);
        !           504:                sin->sin_addr = ti->ti_src;
        !           505:                sin->sin_port = ti->ti_sport;
        !           506:                laddr = inp->inp_laddr;
        !           507:                if (inp->inp_laddr.s_addr == INADDR_ANY)
        !           508:                        inp->inp_laddr = ti->ti_dst;
        !           509:                if (in_pcbconnect(inp, am)) {
        !           510:                        inp->inp_laddr = laddr;
        !           511:                        (void) m_free(am);
        !           512:                        goto drop;
        !           513:                }
        !           514:                (void) m_free(am);
        !           515:                tp->t_template = tcp_template(tp);
        !           516:                if (tp->t_template == 0) {
        !           517:                        tp = tcp_drop(tp, ENOBUFS);
        !           518:                        dropsocket = 0;         /* socket is already gone */
        !           519:                        goto drop;
        !           520:                }
        !           521:                if (om) {
        !           522:                        tcp_dooptions(tp, om, ti);
        !           523:                        om = 0;
        !           524:                }
        !           525:                if (iss)
        !           526:                        tp->iss = iss;
        !           527:                else
        !           528:                        tp->iss = tcp_iss;
        !           529:                tcp_iss += TCP_ISSINCR/2;
        !           530:                tp->irs = ti->ti_seq;
        !           531:                tcp_sendseqinit(tp);
        !           532:                tcp_rcvseqinit(tp);
        !           533:                tp->t_flags |= TF_ACKNOW;
        !           534:                tp->t_state = TCPS_SYN_RECEIVED;
        !           535:                tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
        !           536:                dropsocket = 0;         /* committed to socket */
        !           537:                tcpstat.tcps_accepts++;
        !           538:                goto trimthenstep6;
        !           539:                }
        !           540: 
        !           541:        /*
        !           542:         * If the state is SYN_SENT:
        !           543:         *      if seg contains an ACK, but not for our SYN, drop the input.
        !           544:         *      if seg contains a RST, then drop the connection.
        !           545:         *      if seg does not contain SYN, then drop it.
        !           546:         * Otherwise this is an acceptable SYN segment
        !           547:         *      initialize tp->rcv_nxt and tp->irs
        !           548:         *      if seg contains ack then advance tp->snd_una
        !           549:         *      if SYN has been acked change to ESTABLISHED else SYN_RCVD state
        !           550:         *      arrange for segment to be acked (eventually)
        !           551:         *      continue processing rest of data/controls, beginning with URG
        !           552:         */
        !           553:        case TCPS_SYN_SENT:
        !           554:                if ((tiflags & TH_ACK) &&
        !           555:                    (SEQ_LEQ(ti->ti_ack, tp->iss) ||
        !           556:                     SEQ_GT(ti->ti_ack, tp->snd_max)))
        !           557:                        goto dropwithreset;
        !           558:                if (tiflags & TH_RST) {
        !           559:                        if (tiflags & TH_ACK)
        !           560:                                tp = tcp_drop(tp, ECONNREFUSED);
        !           561:                        goto drop;
        !           562:                }
        !           563:                if ((tiflags & TH_SYN) == 0)
        !           564:                        goto drop;
        !           565:                if (tiflags & TH_ACK) {
        !           566:                        tp->snd_una = ti->ti_ack;
        !           567:                        if (SEQ_LT(tp->snd_nxt, tp->snd_una))
        !           568:                                tp->snd_nxt = tp->snd_una;
        !           569:                }
        !           570:                tp->t_timer[TCPT_REXMT] = 0;
        !           571:                tp->irs = ti->ti_seq;
        !           572:                tcp_rcvseqinit(tp);
        !           573:                tp->t_flags |= TF_ACKNOW;
        !           574:                if (tiflags & TH_ACK && SEQ_GT(tp->snd_una, tp->iss)) {
        !           575:                        tcpstat.tcps_connects++;
        !           576:                        soisconnected(so);
        !           577:                        tp->t_state = TCPS_ESTABLISHED;
        !           578:                        (void) tcp_reass(tp, (struct tcpiphdr *)0,
        !           579:                                (struct mbuf *)0);
        !           580:                        /*
        !           581:                         * if we didn't have to retransmit the SYN,
        !           582:                         * use its rtt as our initial srtt & rtt var.
        !           583:                         */
        !           584:                        if (tp->t_rtt)
        !           585:                                tcp_xmit_timer(tp);
        !           586:                } else
        !           587:                        tp->t_state = TCPS_SYN_RECEIVED;
        !           588: 
        !           589: trimthenstep6:
        !           590:                /*
        !           591:                 * Advance ti->ti_seq to correspond to first data byte.
        !           592:                 * If data, trim to stay within window,
        !           593:                 * dropping FIN if necessary.
        !           594:                 */
        !           595:                ti->ti_seq++;
        !           596:                if (ti->ti_len > tp->rcv_wnd) {
        !           597:                        todrop = ti->ti_len - tp->rcv_wnd;
        !           598:                        m_adj(m, -todrop);
        !           599:                        ti->ti_len = tp->rcv_wnd;
        !           600:                        tiflags &= ~TH_FIN;
        !           601:                        tcpstat.tcps_rcvpackafterwin++;
        !           602:                        tcpstat.tcps_rcvbyteafterwin += todrop;
        !           603:                }
        !           604:                tp->snd_wl1 = ti->ti_seq - 1;
        !           605:                tp->rcv_up = ti->ti_seq;
        !           606:                goto step6;
        !           607:        }
        !           608: 
        !           609:        /*
        !           610:         * States other than LISTEN or SYN_SENT.
        !           611:         * First check that at least some bytes of segment are within 
        !           612:         * receive window.  If segment begins before rcv_nxt,
        !           613:         * drop leading data (and SYN); if nothing left, just ack.
        !           614:         */
        !           615:        todrop = tp->rcv_nxt - ti->ti_seq;
        !           616:        if (todrop > 0) {
        !           617:                if (tiflags & TH_SYN) {
        !           618:                        tiflags &= ~TH_SYN;
        !           619:                        ti->ti_seq++;
        !           620:                        if (ti->ti_urp > 1) 
        !           621:                                ti->ti_urp--;
        !           622:                        else
        !           623:                                tiflags &= ~TH_URG;
        !           624:                        todrop--;
        !           625:                }
        !           626:                if (todrop > ti->ti_len ||
        !           627:                    todrop == ti->ti_len && (tiflags&TH_FIN) == 0) {
        !           628:                        tcpstat.tcps_rcvduppack++;
        !           629:                        tcpstat.tcps_rcvdupbyte += ti->ti_len;
        !           630:                        /*
        !           631:                         * If segment is just one to the left of the window,
        !           632:                         * check two special cases:
        !           633:                         * 1. Don't toss RST in response to 4.2-style keepalive.
        !           634:                         * 2. If the only thing to drop is a FIN, we can drop
        !           635:                         *    it, but check the ACK or we will get into FIN
        !           636:                         *    wars if our FINs crossed (both CLOSING).
        !           637:                         * In either case, send ACK to resynchronize,
        !           638:                         * but keep on processing for RST or ACK.
        !           639:                         */
        !           640:                        if ((tiflags & TH_FIN && todrop == ti->ti_len + 1)
        !           641: #ifdef TCP_COMPAT_42
        !           642:                          || (tiflags & TH_RST && ti->ti_seq == tp->rcv_nxt - 1)
        !           643: #endif
        !           644:                           ) {
        !           645:                                todrop = ti->ti_len;
        !           646:                                tiflags &= ~TH_FIN;
        !           647:                                tp->t_flags |= TF_ACKNOW;
        !           648:                        } else
        !           649:                                goto dropafterack;
        !           650:                } else {
        !           651:                        tcpstat.tcps_rcvpartduppack++;
        !           652:                        tcpstat.tcps_rcvpartdupbyte += todrop;
        !           653:                }
        !           654:                m_adj(m, todrop);
        !           655:                ti->ti_seq += todrop;
        !           656:                ti->ti_len -= todrop;
        !           657:                if (ti->ti_urp > todrop)
        !           658:                        ti->ti_urp -= todrop;
        !           659:                else {
        !           660:                        tiflags &= ~TH_URG;
        !           661:                        ti->ti_urp = 0;
        !           662:                }
        !           663:        }
        !           664: 
        !           665:        /*
        !           666:         * If new data are received on a connection after the
        !           667:         * user processes are gone, then RST the other end.
        !           668:         */
        !           669:        if ((so->so_state & SS_NOFDREF) &&
        !           670:            tp->t_state > TCPS_CLOSE_WAIT && ti->ti_len) {
        !           671:                tp = tcp_close(tp);
        !           672:                tcpstat.tcps_rcvafterclose++;
        !           673:                goto dropwithreset;
        !           674:        }
        !           675: 
        !           676:        /*
        !           677:         * If segment ends after window, drop trailing data
        !           678:         * (and PUSH and FIN); if nothing left, just ACK.
        !           679:         */
        !           680:        todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd);
        !           681:        if (todrop > 0) {
        !           682:                tcpstat.tcps_rcvpackafterwin++;
        !           683:                if (todrop >= ti->ti_len) {
        !           684:                        tcpstat.tcps_rcvbyteafterwin += ti->ti_len;
        !           685:                        /*
        !           686:                         * If a new connection request is received
        !           687:                         * while in TIME_WAIT, drop the old connection
        !           688:                         * and start over if the sequence numbers
        !           689:                         * are above the previous ones.
        !           690:                         */
        !           691:                        if (tiflags & TH_SYN &&
        !           692:                            tp->t_state == TCPS_TIME_WAIT &&
        !           693:                            SEQ_GT(ti->ti_seq, tp->rcv_nxt)) {
        !           694:                                iss = tp->rcv_nxt + TCP_ISSINCR;
        !           695:                                tp = tcp_close(tp);
        !           696:                                goto findpcb;
        !           697:                        }
        !           698:                        /*
        !           699:                         * If window is closed can only take segments at
        !           700:                         * window edge, and have to drop data and PUSH from
        !           701:                         * incoming segments.  Continue processing, but
        !           702:                         * remember to ack.  Otherwise, drop segment
        !           703:                         * and ack.
        !           704:                         */
        !           705:                        if (tp->rcv_wnd == 0 && ti->ti_seq == tp->rcv_nxt) {
        !           706:                                tp->t_flags |= TF_ACKNOW;
        !           707:                                tcpstat.tcps_rcvwinprobe++;
        !           708:                        } else
        !           709:                                goto dropafterack;
        !           710:                } else
        !           711:                        tcpstat.tcps_rcvbyteafterwin += todrop;
        !           712:                m_adj(m, -todrop);
        !           713:                ti->ti_len -= todrop;
        !           714:                tiflags &= ~(TH_PUSH|TH_FIN);
        !           715:        }
        !           716: 
        !           717:        /*
        !           718:         * If the RST bit is set examine the state:
        !           719:         *    SYN_RECEIVED STATE:
        !           720:         *      If passive open, return to LISTEN state.
        !           721:         *      If active open, inform user that connection was refused.
        !           722:         *    ESTABLISHED, FIN_WAIT_1, FIN_WAIT2, CLOSE_WAIT STATES:
        !           723:         *      Inform user that connection was reset, and close tcb.
        !           724:         *    CLOSING, LAST_ACK, TIME_WAIT STATES
        !           725:         *      Close the tcb.
        !           726:         */
        !           727:        if (tiflags&TH_RST) switch (tp->t_state) {
        !           728: 
        !           729:        case TCPS_SYN_RECEIVED:
        !           730:                so->so_error = ECONNREFUSED;
        !           731:                goto close;
        !           732: 
        !           733:        case TCPS_ESTABLISHED:
        !           734:        case TCPS_FIN_WAIT_1:
        !           735:        case TCPS_FIN_WAIT_2:
        !           736:        case TCPS_CLOSE_WAIT:
        !           737:                so->so_error = ECONNRESET;
        !           738:        close:
        !           739:                tp->t_state = TCPS_CLOSED;
        !           740:                tcpstat.tcps_drops++;
        !           741:                tp = tcp_close(tp);
        !           742:                goto drop;
        !           743: 
        !           744:        case TCPS_CLOSING:
        !           745:        case TCPS_LAST_ACK:
        !           746:        case TCPS_TIME_WAIT:
        !           747:                tp = tcp_close(tp);
        !           748:                goto drop;
        !           749:        }
        !           750: 
        !           751:        /*
        !           752:         * If a SYN is in the window, then this is an
        !           753:         * error and we send an RST and drop the connection.
        !           754:         */
        !           755:        if (tiflags & TH_SYN) {
        !           756:                tp = tcp_drop(tp, ECONNRESET);
        !           757:                goto dropwithreset;
        !           758:        }
        !           759: 
        !           760:        /*
        !           761:         * If the ACK bit is off we drop the segment and return.
        !           762:         */
        !           763:        if ((tiflags & TH_ACK) == 0)
        !           764:                goto drop;
        !           765:        
        !           766:        /*
        !           767:         * Ack processing.
        !           768:         */
        !           769:        switch (tp->t_state) {
        !           770: 
        !           771:        /*
        !           772:         * In SYN_RECEIVED state if the ack ACKs our SYN then enter
        !           773:         * ESTABLISHED state and continue processing, otherwise
        !           774:         * send an RST.
        !           775:         */
        !           776:        case TCPS_SYN_RECEIVED:
        !           777:                if (SEQ_GT(tp->snd_una, ti->ti_ack) ||
        !           778:                    SEQ_GT(ti->ti_ack, tp->snd_max))
        !           779:                        goto dropwithreset;
        !           780:                tcpstat.tcps_connects++;
        !           781:                soisconnected(so);
        !           782:                tp->t_state = TCPS_ESTABLISHED;
        !           783:                (void) tcp_reass(tp, (struct tcpiphdr *)0, (struct mbuf *)0);
        !           784:                tp->snd_wl1 = ti->ti_seq - 1;
        !           785:                /* fall into ... */
        !           786: 
        !           787:        /*
        !           788:         * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
        !           789:         * ACKs.  If the ack is in the range
        !           790:         *      tp->snd_una < ti->ti_ack <= tp->snd_max
        !           791:         * then advance tp->snd_una to ti->ti_ack and drop
        !           792:         * data from the retransmission queue.  If this ACK reflects
        !           793:         * more up to date window information we update our window information.
        !           794:         */
        !           795:        case TCPS_ESTABLISHED:
        !           796:        case TCPS_FIN_WAIT_1:
        !           797:        case TCPS_FIN_WAIT_2:
        !           798:        case TCPS_CLOSE_WAIT:
        !           799:        case TCPS_CLOSING:
        !           800:        case TCPS_LAST_ACK:
        !           801:        case TCPS_TIME_WAIT:
        !           802: 
        !           803:                if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {
        !           804:                        if (ti->ti_len == 0 && ti->ti_win == tp->snd_wnd) {
        !           805:                                tcpstat.tcps_rcvdupack++;
        !           806:                                /*
        !           807:                                 * If we have outstanding data (other than
        !           808:                                 * a window probe), this is a completely
        !           809:                                 * duplicate ack (ie, window info didn't
        !           810:                                 * change), the ack is the biggest we've
        !           811:                                 * seen and we've seen exactly our rexmt
        !           812:                                 * threshhold of them, assume a packet
        !           813:                                 * has been dropped and retransmit it.
        !           814:                                 * Kludge snd_nxt & the congestion
        !           815:                                 * window so we send only this one
        !           816:                                 * packet.
        !           817:                                 *
        !           818:                                 * We know we're losing at the current
        !           819:                                 * window size so do congestion avoidance
        !           820:                                 * (set ssthresh to half the current window
        !           821:                                 * and pull our congestion window back to
        !           822:                                 * the new ssthresh).
        !           823:                                 *
        !           824:                                 * Dup acks mean that packets have left the
        !           825:                                 * network (they're now cached at the receiver) 
        !           826:                                 * so bump cwnd by the amount in the receiver
        !           827:                                 * to keep a constant cwnd packets in the
        !           828:                                 * network.
        !           829:                                 */
        !           830:                                if (tp->t_timer[TCPT_REXMT] == 0 ||
        !           831:                                    ti->ti_ack != tp->snd_una)
        !           832:                                        tp->t_dupacks = 0;
        !           833:                                else if (++tp->t_dupacks == tcprexmtthresh) {
        !           834:                                        tcp_seq onxt = tp->snd_nxt;
        !           835:                                        u_int win =
        !           836:                                            min(tp->snd_wnd, tp->snd_cwnd) / 2 /
        !           837:                                                tp->t_maxseg;
        !           838: 
        !           839:                                        if (win < 2)
        !           840:                                                win = 2;
        !           841:                                        tp->snd_ssthresh = win * tp->t_maxseg;
        !           842:                                        tp->t_timer[TCPT_REXMT] = 0;
        !           843:                                        tp->t_rtt = 0;
        !           844:                                        tp->snd_nxt = ti->ti_ack;
        !           845:                                        tp->snd_cwnd = tp->t_maxseg;
        !           846:                                        (void) tcp_output(tp);
        !           847:                                        tp->snd_cwnd = tp->snd_ssthresh +
        !           848:                                               tp->t_maxseg * tp->t_dupacks;
        !           849:                                        if (SEQ_GT(onxt, tp->snd_nxt))
        !           850:                                                tp->snd_nxt = onxt;
        !           851:                                        goto drop;
        !           852:                                } else if (tp->t_dupacks > tcprexmtthresh) {
        !           853:                                        tp->snd_cwnd += tp->t_maxseg;
        !           854:                                        (void) tcp_output(tp);
        !           855:                                        goto drop;
        !           856:                                }
        !           857:                        } else
        !           858:                                tp->t_dupacks = 0;
        !           859:                        break;
        !           860:                }
        !           861:                /*
        !           862:                 * If the congestion window was inflated to account
        !           863:                 * for the other side's cached packets, retract it.
        !           864:                 */
        !           865:                if (tp->t_dupacks > tcprexmtthresh &&
        !           866:                    tp->snd_cwnd > tp->snd_ssthresh)
        !           867:                        tp->snd_cwnd = tp->snd_ssthresh;
        !           868:                tp->t_dupacks = 0;
        !           869:                if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
        !           870:                        tcpstat.tcps_rcvacktoomuch++;
        !           871:                        goto dropafterack;
        !           872:                }
        !           873:                acked = ti->ti_ack - tp->snd_una;
        !           874:                tcpstat.tcps_rcvackpack++;
        !           875:                tcpstat.tcps_rcvackbyte += acked;
        !           876: 
        !           877:                /*
        !           878:                 * If transmit timer is running and timed sequence
        !           879:                 * number was acked, update smoothed round trip time.
        !           880:                 * Since we now have an rtt measurement, cancel the
        !           881:                 * timer backoff (cf., Phil Karn's retransmit alg.).
        !           882:                 * Recompute the initial retransmit timer.
        !           883:                 */
        !           884:                if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq))
        !           885:                        tcp_xmit_timer(tp);
        !           886: 
        !           887:                /*
        !           888:                 * If all outstanding data is acked, stop retransmit
        !           889:                 * timer and remember to restart (more output or persist).
        !           890:                 * If there is more data to be acked, restart retransmit
        !           891:                 * timer, using current (possibly backed-off) value.
        !           892:                 */
        !           893:                if (ti->ti_ack == tp->snd_max) {
        !           894:                        tp->t_timer[TCPT_REXMT] = 0;
        !           895:                        needoutput = 1;
        !           896:                } else if (tp->t_timer[TCPT_PERSIST] == 0)
        !           897:                        tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
        !           898:                /*
        !           899:                 * When new data is acked, open the congestion window.
        !           900:                 * If the window gives us less than ssthresh packets
        !           901:                 * in flight, open exponentially (maxseg per packet).
        !           902:                 * Otherwise open linearly: maxseg per window
        !           903:                 * (maxseg^2 / cwnd per packet), plus a constant
        !           904:                 * fraction of a packet (maxseg/8) to help larger windows
        !           905:                 * open quickly enough.
        !           906:                 */
        !           907:                {
        !           908:                register u_int cw = tp->snd_cwnd;
        !           909:                register u_int incr = tp->t_maxseg;
        !           910: 
        !           911:                if (cw > tp->snd_ssthresh)
        !           912:                        incr = incr * incr / cw + incr / 8;
        !           913:                tp->snd_cwnd = min(cw + incr, TCP_MAXWIN);
        !           914:                }
        !           915:                if (acked > so->so_snd.sb_cc) {
        !           916:                        tp->snd_wnd -= so->so_snd.sb_cc;
        !           917:                        sbdrop(&so->so_snd, (int)so->so_snd.sb_cc);
        !           918:                        ourfinisacked = 1;
        !           919:                } else {
        !           920:                        sbdrop(&so->so_snd, acked);
        !           921:                        tp->snd_wnd -= acked;
        !           922:                        ourfinisacked = 0;
        !           923:                }
        !           924:                if (so->so_snd.sb_flags & SB_NOTIFY)
        !           925:                        sowwakeup(so);
        !           926:                tp->snd_una = ti->ti_ack;
        !           927:                if (SEQ_LT(tp->snd_nxt, tp->snd_una))
        !           928:                        tp->snd_nxt = tp->snd_una;
        !           929: 
        !           930:                switch (tp->t_state) {
        !           931: 
        !           932:                /*
        !           933:                 * In FIN_WAIT_1 STATE in addition to the processing
        !           934:                 * for the ESTABLISHED state if our FIN is now acknowledged
        !           935:                 * then enter FIN_WAIT_2.
        !           936:                 */
        !           937:                case TCPS_FIN_WAIT_1:
        !           938:                        if (ourfinisacked) {
        !           939:                                /*
        !           940:                                 * If we can't receive any more
        !           941:                                 * data, then closing user can proceed.
        !           942:                                 * Starting the timer is contrary to the
        !           943:                                 * specification, but if we don't get a FIN
        !           944:                                 * we'll hang forever.
        !           945:                                 */
        !           946:                                if (so->so_state & SS_CANTRCVMORE) {
        !           947:                                        soisdisconnected(so);
        !           948:                                        tp->t_timer[TCPT_2MSL] = tcp_maxidle;
        !           949:                                }
        !           950:                                tp->t_state = TCPS_FIN_WAIT_2;
        !           951:                        }
        !           952:                        break;
        !           953: 
        !           954:                /*
        !           955:                 * In CLOSING STATE in addition to the processing for
        !           956:                 * the ESTABLISHED state if the ACK acknowledges our FIN
        !           957:                 * then enter the TIME-WAIT state, otherwise ignore
        !           958:                 * the segment.
        !           959:                 */
        !           960:                case TCPS_CLOSING:
        !           961:                        if (ourfinisacked) {
        !           962:                                tp->t_state = TCPS_TIME_WAIT;
        !           963:                                tcp_canceltimers(tp);
        !           964:                                tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
        !           965:                                soisdisconnected(so);
        !           966:                        }
        !           967:                        break;
        !           968: 
        !           969:                /*
        !           970:                 * In LAST_ACK, we may still be waiting for data to drain
        !           971:                 * and/or to be acked, as well as for the ack of our FIN.
        !           972:                 * If our FIN is now acknowledged, delete the TCB,
        !           973:                 * enter the closed state and return.
        !           974:                 */
        !           975:                case TCPS_LAST_ACK:
        !           976:                        if (ourfinisacked) {
        !           977:                                tp = tcp_close(tp);
        !           978:                                goto drop;
        !           979:                        }
        !           980:                        break;
        !           981: 
        !           982:                /*
        !           983:                 * In TIME_WAIT state the only thing that should arrive
        !           984:                 * is a retransmission of the remote FIN.  Acknowledge
        !           985:                 * it and restart the finack timer.
        !           986:                 */
        !           987:                case TCPS_TIME_WAIT:
        !           988:                        tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
        !           989:                        goto dropafterack;
        !           990:                }
        !           991:        }
        !           992: 
        !           993: step6:
        !           994:        /*
        !           995:         * Update window information.
        !           996:         * Don't look at window if no ACK: TAC's send garbage on first SYN.
        !           997:         */
        !           998:        if ((tiflags & TH_ACK) &&
        !           999:            (SEQ_LT(tp->snd_wl1, ti->ti_seq) || tp->snd_wl1 == ti->ti_seq &&
        !          1000:            (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||
        !          1001:             tp->snd_wl2 == ti->ti_ack && ti->ti_win > tp->snd_wnd))) {
        !          1002:                /* keep track of pure window updates */
        !          1003:                if (ti->ti_len == 0 &&
        !          1004:                    tp->snd_wl2 == ti->ti_ack && ti->ti_win > tp->snd_wnd)
        !          1005:                        tcpstat.tcps_rcvwinupd++;
        !          1006:                tp->snd_wnd = ti->ti_win;
        !          1007:                tp->snd_wl1 = ti->ti_seq;
        !          1008:                tp->snd_wl2 = ti->ti_ack;
        !          1009:                if (tp->snd_wnd > tp->max_sndwnd)
        !          1010:                        tp->max_sndwnd = tp->snd_wnd;
        !          1011:                needoutput = 1;
        !          1012:        }
        !          1013: 
        !          1014:        /*
        !          1015:         * Process segments with URG.
        !          1016:         */
        !          1017:        if ((tiflags & TH_URG) && ti->ti_urp &&
        !          1018:            TCPS_HAVERCVDFIN(tp->t_state) == 0) {
        !          1019:                /*
        !          1020:                 * This is a kludge, but if we receive and accept
        !          1021:                 * random urgent pointers, we'll crash in
        !          1022:                 * soreceive.  It's hard to imagine someone
        !          1023:                 * actually wanting to send this much urgent data.
        !          1024:                 */
        !          1025:                if (ti->ti_urp + so->so_rcv.sb_cc > SB_MAX) {
        !          1026:                        ti->ti_urp = 0;                 /* XXX */
        !          1027:                        tiflags &= ~TH_URG;             /* XXX */
        !          1028:                        goto dodata;                    /* XXX */
        !          1029:                }
        !          1030:                /*
        !          1031:                 * If this segment advances the known urgent pointer,
        !          1032:                 * then mark the data stream.  This should not happen
        !          1033:                 * in CLOSE_WAIT, CLOSING, LAST_ACK or TIME_WAIT STATES since
        !          1034:                 * a FIN has been received from the remote side. 
        !          1035:                 * In these states we ignore the URG.
        !          1036:                 *
        !          1037:                 * According to RFC961 (Assigned Protocols),
        !          1038:                 * the urgent pointer points to the last octet
        !          1039:                 * of urgent data.  We continue, however,
        !          1040:                 * to consider it to indicate the first octet
        !          1041:                 * of data past the urgent section as the original 
        !          1042:                 * spec states (in one of two places).
        !          1043:                 */
        !          1044:                if (SEQ_GT(ti->ti_seq+ti->ti_urp, tp->rcv_up)) {
        !          1045:                        tp->rcv_up = ti->ti_seq + ti->ti_urp;
        !          1046:                        so->so_oobmark = so->so_rcv.sb_cc +
        !          1047:                            (tp->rcv_up - tp->rcv_nxt) - 1;
        !          1048:                        if (so->so_oobmark == 0)
        !          1049:                                so->so_state |= SS_RCVATMARK;
        !          1050:                        sohasoutofband(so);
        !          1051:                        tp->t_oobflags &= ~(TCPOOB_HAVEDATA | TCPOOB_HADDATA);
        !          1052:                }
        !          1053:                /*
        !          1054:                 * Remove out of band data so doesn't get presented to user.
        !          1055:                 * This can happen independent of advancing the URG pointer,
        !          1056:                 * but if two URG's are pending at once, some out-of-band
        !          1057:                 * data may creep in... ick.
        !          1058:                 */
        !          1059:                if (ti->ti_urp <= ti->ti_len
        !          1060: #ifdef SO_OOBINLINE
        !          1061:                     && (so->so_options & SO_OOBINLINE) == 0
        !          1062: #endif
        !          1063:                     )
        !          1064:                        tcp_pulloutofband(so, ti, m);
        !          1065:        } else
        !          1066:                /*
        !          1067:                 * If no out of band data is expected,
        !          1068:                 * pull receive urgent pointer along
        !          1069:                 * with the receive window.
        !          1070:                 */
        !          1071:                if (SEQ_GT(tp->rcv_nxt, tp->rcv_up))
        !          1072:                        tp->rcv_up = tp->rcv_nxt;
        !          1073: dodata:                                                        /* XXX */
        !          1074: 
        !          1075:        /*
        !          1076:         * Process the segment text, merging it into the TCP sequencing queue,
        !          1077:         * and arranging for acknowledgment of receipt if necessary.
        !          1078:         * This process logically involves adjusting tp->rcv_wnd as data
        !          1079:         * is presented to the user (this happens in tcp_usrreq.c,
        !          1080:         * case PRU_RCVD).  If a FIN has already been received on this
        !          1081:         * connection then we just ignore the text.
        !          1082:         */
        !          1083:        if ((ti->ti_len || (tiflags&TH_FIN)) &&
        !          1084:            TCPS_HAVERCVDFIN(tp->t_state) == 0) {
        !          1085:                TCP_REASS(tp, ti, m, so, tiflags);
        !          1086:                /*
        !          1087:                 * Note the amount of data that peer has sent into
        !          1088:                 * our window, in order to estimate the sender's
        !          1089:                 * buffer size.
        !          1090:                 */
        !          1091:                len = so->so_rcv.sb_hiwat - (tp->rcv_adv - tp->rcv_nxt);
        !          1092:        } else {
        !          1093:                m_freem(m);
        !          1094:                tiflags &= ~TH_FIN;
        !          1095:        }
        !          1096: 
        !          1097:        /*
        !          1098:         * If FIN is received ACK the FIN and let the user know
        !          1099:         * that the connection is closing.
        !          1100:         */
        !          1101:        if (tiflags & TH_FIN) {
        !          1102:                if (TCPS_HAVERCVDFIN(tp->t_state) == 0) {
        !          1103:                        socantrcvmore(so);
        !          1104:                        tp->t_flags |= TF_ACKNOW;
        !          1105:                        tp->rcv_nxt++;
        !          1106:                }
        !          1107:                switch (tp->t_state) {
        !          1108: 
        !          1109:                /*
        !          1110:                 * In SYN_RECEIVED and ESTABLISHED STATES
        !          1111:                 * enter the CLOSE_WAIT state.
        !          1112:                 */
        !          1113:                case TCPS_SYN_RECEIVED:
        !          1114:                case TCPS_ESTABLISHED:
        !          1115:                        tp->t_state = TCPS_CLOSE_WAIT;
        !          1116:                        break;
        !          1117: 
        !          1118:                /*
        !          1119:                 * If still in FIN_WAIT_1 STATE FIN has not been acked so
        !          1120:                 * enter the CLOSING state.
        !          1121:                 */
        !          1122:                case TCPS_FIN_WAIT_1:
        !          1123:                        tp->t_state = TCPS_CLOSING;
        !          1124:                        break;
        !          1125: 
        !          1126:                /*
        !          1127:                 * In FIN_WAIT_2 state enter the TIME_WAIT state,
        !          1128:                 * starting the time-wait timer, turning off the other 
        !          1129:                 * standard timers.
        !          1130:                 */
        !          1131:                case TCPS_FIN_WAIT_2:
        !          1132:                        tp->t_state = TCPS_TIME_WAIT;
        !          1133:                        tcp_canceltimers(tp);
        !          1134:                        tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
        !          1135:                        soisdisconnected(so);
        !          1136:                        break;
        !          1137: 
        !          1138:                /*
        !          1139:                 * In TIME_WAIT state restart the 2 MSL time_wait timer.
        !          1140:                 */
        !          1141:                case TCPS_TIME_WAIT:
        !          1142:                        tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
        !          1143:                        break;
        !          1144:                }
        !          1145:        }
        !          1146:        if (so->so_options & SO_DEBUG)
        !          1147:                tcp_trace(TA_INPUT, ostate, tp, &tcp_saveti, 0);
        !          1148: 
        !          1149:        /*
        !          1150:         * Return any desired output.
        !          1151:         */
        !          1152:        if (needoutput || (tp->t_flags & TF_ACKNOW))
        !          1153:                (void) tcp_output(tp);
        !          1154:        return;
        !          1155: 
        !          1156: dropafterack:
        !          1157:        /*
        !          1158:         * Generate an ACK dropping incoming segment if it occupies
        !          1159:         * sequence space, where the ACK reflects our state.
        !          1160:         */
        !          1161:        if (tiflags & TH_RST)
        !          1162:                goto drop;
        !          1163:        m_freem(m);
        !          1164:        tp->t_flags |= TF_ACKNOW;
        !          1165:        (void) tcp_output(tp);
        !          1166:        return;
        !          1167: 
        !          1168: dropwithreset:
        !          1169:        if (om) {
        !          1170:                (void) m_free(om);
        !          1171:                om = 0;
        !          1172:        }
        !          1173:        /*
        !          1174:         * Generate a RST, dropping incoming segment.
        !          1175:         * Make ACK acceptable to originator of segment.
        !          1176:         * Don't bother to respond if destination was broadcast.
        !          1177:         */
        !          1178:        if ((tiflags & TH_RST) || m->m_flags & M_BCAST)
        !          1179:                goto drop;
        !          1180:        if (tiflags & TH_ACK)
        !          1181:                tcp_respond(tp, ti, m, (tcp_seq)0, ti->ti_ack, TH_RST);
        !          1182:        else {
        !          1183:                if (tiflags & TH_SYN)
        !          1184:                        ti->ti_len++;
        !          1185:                tcp_respond(tp, ti, m, ti->ti_seq+ti->ti_len, (tcp_seq)0,
        !          1186:                    TH_RST|TH_ACK);
        !          1187:        }
        !          1188:        /* destroy temporarily created socket */
        !          1189:        if (dropsocket)
        !          1190:                (void) soabort(so);
        !          1191:        return;
        !          1192: 
        !          1193: drop:
        !          1194:        if (om)
        !          1195:                (void) m_free(om);
        !          1196:        /*
        !          1197:         * Drop space held by incoming segment and return.
        !          1198:         */
        !          1199:        if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
        !          1200:                tcp_trace(TA_DROP, ostate, tp, &tcp_saveti, 0);
        !          1201:        m_freem(m);
        !          1202:        /* destroy temporarily created socket */
        !          1203:        if (dropsocket)
        !          1204:                (void) soabort(so);
        !          1205:        return;
        !          1206: }
        !          1207: 
        !          1208: tcp_dooptions(tp, om, ti)
        !          1209:        struct tcpcb *tp;
        !          1210:        struct mbuf *om;
        !          1211:        struct tcpiphdr *ti;
        !          1212: {
        !          1213:        register u_char *cp;
        !          1214:        u_short mss;
        !          1215:        int opt, optlen, cnt;
        !          1216: 
        !          1217:        cp = mtod(om, u_char *);
        !          1218:        cnt = om->m_len;
        !          1219:        for (; cnt > 0; cnt -= optlen, cp += optlen) {
        !          1220:                opt = cp[0];
        !          1221:                if (opt == TCPOPT_EOL)
        !          1222:                        break;
        !          1223:                if (opt == TCPOPT_NOP)
        !          1224:                        optlen = 1;
        !          1225:                else {
        !          1226:                        optlen = cp[1];
        !          1227:                        if (optlen <= 0)
        !          1228:                                break;
        !          1229:                }
        !          1230:                switch (opt) {
        !          1231: 
        !          1232:                default:
        !          1233:                        continue;
        !          1234: 
        !          1235:                case TCPOPT_MAXSEG:
        !          1236:                        if (optlen != 4)
        !          1237:                                continue;
        !          1238:                        if (!(ti->ti_flags & TH_SYN))
        !          1239:                                continue;
        !          1240:                        bcopy((char *) cp + 2, (char *) &mss, sizeof(mss));
        !          1241:                        NTOHS(mss);
        !          1242:                        (void) tcp_mss(tp, mss);        /* sets t_maxseg */
        !          1243:                        break;
        !          1244:                }
        !          1245:        }
        !          1246:        (void) m_free(om);
        !          1247: }
        !          1248: 
        !          1249: /*
        !          1250:  * Pull out of band byte out of a segment so
        !          1251:  * it doesn't appear in the user's data queue.
        !          1252:  * It is still reflected in the segment length for
        !          1253:  * sequencing purposes.
        !          1254:  */
        !          1255: tcp_pulloutofband(so, ti, m)
        !          1256:        struct socket *so;
        !          1257:        struct tcpiphdr *ti;
        !          1258:        register struct mbuf *m;
        !          1259: {
        !          1260:        int cnt = ti->ti_urp - 1;
        !          1261:        
        !          1262:        while (cnt >= 0) {
        !          1263:                if (m->m_len > cnt) {
        !          1264:                        char *cp = mtod(m, caddr_t) + cnt;
        !          1265:                        struct tcpcb *tp = sototcpcb(so);
        !          1266: 
        !          1267:                        tp->t_iobc = *cp;
        !          1268:                        tp->t_oobflags |= TCPOOB_HAVEDATA;
        !          1269:                        bcopy(cp+1, cp, (unsigned)(m->m_len - cnt - 1));
        !          1270:                        m->m_len--;
        !          1271:                        return;
        !          1272:                }
        !          1273:                cnt -= m->m_len;
        !          1274:                m = m->m_next;
        !          1275:                if (m == 0)
        !          1276:                        break;
        !          1277:        }
        !          1278:        panic("tcp_pulloutofband");
        !          1279: }
        !          1280: 
        !          1281: /*
        !          1282:  * Collect new round-trip time estimate
        !          1283:  * and update averages and current timeout.
        !          1284:  */
        !          1285: tcp_xmit_timer(tp)
        !          1286:        register struct tcpcb *tp;
        !          1287: {
        !          1288:        register short delta;
        !          1289: 
        !          1290:        tcpstat.tcps_rttupdated++;
        !          1291:        if (tp->t_srtt != 0) {
        !          1292:                /*
        !          1293:                 * srtt is stored as fixed point with 3 bits after the
        !          1294:                 * binary point (i.e., scaled by 8).  The following magic
        !          1295:                 * is equivalent to the smoothing algorithm in rfc793 with
        !          1296:                 * an alpha of .875 (srtt = rtt/8 + srtt*7/8 in fixed
        !          1297:                 * point).  Adjust t_rtt to origin 0.
        !          1298:                 */
        !          1299:                delta = tp->t_rtt - 1 - (tp->t_srtt >> TCP_RTT_SHIFT);
        !          1300:                if ((tp->t_srtt += delta) <= 0)
        !          1301:                        tp->t_srtt = 1;
        !          1302:                /*
        !          1303:                 * We accumulate a smoothed rtt variance (actually, a
        !          1304:                 * smoothed mean difference), then set the retransmit
        !          1305:                 * timer to smoothed rtt + 4 times the smoothed variance.
        !          1306:                 * rttvar is stored as fixed point with 2 bits after the
        !          1307:                 * binary point (scaled by 4).  The following is
        !          1308:                 * equivalent to rfc793 smoothing with an alpha of .75
        !          1309:                 * (rttvar = rttvar*3/4 + |delta| / 4).  This replaces
        !          1310:                 * rfc793's wired-in beta.
        !          1311:                 */
        !          1312:                if (delta < 0)
        !          1313:                        delta = -delta;
        !          1314:                delta -= (tp->t_rttvar >> TCP_RTTVAR_SHIFT);
        !          1315:                if ((tp->t_rttvar += delta) <= 0)
        !          1316:                        tp->t_rttvar = 1;
        !          1317:        } else {
        !          1318:                /* 
        !          1319:                 * No rtt measurement yet - use the unsmoothed rtt.
        !          1320:                 * Set the variance to half the rtt (so our first
        !          1321:                 * retransmit happens at 2*rtt)
        !          1322:                 */
        !          1323:                tp->t_srtt = tp->t_rtt << TCP_RTT_SHIFT;
        !          1324:                tp->t_rttvar = tp->t_rtt << (TCP_RTTVAR_SHIFT - 1);
        !          1325:        }
        !          1326:        tp->t_rtt = 0;
        !          1327:        tp->t_rxtshift = 0;
        !          1328: 
        !          1329:        /*
        !          1330:         * the retransmit should happen at rtt + 4 * rttvar.
        !          1331:         * Because of the way we do the smoothing, srtt and rttvar
        !          1332:         * will each average +1/2 tick of bias.  When we compute
        !          1333:         * the retransmit timer, we want 1/2 tick of rounding and
        !          1334:         * 1 extra tick because of +-1/2 tick uncertainty in the
        !          1335:         * firing of the timer.  The bias will give us exactly the
        !          1336:         * 1.5 tick we need.  But, because the bias is
        !          1337:         * statistical, we have to test that we don't drop below
        !          1338:         * the minimum feasible timer (which is 2 ticks).
        !          1339:         */
        !          1340:        TCPT_RANGESET(tp->t_rxtcur, TCP_REXMTVAL(tp),
        !          1341:            tp->t_rttmin, TCPTV_REXMTMAX);
        !          1342:        
        !          1343:        /*
        !          1344:         * We received an ack for a packet that wasn't retransmitted;
        !          1345:         * it is probably safe to discard any error indications we've
        !          1346:         * received recently.  This isn't quite right, but close enough
        !          1347:         * for now (a route might have failed after we sent a segment,
        !          1348:         * and the return path might not be symmetrical).
        !          1349:         */
        !          1350:        tp->t_softerror = 0;
        !          1351: }
        !          1352: 
        !          1353: /*
        !          1354:  * Determine a reasonable value for maxseg size.
        !          1355:  * If the route is known, check route for mtu.
        !          1356:  * If none, use an mss that can be handled on the outgoing
        !          1357:  * interface without forcing IP to fragment; if bigger than
        !          1358:  * an mbuf cluster (MCLBYTES), round down to nearest multiple of MCLBYTES
        !          1359:  * to utilize large mbufs.  If no route is found, route has no mtu,
        !          1360:  * or the destination isn't local, use a default, hopefully conservative
        !          1361:  * size (usually 512 or the default IP max size, but no more than the mtu
        !          1362:  * of the interface), as we can't discover anything about intervening
        !          1363:  * gateways or networks.  We also initialize the congestion/slow start
        !          1364:  * window to be a single segment if the destination isn't local.
        !          1365:  * While looking at the routing entry, we also initialize other path-dependent
        !          1366:  * parameters from pre-set or cached values in the routing entry.
        !          1367:  */
        !          1368: 
        !          1369: tcp_mss(tp, offer)
        !          1370:        register struct tcpcb *tp;
        !          1371:        u_short offer;
        !          1372: {
        !          1373:        struct route *ro;
        !          1374:        register struct rtentry *rt;
        !          1375:        struct ifnet *ifp;
        !          1376:        register int rtt, mss;
        !          1377:        u_long bufsize;
        !          1378:        struct inpcb *inp;
        !          1379:        struct socket *so;
        !          1380:        extern int tcp_mssdflt, tcp_rttdflt;
        !          1381: 
        !          1382:        inp = tp->t_inpcb;
        !          1383:        ro = &inp->inp_route;
        !          1384: 
        !          1385:        if ((rt = ro->ro_rt) == (struct rtentry *)0) {
        !          1386:                /* No route yet, so try to acquire one */
        !          1387:                if (inp->inp_faddr.s_addr != INADDR_ANY) {
        !          1388:                        ro->ro_dst.sa_family = AF_INET;
        !          1389:                        ro->ro_dst.sa_len = sizeof(ro->ro_dst);
        !          1390:                        ((struct sockaddr_in *) &ro->ro_dst)->sin_addr =
        !          1391:                                inp->inp_faddr;
        !          1392:                        rtalloc(ro);
        !          1393:                }
        !          1394:                if ((rt = ro->ro_rt) == (struct rtentry *)0)
        !          1395:                        return (tcp_mssdflt);
        !          1396:        }
        !          1397:        ifp = rt->rt_ifp;
        !          1398:        so = inp->inp_socket;
        !          1399: 
        !          1400: #ifdef RTV_MTU /* if route characteristics exist ... */
        !          1401:        /*
        !          1402:         * While we're here, check if there's an initial rtt
        !          1403:         * or rttvar.  Convert from the route-table units
        !          1404:         * to scaled multiples of the slow timeout timer.
        !          1405:         */
        !          1406:        if (tp->t_srtt == 0 && (rtt = rt->rt_rmx.rmx_rtt)) {
        !          1407:                if (rt->rt_rmx.rmx_locks & RTV_MTU)
        !          1408:                        tp->t_rttmin = rtt / (RTM_RTTUNIT / PR_SLOWHZ);
        !          1409:                tp->t_srtt = rtt / (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTT_SCALE));
        !          1410:                if (rt->rt_rmx.rmx_rttvar)
        !          1411:                        tp->t_rttvar = rt->rt_rmx.rmx_rttvar /
        !          1412:                            (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTTVAR_SCALE));
        !          1413:                else
        !          1414:                        /* default variation is +- 1 rtt */
        !          1415:                        tp->t_rttvar =
        !          1416:                            tp->t_srtt * TCP_RTTVAR_SCALE / TCP_RTT_SCALE;
        !          1417:                TCPT_RANGESET(tp->t_rxtcur,
        !          1418:                    ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1,
        !          1419:                    tp->t_rttmin, TCPTV_REXMTMAX);
        !          1420:        }
        !          1421:        /*
        !          1422:         * if there's an mtu associated with the route, use it
        !          1423:         */
        !          1424:        if (rt->rt_rmx.rmx_mtu)
        !          1425:                mss = rt->rt_rmx.rmx_mtu - sizeof(struct tcpiphdr);
        !          1426:        else
        !          1427: #endif /* RTV_MTU */
        !          1428:        {
        !          1429:                mss = ifp->if_mtu - sizeof(struct tcpiphdr);
        !          1430: #if    (MCLBYTES & (MCLBYTES - 1)) == 0
        !          1431:                if (mss > MCLBYTES)
        !          1432:                        mss &= ~(MCLBYTES-1);
        !          1433: #else
        !          1434:                if (mss > MCLBYTES)
        !          1435:                        mss = mss / MCLBYTES * MCLBYTES;
        !          1436: #endif
        !          1437:                if (!in_localaddr(inp->inp_faddr))
        !          1438:                        mss = min(mss, tcp_mssdflt);
        !          1439:        }
        !          1440:        /*
        !          1441:         * The current mss, t_maxseg, is initialized to the default value.
        !          1442:         * If we compute a smaller value, reduce the current mss.
        !          1443:         * If we compute a larger value, return it for use in sending
        !          1444:         * a max seg size option, but don't store it for use
        !          1445:         * unless we received an offer at least that large from peer.
        !          1446:         * However, do not accept offers under 32 bytes.
        !          1447:         */
        !          1448:        if (offer)
        !          1449:                mss = min(mss, offer);
        !          1450:        mss = max(mss, 32);             /* sanity */
        !          1451:        if (mss < tp->t_maxseg || offer != 0) {
        !          1452:                /*
        !          1453:                 * If there's a pipesize, change the socket buffer
        !          1454:                 * to that size.  Make the socket buffers an integral
        !          1455:                 * number of mss units; if the mss is larger than
        !          1456:                 * the socket buffer, decrease the mss.
        !          1457:                 */
        !          1458: #ifdef RTV_SPIPE
        !          1459:                if ((bufsize = rt->rt_rmx.rmx_sendpipe) == 0)
        !          1460: #endif
        !          1461:                        bufsize = so->so_snd.sb_hiwat;
        !          1462:                if (bufsize < mss)
        !          1463:                        mss = bufsize;
        !          1464:                else {
        !          1465:                        bufsize = min(bufsize, SB_MAX) / mss * mss;
        !          1466:                        (void) sbreserve(&so->so_snd, bufsize);
        !          1467:                }
        !          1468:                tp->t_maxseg = mss;
        !          1469: 
        !          1470: #ifdef RTV_RPIPE
        !          1471:                if ((bufsize = rt->rt_rmx.rmx_recvpipe) == 0)
        !          1472: #endif
        !          1473:                        bufsize = so->so_rcv.sb_hiwat;
        !          1474:                if (bufsize > mss) {
        !          1475:                        bufsize = min(bufsize, SB_MAX) / mss * mss;
        !          1476:                        (void) sbreserve(&so->so_rcv, bufsize);
        !          1477:                }
        !          1478:        }
        !          1479:        tp->snd_cwnd = mss;
        !          1480: 
        !          1481: #ifdef RTV_SSTHRESH
        !          1482:        if (rt->rt_rmx.rmx_ssthresh) {
        !          1483:                /*
        !          1484:                 * There's some sort of gateway or interface
        !          1485:                 * buffer limit on the path.  Use this to set
        !          1486:                 * the slow start threshhold, but set the
        !          1487:                 * threshold to no less than 2*mss.
        !          1488:                 */
        !          1489:                tp->snd_ssthresh = max(2 * mss, rt->rt_rmx.rmx_ssthresh);
        !          1490:        }
        !          1491: #endif /* RTV_MTU */
        !          1492:        return (mss);
        !          1493: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.