1 files changed, 91 insertions, 73 deletions

diff --git a/net/dccp/input.c b/net/dccp/input.c
index df0e6714aa11..779d0ed9ae94 100644
--- a/net/dccp/input.c
+++ b/net/dccp/input.c
@@ -159,15 +159,13 @@ static void dccp_rcv_reset(struct sock *sk, struct sk_buff *skb)
         dccp_time_wait(sk, DCCP_TIME_WAIT, 0);
 }
 
-static void dccp_handle_ackvec_processing(struct sock *sk, struct sk_buff *skb)
+static void dccp_event_ack_recv(struct sock *sk, struct sk_buff *skb)
 {
-        struct dccp_ackvec *av = dccp_sk(sk)->dccps_hc_rx_ackvec;
+        struct dccp_sock *dp = dccp_sk(sk);
 
-        if (av == NULL)
-                return;
-        if (DCCP_SKB_CB(skb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
-                dccp_ackvec_clear_state(av, DCCP_SKB_CB(skb)->dccpd_ack_seq);
-        dccp_ackvec_input(av, skb);
+        if (dccp_msk(sk)->dccpms_send_ack_vector)
+                dccp_ackvec_check_rcv_ackno(dp->dccps_hc_rx_ackvec, sk,
+                                            DCCP_SKB_CB(skb)->dccpd_ack_seq);
 }
 
 static void dccp_deliver_input_to_ccids(struct sock *sk, struct sk_buff *skb)
@@ -366,13 +364,22 @@ discard:
 int dccp_rcv_established(struct sock *sk, struct sk_buff *skb,
                          const struct dccp_hdr *dh, const unsigned len)
 {
+        struct dccp_sock *dp = dccp_sk(sk);
+
         if (dccp_check_seqno(sk, skb))
                 goto discard;
 
         if (dccp_parse_options(sk, NULL, skb))
                 return 1;
 
-        dccp_handle_ackvec_processing(sk, skb);
+        if (DCCP_SKB_CB(skb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
+                dccp_event_ack_recv(sk, skb);
+
+        if (dccp_msk(sk)->dccpms_send_ack_vector &&
+            dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
+                            DCCP_SKB_CB(skb)->dccpd_seq,
+                            DCCP_ACKVEC_STATE_RECEIVED))
+                goto discard;
         dccp_deliver_input_to_ccids(sk, skb);
 
         return __dccp_rcv_established(sk, skb, dh, len);
@@ -414,33 +421,40 @@ static int dccp_rcv_request_sent_state_process(struct sock *sk,
                         goto out_invalid_packet;
                 }
 
-                /*
-                 * If option processing (Step 8) failed, return 1 here so that
-                 * dccp_v4_do_rcv() sends a Reset. The Reset code depends on
-                 * the option type and is set in dccp_parse_options().
-                 */
                 if (dccp_parse_options(sk, NULL, skb))
-                        return 1;
+                        goto out_invalid_packet;
 
                 /* Obtain usec RTT sample from SYN exchange (used by CCID 3) */
                 if (likely(dp->dccps_options_received.dccpor_timestamp_echo))
                         dp->dccps_syn_rtt = dccp_sample_rtt(sk, 10 * (tstamp -
                             dp->dccps_options_received.dccpor_timestamp_echo));
 
+                if (dccp_msk(sk)->dccpms_send_ack_vector &&
+                    dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
+                                    DCCP_SKB_CB(skb)->dccpd_seq,
+                                    DCCP_ACKVEC_STATE_RECEIVED))
+                        goto out_invalid_packet; /* FIXME: change error code */
+
                 /* Stop the REQUEST timer */
                 inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
                 WARN_ON(sk->sk_send_head == NULL);
                 kfree_skb(sk->sk_send_head);
                 sk->sk_send_head = NULL;
 
+                dp->dccps_isr = DCCP_SKB_CB(skb)->dccpd_seq;
+                dccp_update_gsr(sk, dp->dccps_isr);
                 /*
-                 * Set ISR, GSR from packet. ISS was set in dccp_v{4,6}_connect
-                 * and GSS in dccp_transmit_skb(). Setting AWL/AWH and SWL/SWH
-                 * is done as part of activating the feature values below, since
-                 * these settings depend on the local/remote Sequence Window
-                 * features, which were undefined or not confirmed until now.
+                 * SWL and AWL are initially adjusted so that they are not less than
+                 * the initial Sequence Numbers received and sent, respectively:
+                 *      SWL := max(GSR + 1 - floor(W/4), ISR),
+                 *      AWL := max(GSS - W' + 1, ISS).
+                 * These adjustments MUST be applied only at the beginning of the
+                 * connection.
+                 *
+                 * AWL was adjusted in dccp_v4_connect -acme
                  */
-                dp->dccps_gsr = dp->dccps_isr = DCCP_SKB_CB(skb)->dccpd_seq;
+                dccp_set_seqno(&dp->dccps_swl,
+                               max48(dp->dccps_swl, dp->dccps_isr));
 
                 dccp_sync_mss(sk, icsk->icsk_pmtu_cookie);
 
@@ -461,15 +475,6 @@ static int dccp_rcv_request_sent_state_process(struct sock *sk,
                  */
                 dccp_set_state(sk, DCCP_PARTOPEN);
 
-                /*
-                 * If feature negotiation was successful, activate features now;
-                 * an activation failure means that this host could not activate
-                 * one ore more features (e.g. insufficient memory), which would
-                 * leave at least one feature in an undefined state.
-                 */
-                if (dccp_feat_activate_values(sk, &dp->dccps_featneg))
-                        goto unable_to_proceed;
-
                 /* Make sure socket is routed, for correct metrics. */
                 icsk->icsk_af_ops->rebuild_header(sk);
 
@@ -504,16 +509,6 @@ out_invalid_packet:
         /* dccp_v4_do_rcv will send a reset */
         DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_PACKET_ERROR;
         return 1;
-
-unable_to_proceed:
-        DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_ABORTED;
-        /*
-         * We mark this socket as no longer usable, so that the loop in
-         * dccp_sendmsg() terminates and the application gets notified.
-         */
-        dccp_set_state(sk, DCCP_CLOSED);
-        sk->sk_err = ECOMM;
-        return 1;
 }
 
 static int dccp_rcv_respond_partopen_state_process(struct sock *sk,
@@ -595,6 +590,8 @@ int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
                         if (inet_csk(sk)->icsk_af_ops->conn_request(sk,
                                                                     skb) < 0)
                                 return 1;
+
+                        /* FIXME: do congestion control initialization */
                         goto discard;
                 }
                 if (dh->dccph_type == DCCP_PKT_RESET)
@@ -603,35 +600,29 @@ int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
                 /* Caller (dccp_v4_do_rcv) will send Reset */
                 dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
                 return 1;
-        } else if (sk->sk_state == DCCP_CLOSED) {
-                dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
-                return 1;
         }
 
-        /* Step 6: Check sequence numbers (omitted in LISTEN/REQUEST state) */
-        if (sk->sk_state != DCCP_REQUESTING && dccp_check_seqno(sk, skb))
-                goto discard;
+        if (sk->sk_state != DCCP_REQUESTING) {
+                if (dccp_check_seqno(sk, skb))
+                        goto discard;
 
-        /*
-         *   Step 7: Check for unexpected packet types
-         *      If (S.is_server and P.type == Response)
-         *          or (S.is_client and P.type == Request)
-         *          or (S.state == RESPOND and P.type == Data),
-         *        Send Sync packet acknowledging P.seqno
-         *        Drop packet and return
-         */
-        if ((dp->dccps_role != DCCP_ROLE_CLIENT &&
-             dh->dccph_type == DCCP_PKT_RESPONSE) ||
-            (dp->dccps_role == DCCP_ROLE_CLIENT &&
-             dh->dccph_type == DCCP_PKT_REQUEST) ||
-            (sk->sk_state == DCCP_RESPOND && dh->dccph_type == DCCP_PKT_DATA)) {
-                dccp_send_sync(sk, dcb->dccpd_seq, DCCP_PKT_SYNC);
-                goto discard;
-        }
+                /*
+                 * Step 8: Process options and mark acknowledgeable
+                 */
+                if (dccp_parse_options(sk, NULL, skb))
+                        return 1;
 
-        /*  Step 8: Process options */
-        if (dccp_parse_options(sk, NULL, skb))
-                return 1;
+                if (dcb->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
+                        dccp_event_ack_recv(sk, skb);
+
+                if (dccp_msk(sk)->dccpms_send_ack_vector &&
+                    dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
+                                    DCCP_SKB_CB(skb)->dccpd_seq,
+                                    DCCP_ACKVEC_STATE_RECEIVED))
+                        goto discard;
+
+                dccp_deliver_input_to_ccids(sk, skb);
+        }
 
         /*
          *  Step 9: Process Reset
@@ -640,22 +631,44 @@ int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
          *              S.state := TIMEWAIT
          *              Set TIMEWAIT timer
          *              Drop packet and return
-         */
+        */
         if (dh->dccph_type == DCCP_PKT_RESET) {
                 dccp_rcv_reset(sk, skb);
                 return 0;
-        } else if (dh->dccph_type == DCCP_PKT_CLOSEREQ) {       /* Step 13 */
+                /*
+                 *   Step 7: Check for unexpected packet types
+                 *      If (S.is_server and P.type == Response)
+                 *          or (S.is_client and P.type == Request)
+                 *          or (S.state == RESPOND and P.type == Data),
+                 *        Send Sync packet acknowledging P.seqno
+                 *        Drop packet and return
+                 */
+        } else if ((dp->dccps_role != DCCP_ROLE_CLIENT &&
+                    dh->dccph_type == DCCP_PKT_RESPONSE) ||
+                    (dp->dccps_role == DCCP_ROLE_CLIENT &&
+                     dh->dccph_type == DCCP_PKT_REQUEST) ||
+                    (sk->sk_state == DCCP_RESPOND &&
+                     dh->dccph_type == DCCP_PKT_DATA)) {
+                dccp_send_sync(sk, dcb->dccpd_seq, DCCP_PKT_SYNC);
+                goto discard;
+        } else if (dh->dccph_type == DCCP_PKT_CLOSEREQ) {
                 if (dccp_rcv_closereq(sk, skb))
                         return 0;
                 goto discard;
-        } else if (dh->dccph_type == DCCP_PKT_CLOSE) {          /* Step 14 */
+        } else if (dh->dccph_type == DCCP_PKT_CLOSE) {
                 if (dccp_rcv_close(sk, skb))
                         return 0;
                 goto discard;
         }
 
         switch (sk->sk_state) {
+        case DCCP_CLOSED:
+                dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
+                return 1;
+
         case DCCP_REQUESTING:
+                /* FIXME: do congestion control initialization */
+
                 queued = dccp_rcv_request_sent_state_process(sk, skb, dh, len);
                 if (queued >= 0)
                         return queued;
@@ -663,12 +676,8 @@ int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
                 __kfree_skb(skb);
                 return 0;
 
-        case DCCP_PARTOPEN:
-                /* Step 8: if using Ack Vectors, mark packet acknowledgeable */
-                dccp_handle_ackvec_processing(sk, skb);
-                dccp_deliver_input_to_ccids(sk, skb);
-                /* fall through */
         case DCCP_RESPOND:
+        case DCCP_PARTOPEN:
                 queued = dccp_rcv_respond_partopen_state_process(sk, skb,
                                                                  dh, len);
                 break;
@@ -707,7 +716,16 @@ u32 dccp_sample_rtt(struct sock *sk, long delta)
         /* dccpor_elapsed_time is either zeroed out or set and > 0 */
         delta -= dccp_sk(sk)->dccps_options_received.dccpor_elapsed_time * 10;
 
-        return dccp_sane_rtt(delta);
+        if (unlikely(delta <= 0)) {
+                DCCP_WARN("unusable RTT sample %ld, using min\n", delta);
+                return DCCP_SANE_RTT_MIN;
+        }
+        if (unlikely(delta > DCCP_SANE_RTT_MAX)) {
+                DCCP_WARN("RTT sample %ld too large, using max\n", delta);
+                return DCCP_SANE_RTT_MAX;
+        }
+
+        return delta;
 }
 
 EXPORT_SYMBOL_GPL(dccp_sample_rtt);