tcp_input.pc

无线自组织网络的一个协议仿真软件

            if (tcp_stat) 
                tcp_stat->tcps_rcvbyteafterwin += ti->ti_len;
            /*
             * If a new connection request is received
             * while in TIME_WAIT, drop the old connection
             * and start over if the sequence numbers
             * are above the previous ones.
             */
            if (tiflags & TH_SYN &&
                tp->t_state == TCPS_TIME_WAIT &&
                SEQ_GT(ti->ti_seq, tp->rcv_nxt)) {
                iss = tp->rcv_nxt + TCP_ISSINCR;
                tp = tcp_close(node, tp, tcp_stat);
                goto findpcb;
            }
            /*
             * If window is closed can only take segments at
             * window edge, and have to drop data and PUSH from
             * incoming segments.  Continue processing, but
             * remember to ack.  Otherwise, drop segment
             * and ack.
             */
            if (tp->rcv_wnd == 0 && ti->ti_seq == tp->rcv_nxt) {
                tp->t_flags |= TF_ACKNOW;
                if (tcp_stat)
                    tcp_stat->tcps_rcvwinprobe++;
            } else
                goto dropafterack;
        } else{
            if (tcp_stat) 
                tcp_stat->tcps_rcvbyteafterwin += todrop;
        }
        ti->ti_len -= todrop;
        tiflags &= ~(TH_PUSH|TH_FIN);
    }

    /*
     * If last ACK falls within this segment's sequence numbers,
     * record its timestamp.
     * NOTE that the test is modified according to the latest
     * proposal of the [e-mail] list (Braden 1993/04/26).
     */
    if ((topt.to_flag & TOF_TS) != 0 &&
        SEQ_LEQ(ti->ti_seq, tp->last_ack_sent)) {
        tp->ts_recent_age = tcp_now;
        tp->ts_recent = topt.to_tsval;
    }

    /*
     * If the RST bit is set examine the state:
     *    SYN_RECEIVED STATE:
     *  If passive open, return to LISTEN state.
     *  If active open, inform user that connection was refused.
     *    ESTABLISHED, FIN_WAIT_1, FIN_WAIT2, CLOSE_WAIT STATES:
     *  Inform user that connection was reset, and close tcb.
     *    CLOSING, LAST_ACK, TIME_WAIT STATES
     *  Close the tcb.
     */
    if (tiflags&TH_RST) switch (tp->t_state) {

    case TCPS_SYN_RECEIVED:
    case TCPS_ESTABLISHED:
    case TCPS_FIN_WAIT_1:
    case TCPS_FIN_WAIT_2:
    case TCPS_CLOSE_WAIT:
        tp->t_state = TCPS_CLOSED;
        if (tcp_stat)
            tcp_stat->tcps_drops++;
        tp = tcp_close(node, tp, tcp_stat);
        goto drop;

    case TCPS_CLOSING:
    case TCPS_LAST_ACK:
    case TCPS_TIME_WAIT:
        tp = tcp_close(node, tp, tcp_stat);
        goto drop;
    }

    /*
     * If a SYN is in the window, then this is an
     * error and we send an RST and drop the connection.
     */
    if (tiflags & TH_SYN) {
        tp = tcp_drop(node, tp, tcp_now, tcp_stat);
        goto dropwithreset;
    }

    /*
     * If the ACK bit is off:  if in SYN-RECEIVED state or SENDSYN
     * flag is on (half-synchronized state), then queue data for
     * later processing; else drop segment and return.
     */
    if ((tiflags & TH_ACK) == 0) {
        if (tp->t_state == TCPS_SYN_RECEIVED ||
            (tp->t_flags & TF_NEEDSYN))
            goto step6;
        else
            goto drop;
    }

    /*
     * Ack processing.
     */
    switch (tp->t_state) {

    /*
     * In SYN_RECEIVED state if the ack ACKs our SYN then enter
     * ESTABLISHED state and continue processing, otherwise
     * send an RST.
     */
    case TCPS_SYN_RECEIVED:
        if (SEQ_GT(tp->snd_una, ti->ti_ack) ||
            SEQ_GT(ti->ti_ack, tp->snd_max))
            goto dropwithreset;
        if (tcp_stat)
            tcp_stat->tcps_connects++;
        /* Do window scaling? */
        if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) ==
            (TF_RCVD_SCALE|TF_REQ_SCALE)) {
            tp->snd_scale = tp->requested_s_scale;
            tp->rcv_scale = tp->request_r_scale;
        }

        /*
         * Make transitions:
         *      SYN-RECEIVED  -> ESTABLISHED
         *      SYN-RECEIVED* -> FIN-WAIT-1
         */
        if (tp->t_flags & TF_NEEDFIN) {
            tp->t_state = TCPS_FIN_WAIT_1;
            tp->t_flags &= ~TF_NEEDFIN;
        } else {
            Message *msg;
            TransportToAppOpenResult *tcpOpenResult;

            if (inp->usrreq == INPCB_USRREQ_OPEN)
                flag = TCP_CONN_ACTIVE_OPEN; 
            else flag = TCP_CONN_PASSIVE_OPEN;   

            msg = GLOMO_MsgAlloc(node, GLOMO_APP_LAYER,
                                 inp->app_proto_type, 
                                 MSG_APP_FromTransOpenResult);
            GLOMO_MsgInfoAlloc(node, msg, sizeof(TransportToAppOpenResult));
            tcpOpenResult = (TransportToAppOpenResult *) msg->info;
            tcpOpenResult->type = flag;
            tcpOpenResult->localAddr = inp->inp_local_addr;
            tcpOpenResult->localPort = inp->inp_local_port;
            tcpOpenResult->remoteAddr = inp->inp_remote_addr;
            tcpOpenResult->remotePort = inp->inp_remote_port;
            tcpOpenResult->connectionId = inp->con_id;

            tcpOpenResult->uniqueId = inp->unique_id;

            GLOMO_MsgSend(node, msg, TRANSPORT_DELAY);

            inp->usrreq = INPCB_USRREQ_CONNECTED;
            tp->t_state = TCPS_ESTABLISHED;
            tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_IDLE;
        }
        /*
         * If segment contains data or ACK, will call tcp_reass()
         * later; if not, do so now to pass queued data to user.
         */
        if (ti->ti_len == 0 && (tiflags & TH_FIN) == 0)
            (void) tcp_reass(node, tp, (struct tcpiphdr *)0,
                             tcp_stat);
        tp->snd_wl1 = ti->ti_seq - 1;
        /* fall into ... */

    /*
     * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
     * ACKs.  If the ack is in the range
     *  tp->snd_una < ti->ti_ack <= tp->snd_max
     * then advance tp->snd_una to ti->ti_ack and drop
     * data from the retransmission queue.  If this ACK reflects
     * more up to date window information we update our window information.
     */
    case TCPS_ESTABLISHED:
    case TCPS_FIN_WAIT_1:
    case TCPS_FIN_WAIT_2:
    case TCPS_CLOSE_WAIT:
    case TCPS_CLOSING:
    case TCPS_LAST_ACK:
    case TCPS_TIME_WAIT:

        if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {
            if (ti->ti_len == 0 && tiwin == tp->snd_wnd) {
                if (tcp_stat) {
                    if (!(ti->ti_flags & (TH_FIN|TH_SYN|TH_RST))) 
                        tcp_stat->tcps_rcvdupack++;
                }
                /*
                 * If we have outstanding data (other than
                 * a window probe), this is a completely
                 * duplicate ack (ie, window info didn't
                 * change), the ack is the biggest we've
                 * seen and we've seen exactly our rexmt
                 * threshhold of them, assume a packet
                 * has been dropped and retransmit it.
                 * Kludge snd_nxt & the congestion
                 * window so we send only this one
                 * packet.
                 *
                 * We know we're losing at the current
                 * window size so do congestion avoidance
                 * (set ssthresh to half the current window
                 * and pull our congestion window back to
                 * the new ssthresh).
                 *
                 * Dup acks mean that packets have left the
                 * network (they're now cached at the receiver)
                 * so bump cwnd by the amount in the receiver
                 * to keep a constant cwnd packets in the
                 * network.
                 */
                if (tp->t_timer[TCPT_REXMT] == 0 ||
                    ti->ti_ack != tp->snd_una)
                    tp->t_dupacks = 0;
                else if (++tp->t_dupacks == tcprexmtthresh) {
                    tcp_seq onxt = tp->snd_nxt;
                    unsigned int win =
                        MIN(tp->snd_wnd, tp->snd_cwnd) / 2 /
                        tp->t_maxseg;

                    if (win < 2)
                        win = 2;
                    tp->snd_ssthresh = win * tp->t_maxseg;
                    tp->t_timer[TCPT_REXMT] = 0;
                    tp->t_rtt = 0;
                    tp->snd_nxt = ti->ti_ack;
                    tp->snd_cwnd = tp->t_maxseg;
                    tcp_output(node, tp, tcp_now, tcp_stat);
                    tp->snd_cwnd = tp->snd_ssthresh +
                                   tp->t_maxseg * tp->t_dupacks;

                    if (SEQ_GT(onxt, tp->snd_nxt))
                        tp->snd_nxt = onxt;
                    goto drop;
                } else if (tp->t_dupacks > tcprexmtthresh) {
                    tp->snd_cwnd += tp->t_maxseg;
                    tcp_output(node, tp, tcp_now, tcp_stat);
                    goto drop;
                }
            } else
                tp->t_dupacks = 0;
            break;
        }
        /*
         * If the congestion window was inflated to account
         * for the other side's cached packets, retract it.
         */
        if (tp->t_dupacks >= tcprexmtthresh &&
            tp->snd_cwnd > tp->snd_ssthresh){
            tp->snd_cwnd = tp->snd_ssthresh;
        }

        tp->t_dupacks = 0;
        if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
            if (tcp_stat) 
                tcp_stat->tcps_rcvacktoomuch++;
            goto dropafterack;
        }

process_ACK:
        acked = ti->ti_ack - tp->snd_una;
        if (tcp_stat) { 
            if ((tlen == 0)&&(!(ti->ti_flags & (TH_SYN|TH_RST|TH_FIN)))) 
                tcp_stat->tcps_rcvackpack++;
            tcp_stat->tcps_rcvackbyte += acked;
         } 

        /*
         * If we have a timestamp reply, update smoothed
         * round trip time.  If no timestamp is present but
         * transmit timer is running and timed sequence
         * number was acked, update smoothed round trip time.
         * Since we now have an rtt measurement, cancel the
         * timer backoff (cf., Phil Karn's retransmit alg.).
         * Recompute the initial retransmit timer.
         */
        if (topt.to_flag & TOF_TS)
            tcp_xmit_timer(tp, tcp_now - topt.to_tsecr + 1, tcp_stat);
        else if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq))
            tcp_xmit_timer(tp,tp->t_rtt, tcp_stat);

        /*
         * If all outstanding data is acked, stop retransmit
         * timer and remember to restart (more output or persist).
         * If there is more data to be acked, restart retransmit
         * timer, using current (possibly backed-off) value.
         */
        if (ti->ti_ack == tp->snd_max) {
            tp->t_timer[TCPT_REXMT] = 0;
            needoutput = 1;
        } else if (tp->t_timer[TCPT_PERSIST] == 0)
            tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;

        /*
         * If no data (only SYN) was ACK'd,
         *    skip rest of ACK processing.
         */
        if (acked == 0)
            goto step6;

        /*
         * When new data is acked, open the congestion window.
         * If the window gives us less than ssthresh packets
         * in flight, open exponentially (maxseg per packet).
         * Otherwise open linearly: maxseg per window
         * (maxseg^2 / cwnd per packet).
         */
        {
            unsigned int cw = tp->snd_cwnd;
            unsigned int incr = tp->t_maxseg;

            if (cw > tp->snd_ssthresh)
                incr = incr * incr / cw;
            tp->snd_cwnd = MIN(cw + incr, TCP_MAXWIN<<tp->snd_scale);

        }
        if (acked > inp->inp_snd.cc) {
            tp->snd_wnd -= inp->inp_snd.cc;
            del_buf(node, inp, (int)inp->inp_snd.cc);
            ourfinisacked = 1;
        } else {
            tp->snd_wnd -= acked;
            del_buf(node, inp, acked);
            ourfinisacked = 0;
        }

        tp->snd_una = ti->ti_ack;
        if (SEQ_LT(tp->snd_nxt, tp->snd_una))
            tp->snd_nxt = tp->snd_una;

        switch (tp->t_state) {

        /*
         * In FIN_WAIT_1 STATE in addition to the processing
         * for the ESTABLISHED state if our FIN is now acknowledged
         * then enter FIN_WAIT_2.
         */
        case TCPS_FIN_WAIT_1:
            if (ourfinisacked) {
                /*
                 * If we can't receive any more
                 * data, then closing user can proceed.
                 * Starting the timer is contrary to the
                 * specification, but if we don't get a FIN
                 * we'll hang forever.
                 */
                tp->t_state = TCPS_FIN_WAIT_2;
            }
            break;

        /*
         * In CLOSING STATE in addition to the processing for
         * the ESTABLISHED state if the ACK acknowledges our FIN
         * then enter the TIME-WAIT state, otherwise ignore
         * the segment.
         */
        case TCPS_CLOSING:
            if (ourfinisacked) {
                tp->t_state = TCPS_TIME_WAIT;
                tcp_canceltimers(tp);
                tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
            }
            break;

        /*
         * In LAST_ACK, we may still be waiting for data to drain
         * and/or to be acked, as well as for the ack of our FIN.
         * If our FIN is now acknowledged, delete the TCB,
         * enter the closed state and return.
         */
        case TCPS_LAST_ACK:
            if (ourfinisacked) {
                tp = tcp_close(node, tp, tcp_stat);
                goto drop;
            }
            break;

        /*
         * In TIME_WAIT state the only thing that should arrive
         * is a retransmission of the remote FIN.  Acknowledge
         * it and restart the finack timer.
         */
        case TCPS_TIME_WAIT:
            tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
            goto dropafterack;
        }
    }

step6:
    /*
     * Update window information.
     * Don't look at window if no ACK: TAC's send garbage on first SYN.
     */
    if ((tiflags & TH_ACK) &&
        (SEQ_LT(tp->snd_wl1, ti->ti_seq) ||
        (tp->snd_wl1 == ti->ti_seq && (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||
         (tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd))))) {
        /* keep track of pure window updates */
        if (tcp_stat) { 
            if (ti->ti_len == 0 &&
                tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd)
                tcp_stat->tcps_rcvwinupd++;
        }
        tp->snd_wnd = tiwin;
        tp->snd_wl1 = ti->ti_seq;
        tp->snd_wl2 = ti->ti_ack;
        if (tp->snd_wnd > tp->max_sndwnd)
            tp->max_sndwnd = tp->snd_wnd;
        needoutput = 1;
    }
    /*
     * Pull receive urgent pointer along
     * with the receive window.
     */
    if (SEQ_GT(tp->rcv_nxt, tp->rcv_up))
        tp->rcv_up = tp->rcv_nxt;

    /*
     * Process the segment text, merging it into the TCP sequencing queue,
     * and arranging for acknowledgment of receipt if necessary.
     * This process logically involves adjusting tp->rcv_wnd as data
     * is presented to the user (this happens in tcp_usrreq.c,
     * case PRU_RCVD).  If a FIN has already been received on this
     * connection then we just ignore the text.
     */
    if ((ti->ti_len || (tiflags&TH_FIN)) &&
        TCPS_HAVERCVDFIN(tp->t_state) == 0) {
        if (TCP_ACK_HACK) {
            if (ti->ti_seq == tp->rcv_nxt && 
                tp->seg_next == (struct tcpiphdr *)tp && 
                tp->t_state == TCPS_ESTABLISHED) { 
                if (ti->ti_flags & TH_PUSH) 
                    tp->t_flags |= TF_ACKNOW; 
                else