[DCCP]: Move the ack vector code to net/dccp/ackvec.[ch]

Isolating it, that will be used when we introduce a CCID2 (TCP-Like)
implementation.

Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

10 files changed, 612 insertions, 631 deletions

diff --git a/include/linux/dccp.h b/include/linux/dccp.h
index 0e72708677e4..8c8e029095a5 100644
--- a/include/linux/dccp.h
+++ b/include/linux/dccp.h
@@ -353,14 +353,8 @@ static inline struct dccp_request_sock *dccp_rsk(const struct request_sock *req)
 
 extern struct inet_timewait_death_row dccp_death_row;
 
-/* Read about the ECN nonce to see why it is 253 */
-#define DCCP_MAX_ACK_VECTOR_LEN 253
-
 struct dccp_options_received {
-        u32     dccpor_ndp:24,
-                dccpor_ack_vector_len:8;
-        u32     dccpor_ack_vector_idx:10;
-        /* 22 bits hole, try to pack */
+        u32     dccpor_ndp; /* only 24 bits */
         u32     dccpor_timestamp;
         u32     dccpor_timestamp_echo;
         u32     dccpor_elapsed_time;
@@ -394,6 +388,8 @@ static inline int dccp_list_has_service(const struct dccp_service_list *sl,
         return 0;
 }
 
+struct dccp_ackvec;
+
 /**
  * struct dccp_sock - DCCP socket state
  *
@@ -414,7 +410,7 @@ static inline int dccp_list_has_service(const struct dccp_service_list *sl,
  * @dccps_packet_size - Set thru setsockopt
  * @dccps_role - Role of this sock, one of %dccp_role
  * @dccps_ndp_count - number of Non Data Packets since last data packet
- * @dccps_hc_rx_ackpkts - receiver half connection acked packets
+ * @dccps_hc_rx_ackvec - rx half connection ack vector
  */
 struct dccp_sock {
         /* inet_connection_sock has to be the first member of dccp_sock */
@@ -439,7 +435,7 @@ struct dccp_sock {
         __u32                           dccps_pmtu_cookie;
         __u32                           dccps_mss_cache;
         struct dccp_options             dccps_options;
-        struct dccp_ackpkts             *dccps_hc_rx_ackpkts;
+        struct dccp_ackvec              *dccps_hc_rx_ackvec;
         void                            *dccps_hc_rx_ccid_private;
         void                            *dccps_hc_tx_ccid_private;
         struct ccid                     *dccps_hc_rx_ccid;
diff --git a/net/dccp/Makefile b/net/dccp/Makefile
index fb97bb042455..344a8da153fc 100644
--- a/net/dccp/Makefile
+++ b/net/dccp/Makefile
@@ -3,6 +3,8 @@ obj-$(CONFIG_IP_DCCP) += dccp.o
 dccp-y := ccid.o input.o ipv4.o minisocks.o options.o output.o proto.o \
           timer.o
 
+dccp-$(CONFIG_IP_DCCP_ACKVEC) += ackvec.o
+
 obj-$(CONFIG_INET_DCCP_DIAG) += dccp_diag.o
 
 dccp_diag-y := diag.o
diff --git a/net/dccp/ackvec.c b/net/dccp/ackvec.c
new file mode 100644
index 000000000000..6530283eafca
--- /dev/null
+++ b/net/dccp/ackvec.c
@@ -0,0 +1,419 @@
+/*
+ *  net/dccp/ackvec.c
+ *
+ *  An implementation of the DCCP protocol
+ *  Copyright (c) 2005 Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
+ *
+ *      This program is free software; you can redistribute it and/or modify it
+ *      under the terms of the GNU General Public License as published by the
+ *      Free Software Foundation; version 2 of the License;
+ */
+
+#include "ackvec.h"
+#include "dccp.h"
+
+#include <linux/dccp.h>
+#include <linux/skbuff.h>
+
+#include <net/sock.h>
+
+int dccp_insert_option_ackvec(struct sock *sk, struct sk_buff *skb)
+{
+        struct dccp_sock *dp = dccp_sk(sk);
+        struct dccp_ackvec *av = dp->dccps_hc_rx_ackvec;
+        int len = av->dccpav_vec_len + 2;
+        struct timeval now;
+        u32 elapsed_time;
+        unsigned char *to, *from;
+
+        dccp_timestamp(sk, &now);
+        elapsed_time = timeval_delta(&now, &av->dccpav_time) / 10;
+
+        if (elapsed_time != 0)
+                dccp_insert_option_elapsed_time(sk, skb, elapsed_time);
+
+        if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN)
+                return -1;
+
+        /*
+         * XXX: now we have just one ack vector sent record, so
+         * we have to wait for it to be cleared.
+         *
+         * Of course this is not acceptable, but this is just for
+         * basic testing now.
+         */
+        if (av->dccpav_ack_seqno != DCCP_MAX_SEQNO + 1)
+                return -1;
+
+        DCCP_SKB_CB(skb)->dccpd_opt_len += len;
+
+        to    = skb_push(skb, len);
+        *to++ = DCCPO_ACK_VECTOR_0;
+        *to++ = len;
+
+        len  = av->dccpav_vec_len;
+        from = av->dccpav_buf + av->dccpav_buf_head;
+
+        /* Check if buf_head wraps */
+        if (av->dccpav_buf_head + len > av->dccpav_vec_len) {
+                const u32 tailsize = (av->dccpav_vec_len - av->dccpav_buf_head);
+
+                memcpy(to, from, tailsize);
+                to   += tailsize;
+                len  -= tailsize;
+                from = av->dccpav_buf;
+        }
+
+        memcpy(to, from, len);
+        /*
+         *      From draft-ietf-dccp-spec-11.txt:
+         *
+         *      For each acknowledgement it sends, the HC-Receiver will add an
+         *      acknowledgement record.  ack_seqno will equal the HC-Receiver
+         *      sequence number it used for the ack packet; ack_ptr will equal
+         *      buf_head; ack_ackno will equal buf_ackno; and ack_nonce will
+         *      equal buf_nonce.
+         *
+         * This implemention uses just one ack record for now.
+         */
+        av->dccpav_ack_seqno = DCCP_SKB_CB(skb)->dccpd_seq;
+        av->dccpav_ack_ptr   = av->dccpav_buf_head;
+        av->dccpav_ack_ackno = av->dccpav_buf_ackno;
+        av->dccpav_ack_nonce = av->dccpav_buf_nonce;
+        av->dccpav_sent_len  = av->dccpav_vec_len;
+
+        dccp_pr_debug("%sACK Vector 0, len=%d, ack_seqno=%llu, "
+                      "ack_ackno=%llu\n",
+                      debug_prefix, av->dccpav_sent_len,
+                      (unsigned long long)av->dccpav_ack_seqno,
+                      (unsigned long long)av->dccpav_ack_ackno);
+        return -1;
+}
+
+struct dccp_ackvec *dccp_ackvec_alloc(const unsigned int len,
+                                      const unsigned int __nocast priority)
+{
+        struct dccp_ackvec *av = kmalloc(sizeof(*av) + len, priority);
+
+        if (av != NULL) {
+                av->dccpav_buf_len      = len;
+                av->dccpav_buf_head     =
+                        av->dccpav_buf_tail = av->dccpav_buf_len - 1;
+                av->dccpav_buf_ackno    =
+                        av->dccpav_ack_ackno = av->dccpav_ack_seqno = ~0LLU;
+                av->dccpav_buf_nonce = av->dccpav_buf_nonce = 0;
+                av->dccpav_ack_ptr      = 0;
+                av->dccpav_time.tv_sec  = 0;
+                av->dccpav_time.tv_usec = 0;
+                av->dccpav_sent_len     = av->dccpav_vec_len = 0;
+        }
+
+        return av;
+}
+
+void dccp_ackvec_free(struct dccp_ackvec *av)
+{
+        kfree(av);
+}
+
+static inline u8 dccp_ackvec_state(const struct dccp_ackvec *av,
+                                   const unsigned int index)
+{
+        return av->dccpav_buf[index] & DCCP_ACKVEC_STATE_MASK;
+}
+
+static inline u8 dccp_ackvec_len(const struct dccp_ackvec *av,
+                                 const unsigned int index)
+{
+        return av->dccpav_buf[index] & DCCP_ACKVEC_LEN_MASK;
+}
+
+/*
+ * If several packets are missing, the HC-Receiver may prefer to enter multiple
+ * bytes with run length 0, rather than a single byte with a larger run length;
+ * this simplifies table updates if one of the missing packets arrives.
+ */
+static inline int dccp_ackvec_set_buf_head_state(struct dccp_ackvec *av,
+                                                 const unsigned int packets,
+                                                  const unsigned char state)
+{
+        unsigned int gap;
+        signed long new_head;
+
+        if (av->dccpav_vec_len + packets > av->dccpav_buf_len)
+                return -ENOBUFS;
+
+        gap      = packets - 1;
+        new_head = av->dccpav_buf_head - packets;
+
+        if (new_head < 0) {
+                if (gap > 0) {
+                        memset(av->dccpav_buf, DCCP_ACKVEC_STATE_NOT_RECEIVED,
+                               gap + new_head + 1);
+                        gap = -new_head;
+                }
+                new_head += av->dccpav_buf_len;
+        } 
+
+        av->dccpav_buf_head = new_head;
+
+        if (gap > 0)
+                memset(av->dccpav_buf + av->dccpav_buf_head + 1,
+                       DCCP_ACKVEC_STATE_NOT_RECEIVED, gap);
+
+        av->dccpav_buf[av->dccpav_buf_head] = state;
+        av->dccpav_vec_len += packets;
+        return 0;
+}
+
+/*
+ * Implements the draft-ietf-dccp-spec-11.txt Appendix A
+ */
+int dccp_ackvec_add(struct dccp_ackvec *av, const struct sock *sk,
+                    const u64 ackno, const u8 state)
+{
+        /*
+         * Check at the right places if the buffer is full, if it is, tell the
+         * caller to start dropping packets till the HC-Sender acks our ACK
+         * vectors, when we will free up space in dccpav_buf.
+         *
+         * We may well decide to do buffer compression, etc, but for now lets
+         * just drop.
+         *
+         * From Appendix A:
+         *
+         *      Of course, the circular buffer may overflow, either when the
+         *      HC-Sender is sending data at a very high rate, when the
+         *      HC-Receiver's acknowledgements are not reaching the HC-Sender,
+         *      or when the HC-Sender is forgetting to acknowledge those acks
+         *      (so the HC-Receiver is unable to clean up old state). In this
+         *      case, the HC-Receiver should either compress the buffer (by
+         *      increasing run lengths when possible), transfer its state to
+         *      a larger buffer, or, as a last resort, drop all received
+         *      packets, without processing them whatsoever, until its buffer
+         *      shrinks again.
+         */
+
+        /* See if this is the first ackno being inserted */
+        if (av->dccpav_vec_len == 0) {
+                av->dccpav_buf[av->dccpav_buf_head] = state;
+                av->dccpav_vec_len = 1;
+        } else if (after48(ackno, av->dccpav_buf_ackno)) {
+                const u64 delta = dccp_delta_seqno(av->dccpav_buf_ackno,
+                                                   ackno);
+
+                /*
+                 * Look if the state of this packet is the same as the
+                 * previous ackno and if so if we can bump the head len.
+                 */
+                if (delta == 1 &&
+                    dccp_ackvec_state(av, av->dccpav_buf_head) == state &&
+                    (dccp_ackvec_len(av, av->dccpav_buf_head) <
+                     DCCP_ACKVEC_LEN_MASK))
+                        av->dccpav_buf[av->dccpav_buf_head]++;
+                else if (dccp_ackvec_set_buf_head_state(av, delta, state))
+                        return -ENOBUFS;
+        } else {
+                /*
+                 * A.1.2.  Old Packets
+                 *
+                 *      When a packet with Sequence Number S arrives, and
+                 *      S <= buf_ackno, the HC-Receiver will scan the table
+                 *      for the byte corresponding to S. (Indexing structures
+                 *      could reduce the complexity of this scan.)
+                 */
+                u64 delta = dccp_delta_seqno(ackno, av->dccpav_buf_ackno);
+                unsigned int index = av->dccpav_buf_head;
+
+                while (1) {
+                        const u8 len = dccp_ackvec_len(av, index);
+                        const u8 state = dccp_ackvec_state(av, index);
+                        /*
+                         * valid packets not yet in dccpav_buf have a reserved
+                         * entry, with a len equal to 0.
+                         */
+                        if (state == DCCP_ACKVEC_STATE_NOT_RECEIVED &&
+                            len == 0 && delta == 0) { /* Found our
+                                                         reserved seat! */
+                                dccp_pr_debug("Found %llu reserved seat!\n",
+                                              (unsigned long long)ackno);
+                                av->dccpav_buf[index] = state;
+                                goto out;
+                        }
+                        /* len == 0 means one packet */
+                        if (delta < len + 1)
+                                goto out_duplicate;
+
+                        delta -= len + 1;
+                        if (++index == av->dccpav_buf_len)
+                                index = 0;
+                }
+        }
+
+        av->dccpav_buf_ackno = ackno;
+        dccp_timestamp(sk, &av->dccpav_time);
+out:
+        dccp_pr_debug("");
+        return 0;
+
+out_duplicate:
+        /* Duplicate packet */
+        dccp_pr_debug("Received a dup or already considered lost "
+                      "packet: %llu\n", (unsigned long long)ackno);
+        return -EILSEQ;
+}
+
+#ifdef CONFIG_IP_DCCP_DEBUG
+void dccp_ackvector_print(const u64 ackno, const unsigned char *vector, int len)
+{
+        if (!dccp_debug)
+                return;
+
+        printk("ACK vector len=%d, ackno=%llu |", len,
+               (unsigned long long)ackno);
+
+        while (len--) {
+                const u8 state = (*vector & DCCP_ACKVEC_STATE_MASK) >> 6;
+                const u8 rl = *vector & DCCP_ACKVEC_LEN_MASK;
+
+                printk("%d,%d|", state, rl);
+                ++vector;
+        }
+
+        printk("\n");
+}
+
+void dccp_ackvec_print(const struct dccp_ackvec *av)
+{
+        dccp_ackvector_print(av->dccpav_buf_ackno,
+                             av->dccpav_buf + av->dccpav_buf_head,
+                             av->dccpav_vec_len);
+}
+#endif
+
+static void dccp_ackvec_trow_away_ack_record(struct dccp_ackvec *av)
+{
+        /*
+         * As we're keeping track of the ack vector size (dccpav_vec_len) and
+         * the sent ack vector size (dccpav_sent_len) we don't need
+         * dccpav_buf_tail at all, but keep this code here as in the future
+         * we'll implement a vector of ack records, as suggested in
+         * draft-ietf-dccp-spec-11.txt Appendix A. -acme
+         */
+#if 0
+        av->dccpav_buf_tail = av->dccpav_ack_ptr + 1;
+        if (av->dccpav_buf_tail >= av->dccpav_vec_len)
+                av->dccpav_buf_tail -= av->dccpav_vec_len;
+#endif
+        av->dccpav_vec_len -= av->dccpav_sent_len;
+}
+
+void dccp_ackvec_check_rcv_ackno(struct dccp_ackvec *av, struct sock *sk,
+                                 const u64 ackno)
+{
+        /* Check if we actually sent an ACK vector */
+        if (av->dccpav_ack_seqno == DCCP_MAX_SEQNO + 1)
+                return;
+
+        if (ackno == av->dccpav_ack_seqno) {
+#ifdef CONFIG_IP_DCCP_DEBUG
+                struct dccp_sock *dp = dccp_sk(sk);
+                const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ?
+                                        "CLIENT rx ack: " : "server rx ack: ";
+#endif
+                dccp_pr_debug("%sACK packet 0, len=%d, ack_seqno=%llu, "
+                              "ack_ackno=%llu, ACKED!\n",
+                              debug_prefix, 1,
+                              (unsigned long long)av->dccpav_ack_seqno,
+                              (unsigned long long)av->dccpav_ack_ackno);
+                dccp_ackvec_trow_away_ack_record(av);
+                av->dccpav_ack_seqno = DCCP_MAX_SEQNO + 1;
+        }
+}
+
+static void dccp_ackvec_check_rcv_ackvector(struct dccp_ackvec *av,
+                                            struct sock *sk, u64 ackno,
+                                            const unsigned char len,
+                                            const unsigned char *vector)
+{
+        unsigned char i;
+
+        /* Check if we actually sent an ACK vector */
+        if (av->dccpav_ack_seqno == DCCP_MAX_SEQNO + 1)
+                return;
+        /*
+         * We're in the receiver half connection, so if the received an ACK
+         * vector ackno (e.g. 50) before dccpav_ack_seqno (e.g. 52), we're
+         * not interested.
+         *
+         * Extra explanation with example:
+         * 
+         * if we received an ACK vector with ackno 50, it can only be acking
+         * 50, 49, 48, etc, not 52 (the seqno for the ACK vector we sent).
+         */
+        /* dccp_pr_debug("is %llu < %llu? ", ackno, av->dccpav_ack_seqno); */
+        if (before48(ackno, av->dccpav_ack_seqno)) {
+                /* dccp_pr_debug_cat("yes\n"); */
+                return;
+        }
+        /* dccp_pr_debug_cat("no\n"); */
+
+        i = len;
+        while (i--) {
+                const u8 rl = *vector & DCCP_ACKVEC_LEN_MASK;
+                u64 ackno_end_rl;
+
+                dccp_set_seqno(&ackno_end_rl, ackno - rl);
+
+                /*
+                 * dccp_pr_debug("is %llu <= %llu <= %llu? ", ackno_end_rl,
+                 * av->dccpav_ack_seqno, ackno);
+                 */
+                if (between48(av->dccpav_ack_seqno, ackno_end_rl, ackno)) {
+                        const u8 state = (*vector &
+                                          DCCP_ACKVEC_STATE_MASK) >> 6;
+                        /* dccp_pr_debug_cat("yes\n"); */
+
+                        if (state != DCCP_ACKVEC_STATE_NOT_RECEIVED) {
+#ifdef CONFIG_IP_DCCP_DEBUG
+                                struct dccp_sock *dp = dccp_sk(sk);
+                                const char *debug_prefix =
+                                        dp->dccps_role == DCCP_ROLE_CLIENT ?
+                                        "CLIENT rx ack: " : "server rx ack: ";
+#endif
+                                dccp_pr_debug("%sACK vector 0, len=%d, "
+                                              "ack_seqno=%llu, ack_ackno=%llu, "
+                                              "ACKED!\n",
+                                              debug_prefix, len,
+                                              (unsigned long long)
+                                              av->dccpav_ack_seqno,
+                                              (unsigned long long)
+                                              av->dccpav_ack_ackno);
+                                dccp_ackvec_trow_away_ack_record(av);
+                        }
+                        /*
+                         * If dccpav_ack_seqno was not received, no problem
+                         * we'll send another ACK vector.
+                         */
+                        av->dccpav_ack_seqno = DCCP_MAX_SEQNO + 1;
+                        break;
+                }
+                /* dccp_pr_debug_cat("no\n"); */
+
+                dccp_set_seqno(&ackno, ackno_end_rl - 1);
+                ++vector;
+        }
+}
+
+int dccp_ackvec_parse(struct sock *sk, const struct sk_buff *skb,
+                      const u8 opt, const u8 *value, const u8 len)
+{
+        if (len > DCCP_MAX_ACKVEC_LEN)
+                return -1;
+
+        /* dccp_ackvector_print(DCCP_SKB_CB(skb)->dccpd_ack_seq, value, len); */
+        dccp_ackvec_check_rcv_ackvector(dccp_sk(sk)->dccps_hc_rx_ackvec, sk,
+                                        DCCP_SKB_CB(skb)->dccpd_ack_seq,
+                                        len, value);
+        return 0;
+}
diff --git a/net/dccp/ackvec.h b/net/dccp/ackvec.h
new file mode 100644
index 000000000000..8ca51c9191f7
--- /dev/null
+++ b/net/dccp/ackvec.h
@@ -0,0 +1,133 @@
+#ifndef _ACKVEC_H
+#define _ACKVEC_H
+/*
+ *  net/dccp/ackvec.h
+ *
+ *  An implementation of the DCCP protocol
+ *  Copyright (c) 2005 Arnaldo Carvalho de Melo <acme@mandriva.com>
+ *
+ *      This program is free software; you can redistribute it and/or modify it
+ *      under the terms of the GNU General Public License version 2 as
+ *      published by the Free Software Foundation.
+ */
+
+#include <linux/config.h>
+#include <linux/compiler.h>
+#include <linux/time.h>
+#include <linux/types.h>
+
+/* Read about the ECN nonce to see why it is 253 */
+#define DCCP_MAX_ACKVEC_LEN 253
+
+#define DCCP_ACKVEC_STATE_RECEIVED      0
+#define DCCP_ACKVEC_STATE_ECN_MARKED    (1 << 6)
+#define DCCP_ACKVEC_STATE_NOT_RECEIVED  (3 << 6)
+
+#define DCCP_ACKVEC_STATE_MASK          0xC0 /* 11000000 */
+#define DCCP_ACKVEC_LEN_MASK            0x3F /* 00111111 */
+
+/** struct dccp_ackvec - ack vector
+ *
+ * This data structure is the one defined in the DCCP draft
+ * Appendix A.
+ *
+ * @dccpav_buf_head - circular buffer head
+ * @dccpav_buf_tail - circular buffer tail
+ * @dccpav_buf_ackno - ack # of the most recent packet acknowledgeable in the
+ *                     buffer (i.e. %dccpav_buf_head)
+ * @dccpav_buf_nonce - the one-bit sum of the ECN Nonces on all packets acked
+ *                     by the buffer with State 0
+ *
+ * Additionally, the HC-Receiver must keep some information about the
+ * Ack Vectors it has recently sent. For each packet sent carrying an
+ * Ack Vector, it remembers four variables:
+ *
+ * @dccpav_ack_seqno - the Sequence Number used for the packet
+ *                     (HC-Receiver seqno)
+ * @dccpav_ack_ptr - the value of buf_head at the time of acknowledgement.
+ * @dccpav_ack_ackno - the Acknowledgement Number used for the packet
+ *                     (HC-Sender seqno)
+ * @dccpav_ack_nonce - the one-bit sum of the ECN Nonces for all State 0.
+ *
+ * @dccpav_buf_len      - circular buffer length
+ * @dccpav_time         - the time in usecs
+ * @dccpav_buf - circular buffer of acknowledgeable packets
+ */
+struct dccp_ackvec {
+        unsigned int    dccpav_buf_head;
+        unsigned int    dccpav_buf_tail;
+        u64             dccpav_buf_ackno;
+        u64             dccpav_ack_seqno;
+        u64             dccpav_ack_ackno;
+        unsigned int    dccpav_ack_ptr;
+        unsigned int    dccpav_sent_len;
+        unsigned int    dccpav_vec_len;
+        unsigned int    dccpav_buf_len;
+        struct timeval  dccpav_time;
+        u8              dccpav_buf_nonce;
+        u8              dccpav_ack_nonce;
+        u8              dccpav_buf[0];
+};
+
+struct sock;
+struct sk_buff;
+
+#ifdef CONFIG_IP_DCCP_ACKVEC
+extern struct dccp_ackvec *dccp_ackvec_alloc(unsigned int len,
+                                          const unsigned int __nocast priority);
+extern void dccp_ackvec_free(struct dccp_ackvec *av);
+
+extern int dccp_ackvec_add(struct dccp_ackvec *av, const struct sock *sk,
+                           const u64 ackno, const u8 state);
+
+extern void dccp_ackvec_check_rcv_ackno(struct dccp_ackvec *av,
+                                        struct sock *sk, const u64 ackno);
+extern int dccp_ackvec_parse(struct sock *sk, const struct sk_buff *skb,
+                             const u8 opt, const u8 *value, const u8 len);
+
+extern int dccp_insert_option_ackvec(struct sock *sk, struct sk_buff *skb);
+
+static inline int dccp_ackvec_pending(const struct dccp_ackvec *av)
+{
+        return av->dccpav_sent_len != av->dccpav_vec_len;
+}
+#else /* CONFIG_IP_DCCP_ACKVEC */
+static inline struct dccp_ackvec *dccp_ackvec_alloc(unsigned int len,
+                                           const unsigned int __nocast priority)
+{
+        return NULL;
+}
+
+static inline void dccp_ackvec_free(struct dccp_ackvec *av)
+{
+}
+
+static inline int dccp_ackvec_add(struct dccp_ackvec *av, const struct sock *sk,
+                                  const u64 ackno, const u8 state)
+{
+        return -1;
+}
+
+static inline void dccp_ackvec_check_rcv_ackno(struct dccp_ackvec *av,
+                                               struct sock *sk, const u64 ackno)
+{
+}
+
+static inline int dccp_ackvec_parse(struct sock *sk, const struct sk_buff *skb,
+                                    const u8 opt, const u8 *value, const u8 len)
+{
+        return -1;
+}
+
+static inline int dccp_insert_option_ackvec(const struct sock *sk,
+                                            const struct sk_buff *skb)
+{
+        return -1;
+}
+
+static inline int dccp_ackvec_pending(const struct dccp_ackvec *av)
+{
+        return 0;
+}
+#endif /* CONFIG_IP_DCCP_ACKVEC */
+#endif /* _ACKVEC_H */
diff --git a/net/dccp/dccp.h b/net/dccp/dccp.h
index be7a660b6b24..5871c027f9dc 100644
--- a/net/dccp/dccp.h
+++ b/net/dccp/dccp.h
@@ -17,6 +17,7 @@
 #include <net/snmp.h>
 #include <net/sock.h>
 #include <net/tcp.h>
+#include "ackvec.h"
 
 #ifdef CONFIG_IP_DCCP_DEBUG
 extern int dccp_debug;
@@ -358,6 +359,17 @@ static inline void dccp_update_gss(struct sock *sk, u64 seq)
                        (dp->dccps_gss -
                         dp->dccps_options.dccpo_sequence_window + 1));
 }
+                                
+static inline int dccp_ack_pending(const struct sock *sk)
+{
+        const struct dccp_sock *dp = dccp_sk(sk);
+        return dp->dccps_timestamp_echo != 0 ||
+#ifdef CONFIG_IP_DCCP_ACKVEC
+               (dp->dccps_options.dccpo_send_ack_vector &&
+                dccp_ackvec_pending(dp->dccps_hc_rx_ackvec)) ||
+#endif
+               inet_csk_ack_scheduled(sk);
+}
 
 extern void dccp_insert_options(struct sock *sk, struct sk_buff *skb);
 extern void dccp_insert_option_elapsed_time(struct sock *sk,
@@ -371,65 +383,6 @@ extern void dccp_insert_option(struct sock *sk, struct sk_buff *skb,
 
 extern struct socket *dccp_ctl_socket;
 
-#define DCCP_ACKPKTS_STATE_RECEIVED     0
-#define DCCP_ACKPKTS_STATE_ECN_MARKED   (1 << 6)
-#define DCCP_ACKPKTS_STATE_NOT_RECEIVED (3 << 6)
-
-#define DCCP_ACKPKTS_STATE_MASK         0xC0 /* 11000000 */
-#define DCCP_ACKPKTS_LEN_MASK           0x3F /* 00111111 */
-
-/** struct dccp_ackpkts - acknowledgeable packets
- *
- * This data structure is the one defined in the DCCP draft
- * Appendix A.
- *
- * @dccpap_buf_head - circular buffer head
- * @dccpap_buf_tail - circular buffer tail
- * @dccpap_buf_ackno - ack # of the most recent packet acknowledgeable in the
- *                     buffer (i.e. %dccpap_buf_head)
- * @dccpap_buf_nonce - the one-bit sum of the ECN Nonces on all packets acked
- *                     by the buffer with State 0
- *
- * Additionally, the HC-Receiver must keep some information about the
- * Ack Vectors it has recently sent. For each packet sent carrying an
- * Ack Vector, it remembers four variables:
- *
- * @dccpap_ack_seqno - the Sequence Number used for the packet
- *                     (HC-Receiver seqno)
- * @dccpap_ack_ptr - the value of buf_head at the time of acknowledgement.
- * @dccpap_ack_ackno - the Acknowledgement Number used for the packet
- *                     (HC-Sender seqno)
- * @dccpap_ack_nonce - the one-bit sum of the ECN Nonces for all State 0.
- *
- * @dccpap_buf_len - circular buffer length
- * @dccpap_time         - the time in usecs
- * @dccpap_buf - circular buffer of acknowledgeable packets
- */
-struct dccp_ackpkts {
-        unsigned int            dccpap_buf_head;
-        unsigned int            dccpap_buf_tail;
-        u64                     dccpap_buf_ackno;
-        u64                     dccpap_ack_seqno;
-        u64                     dccpap_ack_ackno;
-        unsigned int            dccpap_ack_ptr;
-        unsigned int            dccpap_buf_vector_len;
-        unsigned int            dccpap_ack_vector_len;
-        unsigned int            dccpap_buf_len;
-        struct timeval          dccpap_time;
-        u8                      dccpap_buf_nonce;
-        u8                      dccpap_ack_nonce;
-        u8                      dccpap_buf[0];
-};
-
-extern struct dccp_ackpkts *
-                dccp_ackpkts_alloc(unsigned int len,
-                                  const unsigned int __nocast priority);
-extern void dccp_ackpkts_free(struct dccp_ackpkts *ap);
-extern int dccp_ackpkts_add(struct dccp_ackpkts *ap, const struct sock *sk,
-                            u64 ackno, u8 state);
-extern void dccp_ackpkts_check_rcv_ackno(struct dccp_ackpkts *ap,
-                                         struct sock *sk, u64 ackno);
-
 extern void dccp_timestamp(const struct sock *sk, struct timeval *tv);
 
 static inline suseconds_t timeval_usecs(const struct timeval *tv)
@@ -470,15 +423,4 @@ static inline void timeval_sub_usecs(struct timeval *tv,
         }
 }
 
-#ifdef CONFIG_IP_DCCP_DEBUG
-extern void dccp_ackvector_print(const u64 ackno,
-                                 const unsigned char *vector, int len);
-extern void dccp_ackpkts_print(const struct dccp_ackpkts *ap);
-#else
-static inline void dccp_ackvector_print(const u64 ackno,
-                                        const unsigned char *vector,
-                                        int len) { }
-static inline void dccp_ackpkts_print(const struct dccp_ackpkts *ap) { }
-#endif
-
 #endif /* _DCCP_H */
diff --git a/net/dccp/input.c b/net/dccp/input.c
index 062e9f8359d0..1b6b2cb12376 100644
--- a/net/dccp/input.c
+++ b/net/dccp/input.c
@@ -16,6 +16,7 @@
 
 #include <net/sock.h>
 
+#include "ackvec.h"
 #include "ccid.h"
 #include "dccp.h"
 
@@ -60,8 +61,8 @@ static inline void dccp_event_ack_recv(struct sock *sk, struct sk_buff *skb)
         struct dccp_sock *dp = dccp_sk(sk);
 
         if (dp->dccps_options.dccpo_send_ack_vector)
-                dccp_ackpkts_check_rcv_ackno(dp->dccps_hc_rx_ackpkts, sk,
-                                             DCCP_SKB_CB(skb)->dccpd_ack_seq);
+                dccp_ackvec_check_rcv_ackno(dp->dccps_hc_rx_ackvec, sk,
+                                            DCCP_SKB_CB(skb)->dccpd_ack_seq);
 }
 
 static int dccp_check_seqno(struct sock *sk, struct sk_buff *skb)
@@ -164,37 +165,11 @@ int dccp_rcv_established(struct sock *sk, struct sk_buff *skb,
         if (DCCP_SKB_CB(skb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
                 dccp_event_ack_recv(sk, skb);
 
-        /*
-         * FIXME: check ECN to see if we should use
-         * DCCP_ACKPKTS_STATE_ECN_MARKED
-         */
-        if (dp->dccps_options.dccpo_send_ack_vector) {
-                struct dccp_ackpkts *ap = dp->dccps_hc_rx_ackpkts;
-
-                if (dccp_ackpkts_add(dp->dccps_hc_rx_ackpkts, sk,
-                                     DCCP_SKB_CB(skb)->dccpd_seq,
-                                     DCCP_ACKPKTS_STATE_RECEIVED)) {
-                        LIMIT_NETDEBUG(KERN_WARNING "DCCP: acknowledgeable "
-                                                    "packets buffer full!\n");
-                        ap->dccpap_ack_seqno = DCCP_MAX_SEQNO + 1;
-                        inet_csk_schedule_ack(sk);
-                        inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
-                                                  TCP_DELACK_MIN,
-                                                  DCCP_RTO_MAX);
-                        goto discard;
-                }
-
-                /*
-                 * FIXME: this activation is probably wrong, have to study more
-                 * TCP delack machinery and how it fits into DCCP draft, but
-                 * for now it kinda "works" 8)
-                 */
-                if (!inet_csk_ack_scheduled(sk)) {
-                        inet_csk_schedule_ack(sk);
-                        inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, 5 * HZ,
-                                                  DCCP_RTO_MAX);
-                }
-        }
+        if (dp->dccps_options.dccpo_send_ack_vector &&
+            dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
+                            DCCP_SKB_CB(skb)->dccpd_seq,
+                            DCCP_ACKVEC_STATE_RECEIVED))
+                goto discard;
 
         ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb);
         ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb);
@@ -495,29 +470,11 @@ int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
                 ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb);
                 ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb);
 
-                /*
-                 * FIXME: check ECN to see if we should use
-                 * DCCP_ACKPKTS_STATE_ECN_MARKED
-                 */
-                if (dp->dccps_options.dccpo_send_ack_vector) {
-                        if (dccp_ackpkts_add(dp->dccps_hc_rx_ackpkts, sk,
-                                             dcb->dccpd_seq,
-                                             DCCP_ACKPKTS_STATE_RECEIVED))
-                                goto discard;
-                        /*
-                         * FIXME: this activation is probably wrong, have to
-                         * study more TCP delack machinery and how it fits into
-                         * DCCP draft, but for now it kinda "works" 8)
-                         */
-                        if ((dp->dccps_hc_rx_ackpkts->dccpap_ack_seqno ==
-                             DCCP_MAX_SEQNO + 1) &&
-                            !inet_csk_ack_scheduled(sk)) {
-                                inet_csk_schedule_ack(sk);
-                                inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
-                                                          TCP_DELACK_MIN,
-                                                          DCCP_RTO_MAX);
-                        }
-                }
+                if (dp->dccps_options.dccpo_send_ack_vector &&
+                    dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
+                                    DCCP_SKB_CB(skb)->dccpd_seq,
+                                    DCCP_ACKVEC_STATE_RECEIVED))
+                        goto discard;
         }
 
         /*
diff --git a/net/dccp/ipv4.c b/net/dccp/ipv4.c
index 94a440b2685b..82434e4a42df 100644
--- a/net/dccp/ipv4.c
+++ b/net/dccp/ipv4.c
@@ -23,6 +23,7 @@
 #include <net/tcp_states.h>
 #include <net/xfrm.h>
 
+#include "ackvec.h"
 #include "ccid.h"
 #include "dccp.h"
 
@@ -1112,45 +1113,7 @@ int dccp_v4_rcv(struct sk_buff *skb)
                 goto discard_it;
 
         dh = dccp_hdr(skb);
-#if 0
-        /*
-         * Use something like this to simulate some DATA/DATAACK loss to test
-         * dccp_ackpkts_add, you'll get something like this on a session that
-         * sends 10 DATA/DATAACK packets:
-         *
-         * ackpkts_print: 281473596467422 |0,0|3,0|0,0|3,0|0,0|3,0|0,0|3,0|0,1|
-         *
-         * 0, 0 means: DCCP_ACKPKTS_STATE_RECEIVED, RLE == just this packet
-         * 0, 1 means: DCCP_ACKPKTS_STATE_RECEIVED, RLE == two adjacent packets
-         *                                                 with the same state
-         * 3, 0 means: DCCP_ACKPKTS_STATE_NOT_RECEIVED, RLE == just this packet
-         *
-         * So...
-         *
-         * 281473596467422 was received
-         * 281473596467421 was not received
-         * 281473596467420 was received
-         * 281473596467419 was not received
-         * 281473596467418 was received
-         * 281473596467417 was not received
-         * 281473596467416 was received
-         * 281473596467415 was not received
-         * 281473596467414 was received
-         * 281473596467413 was received (this one was the 3way handshake
-         *                               RESPONSE)
-         *
-         */
-        if (dh->dccph_type == DCCP_PKT_DATA ||
-            dh->dccph_type == DCCP_PKT_DATAACK) {
-                static int discard = 0;
 
-                if (discard) {
-                        discard = 0;
-                        goto discard_it;
-                }
-                discard = 1;
-        }
-#endif
         DCCP_SKB_CB(skb)->dccpd_seq  = dccp_hdr_seq(skb);
         DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type;
 
@@ -1264,11 +1227,9 @@ static int dccp_v4_init_sock(struct sock *sk)
         do_gettimeofday(&dp->dccps_epoch);
 
         if (dp->dccps_options.dccpo_send_ack_vector) {
-                dp->dccps_hc_rx_ackpkts =
-                        dccp_ackpkts_alloc(DCCP_MAX_ACK_VECTOR_LEN,
-                                           GFP_KERNEL);
-
-                if (dp->dccps_hc_rx_ackpkts == NULL)
+                dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(DCCP_MAX_ACKVEC_LEN,
+                                                           GFP_KERNEL);
+                if (dp->dccps_hc_rx_ackvec == NULL)
                         return -ENOMEM;
         }
 
@@ -1288,8 +1249,10 @@ static int dccp_v4_init_sock(struct sock *sk)
                     dp->dccps_hc_tx_ccid == NULL) {
                         ccid_exit(dp->dccps_hc_rx_ccid, sk);
                         ccid_exit(dp->dccps_hc_tx_ccid, sk);
-                        dccp_ackpkts_free(dp->dccps_hc_rx_ackpkts);
-                        dp->dccps_hc_rx_ackpkts = NULL;
+                        if (dp->dccps_options.dccpo_send_ack_vector) {
+                                dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
+                                dp->dccps_hc_rx_ackvec = NULL;
+                        }
                         dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
                         return -ENOMEM;
                 }
@@ -1331,8 +1294,10 @@ static int dccp_v4_destroy_sock(struct sock *sk)
 
         ccid_hc_rx_exit(dp->dccps_hc_rx_ccid, sk);
         ccid_hc_tx_exit(dp->dccps_hc_tx_ccid, sk);
-        dccp_ackpkts_free(dp->dccps_hc_rx_ackpkts);
-        dp->dccps_hc_rx_ackpkts = NULL;
+        if (dp->dccps_options.dccpo_send_ack_vector) {
+                dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
+                dp->dccps_hc_rx_ackvec = NULL;
+        }
         ccid_exit(dp->dccps_hc_rx_ccid, sk);
         ccid_exit(dp->dccps_hc_tx_ccid, sk);
         dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
diff --git a/net/dccp/minisocks.c b/net/dccp/minisocks.c
index 933e10db1789..1393461898bb 100644
--- a/net/dccp/minisocks.c
+++ b/net/dccp/minisocks.c
@@ -19,6 +19,7 @@
 #include <net/xfrm.h>
 #include <net/inet_timewait_sock.h>
 
+#include "ackvec.h"
 #include "ccid.h"
 #include "dccp.h"
 
@@ -94,23 +95,23 @@ struct sock *dccp_create_openreq_child(struct sock *sk,
                 struct dccp_sock *newdp = dccp_sk(newsk);
 
                 newdp->dccps_role          = DCCP_ROLE_SERVER;
-                newdp->dccps_hc_rx_ackpkts = NULL;
+                newdp->dccps_hc_rx_ackvec  = NULL;
                 newdp->dccps_service_list  = NULL;
                 newdp->dccps_service       = dreq->dreq_service;
                 newicsk->icsk_rto          = DCCP_TIMEOUT_INIT;
                 do_gettimeofday(&newdp->dccps_epoch);
 
                 if (newdp->dccps_options.dccpo_send_ack_vector) {
-                        newdp->dccps_hc_rx_ackpkts =
-                                dccp_ackpkts_alloc(DCCP_MAX_ACK_VECTOR_LEN,
-                                                   GFP_ATOMIC);
+                        newdp->dccps_hc_rx_ackvec =
+                                dccp_ackvec_alloc(DCCP_MAX_ACKVEC_LEN,
+                                                  GFP_ATOMIC);
                         /*
                          * XXX: We're using the same CCIDs set on the parent,
                          * i.e. sk_clone copied the master sock and left the
                          * CCID pointers for this child, that is why we do the
                          * __ccid_get calls.
                          */
-                        if (unlikely(newdp->dccps_hc_rx_ackpkts == NULL))
+                        if (unlikely(newdp->dccps_hc_rx_ackvec == NULL))
                                 goto out_free;
                 }
 
@@ -118,7 +119,7 @@ struct sock *dccp_create_openreq_child(struct sock *sk,
                                              newsk) != 0 ||
                              ccid_hc_tx_init(newdp->dccps_hc_tx_ccid,
                                              newsk) != 0)) {
-                        dccp_ackpkts_free(newdp->dccps_hc_rx_ackpkts);
+                        dccp_ackvec_free(newdp->dccps_hc_rx_ackvec);
                         ccid_hc_rx_exit(newdp->dccps_hc_rx_ccid, newsk);
                         ccid_hc_tx_exit(newdp->dccps_hc_tx_ccid, newsk);
 out_free:
diff --git a/net/dccp/options.c b/net/dccp/options.c
index d4c4242d8dd7..c480c506a4a4 100644
--- a/net/dccp/options.c
+++ b/net/dccp/options.c
@@ -18,15 +18,10 @@
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
 
+#include "ackvec.h"
 #include "ccid.h"
 #include "dccp.h"
 
-static void dccp_ackpkts_check_rcv_ackvector(struct dccp_ackpkts *ap,
-                                             struct sock *sk,
-                                             const u64 ackno,
-                                             const unsigned char len,
-                                             const unsigned char *vector);
-
 /* stores the default values for new connection. may be changed with sysctl */
 static const struct dccp_options dccpo_default_values = {
         .dccpo_sequence_window    = DCCPF_INITIAL_SEQUENCE_WINDOW,
@@ -113,25 +108,13 @@ int dccp_parse_options(struct sock *sk, struct sk_buff *skb)
                                       opt_recv->dccpor_ndp);
                         break;
                 case DCCPO_ACK_VECTOR_0:
-                        if (len > DCCP_MAX_ACK_VECTOR_LEN)
-                                goto out_invalid_option;
-
+                case DCCPO_ACK_VECTOR_1:
                         if (pkt_type == DCCP_PKT_DATA)
                                 continue;
 
-                        opt_recv->dccpor_ack_vector_len = len;
-                        opt_recv->dccpor_ack_vector_idx = value - options;
-
-                        dccp_pr_debug("%sACK vector 0, len=%d, ack_ackno=%llu\n",
-                                      debug_prefix, len,
-                                      (unsigned long long)
-                                      DCCP_SKB_CB(skb)->dccpd_ack_seq);
-                        dccp_ackvector_print(DCCP_SKB_CB(skb)->dccpd_ack_seq,
-                                             value, len);
-                        dccp_ackpkts_check_rcv_ackvector(dp->dccps_hc_rx_ackpkts,
-                                                         sk,
-                                                 DCCP_SKB_CB(skb)->dccpd_ack_seq,
-                                                         len, value);
+                        if (dp->dccps_options.dccpo_send_ack_vector &&
+                            dccp_ackvec_parse(sk, skb, opt, value, len))
+                                goto out_invalid_option;
                         break;
                 case DCCPO_TIMESTAMP:
                         if (len != 4)
@@ -352,86 +335,6 @@ void dccp_insert_option_elapsed_time(struct sock *sk,
 
 EXPORT_SYMBOL_GPL(dccp_insert_option_elapsed_time);
 
-static void dccp_insert_option_ack_vector(struct sock *sk, struct sk_buff *skb)
-{
-        struct dccp_sock *dp = dccp_sk(sk);
-#ifdef CONFIG_IP_DCCP_DEBUG
-        const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ?
-                                        "CLIENT TX opt: " : "server TX opt: ";
-#endif
-        struct dccp_ackpkts *ap = dp->dccps_hc_rx_ackpkts;
-        int len = ap->dccpap_buf_vector_len + 2;
-        struct timeval now;
-        u32 elapsed_time;
-        unsigned char *to, *from;
-
-        dccp_timestamp(sk, &now);
-        elapsed_time = timeval_delta(&now, &ap->dccpap_time) / 10;
-
-        if (elapsed_time != 0)
-                dccp_insert_option_elapsed_time(sk, skb, elapsed_time);
-
-        if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN) {
-                LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to "
-                                         "insert ACK Vector!\n");
-                return;
-        }
-
-        /*
-         * XXX: now we have just one ack vector sent record, so
-         * we have to wait for it to be cleared.
-         *
-         * Of course this is not acceptable, but this is just for
-         * basic testing now.
-         */
-        if (ap->dccpap_ack_seqno != DCCP_MAX_SEQNO + 1)
-                return;
-
-        DCCP_SKB_CB(skb)->dccpd_opt_len += len;
-
-        to    = skb_push(skb, len);
-        *to++ = DCCPO_ACK_VECTOR_0;
-        *to++ = len;
-
-        len  = ap->dccpap_buf_vector_len;
-        from = ap->dccpap_buf + ap->dccpap_buf_head;
-
-        /* Check if buf_head wraps */
-        if (ap->dccpap_buf_head + len > ap->dccpap_buf_len) {
-                const unsigned int tailsize = (ap->dccpap_buf_len -
-                                               ap->dccpap_buf_head);
-
-                memcpy(to, from, tailsize);
-                to   += tailsize;
-                len  -= tailsize;
-                from = ap->dccpap_buf;
-        }
-
-        memcpy(to, from, len);
-        /*
-         *      From draft-ietf-dccp-spec-11.txt:
-         *
-         *      For each acknowledgement it sends, the HC-Receiver will add an
-         *      acknowledgement record.  ack_seqno will equal the HC-Receiver
-         *      sequence number it used for the ack packet; ack_ptr will equal
-         *      buf_head; ack_ackno will equal buf_ackno; and ack_nonce will
-         *      equal buf_nonce.
-         *
-         * This implemention uses just one ack record for now.
-         */
-        ap->dccpap_ack_seqno      = DCCP_SKB_CB(skb)->dccpd_seq;
-        ap->dccpap_ack_ptr        = ap->dccpap_buf_head;
-        ap->dccpap_ack_ackno      = ap->dccpap_buf_ackno;
-        ap->dccpap_ack_nonce      = ap->dccpap_buf_nonce;
-        ap->dccpap_ack_vector_len = ap->dccpap_buf_vector_len;
-
-        dccp_pr_debug("%sACK Vector 0, len=%d, ack_seqno=%llu, "
-                      "ack_ackno=%llu\n",
-                      debug_prefix, ap->dccpap_ack_vector_len,
-                      (unsigned long long) ap->dccpap_ack_seqno,
-                      (unsigned long long) ap->dccpap_ack_ackno);
-}
-
 void dccp_timestamp(const struct sock *sk, struct timeval *tv)
 {
         const struct dccp_sock *dp = dccp_sk(sk);
@@ -528,9 +431,8 @@ void dccp_insert_options(struct sock *sk, struct sk_buff *skb)
 
         if (!dccp_packet_without_ack(skb)) {
                 if (dp->dccps_options.dccpo_send_ack_vector &&
-                    (dp->dccps_hc_rx_ackpkts->dccpap_buf_ackno !=
-                     DCCP_MAX_SEQNO + 1))
-                        dccp_insert_option_ack_vector(sk, skb);
+                    dccp_ackvec_pending(dp->dccps_hc_rx_ackvec))
+                        dccp_insert_option_ackvec(sk, skb);
                 if (dp->dccps_timestamp_echo != 0)
                         dccp_insert_option_timestamp_echo(sk, skb);
         }
@@ -557,331 +459,3 @@ void dccp_insert_options(struct sock *sk, struct sk_buff *skb)
                 }
         }
 }
-
-struct dccp_ackpkts *dccp_ackpkts_alloc(const unsigned int len,
-                                        const unsigned int __nocast priority)
-{
-        struct dccp_ackpkts *ap = kmalloc(sizeof(*ap) + len, priority);
-
-        if (ap != NULL) {
-#ifdef CONFIG_IP_DCCP_DEBUG
-                memset(ap->dccpap_buf, 0xFF, len);
-#endif
-                ap->dccpap_buf_len   = len;
-                ap->dccpap_buf_head  =
-                        ap->dccpap_buf_tail =
-                                ap->dccpap_buf_len - 1;
-                ap->dccpap_buf_ackno =
-                        ap->dccpap_ack_ackno =
-                                ap->dccpap_ack_seqno = DCCP_MAX_SEQNO + 1;
-                ap->dccpap_buf_nonce = ap->dccpap_buf_nonce = 0;
-                ap->dccpap_ack_ptr   = 0;
-                ap->dccpap_time.tv_sec = 0;
-                ap->dccpap_time.tv_usec = 0;
-                ap->dccpap_buf_vector_len = ap->dccpap_ack_vector_len = 0;
-        }
-
-        return ap;
-}
-
-void dccp_ackpkts_free(struct dccp_ackpkts *ap)
-{
-        if (ap != NULL) {
-#ifdef CONFIG_IP_DCCP_DEBUG
-                memset(ap, 0xFF, sizeof(*ap) + ap->dccpap_buf_len);
-#endif
-                kfree(ap);
-        }
-}
-
-static inline u8 dccp_ackpkts_state(const struct dccp_ackpkts *ap,
-                                    const unsigned int index)
-{
-        return ap->dccpap_buf[index] & DCCP_ACKPKTS_STATE_MASK;
-}
-
-static inline u8 dccp_ackpkts_len(const struct dccp_ackpkts *ap,
-                                  const unsigned int index)
-{
-        return ap->dccpap_buf[index] & DCCP_ACKPKTS_LEN_MASK;
-}
-
-/*
- * If several packets are missing, the HC-Receiver may prefer to enter multiple
- * bytes with run length 0, rather than a single byte with a larger run length;
- * this simplifies table updates if one of the missing packets arrives.
- */
-static inline int dccp_ackpkts_set_buf_head_state(struct dccp_ackpkts *ap,
-                                                  const unsigned int packets,
-                                                  const unsigned char state)
-{
-        unsigned int gap;
-        signed long new_head;
-
-        if (ap->dccpap_buf_vector_len + packets > ap->dccpap_buf_len)
-                return -ENOBUFS;
-
-        gap      = packets - 1;
-        new_head = ap->dccpap_buf_head - packets;
-
-        if (new_head < 0) {
-                if (gap > 0) {
-                        memset(ap->dccpap_buf, DCCP_ACKPKTS_STATE_NOT_RECEIVED,
-                               gap + new_head + 1);
-                        gap = -new_head;
-                }
-                new_head += ap->dccpap_buf_len;
-        } 
-
-        ap->dccpap_buf_head = new_head;
-
-        if (gap > 0)
-                memset(ap->dccpap_buf + ap->dccpap_buf_head + 1,
-                       DCCP_ACKPKTS_STATE_NOT_RECEIVED, gap);
-
-        ap->dccpap_buf[ap->dccpap_buf_head] = state;
-        ap->dccpap_buf_vector_len += packets;
-        return 0;
-}
-
-/*
- * Implements the draft-ietf-dccp-spec-11.txt Appendix A
- */
-int dccp_ackpkts_add(struct dccp_ackpkts *ap, const struct sock *sk,
-                     u64 ackno, u8 state)
-{
-        /*
-         * Check at the right places if the buffer is full, if it is, tell the
-         * caller to start dropping packets till the HC-Sender acks our ACK
-         * vectors, when we will free up space in dccpap_buf.
-         *
-         * We may well decide to do buffer compression, etc, but for now lets
-         * just drop.
-         *
-         * From Appendix A:
-         *
-         *      Of course, the circular buffer may overflow, either when the
-         *      HC-Sender is sending data at a very high rate, when the
-         *      HC-Receiver's acknowledgements are not reaching the HC-Sender,
-         *      or when the HC-Sender is forgetting to acknowledge those acks
-         *      (so the HC-Receiver is unable to clean up old state). In this
-         *      case, the HC-Receiver should either compress the buffer (by
-         *      increasing run lengths when possible), transfer its state to
-         *      a larger buffer, or, as a last resort, drop all received
-         *      packets, without processing them whatsoever, until its buffer
-         *      shrinks again.
-         */
-
-        /* See if this is the first ackno being inserted */
-        if (ap->dccpap_buf_vector_len == 0) {
-                ap->dccpap_buf[ap->dccpap_buf_head] = state;
-                ap->dccpap_buf_vector_len = 1;
-        } else if (after48(ackno, ap->dccpap_buf_ackno)) {
-                const u64 delta = dccp_delta_seqno(ap->dccpap_buf_ackno,
-                                                   ackno);
-
-                /*
-                 * Look if the state of this packet is the same as the
-                 * previous ackno and if so if we can bump the head len.
-                 */
-                if (delta == 1 &&
-                    dccp_ackpkts_state(ap, ap->dccpap_buf_head) == state &&
-                    (dccp_ackpkts_len(ap, ap->dccpap_buf_head) <
-                     DCCP_ACKPKTS_LEN_MASK))
-                        ap->dccpap_buf[ap->dccpap_buf_head]++;
-                else if (dccp_ackpkts_set_buf_head_state(ap, delta, state))
-                        return -ENOBUFS;
-        } else {
-                /*
-                 * A.1.2.  Old Packets
-                 *
-                 *      When a packet with Sequence Number S arrives, and
-                 *      S <= buf_ackno, the HC-Receiver will scan the table
-                 *      for the byte corresponding to S. (Indexing structures
-                 *      could reduce the complexity of this scan.)
-                 */
-                u64 delta = dccp_delta_seqno(ackno, ap->dccpap_buf_ackno);
-                unsigned int index = ap->dccpap_buf_head;
-
-                while (1) {
-                        const u8 len = dccp_ackpkts_len(ap, index);
-                        const u8 state = dccp_ackpkts_state(ap, index);
-                        /*
-                         * valid packets not yet in dccpap_buf have a reserved
-                         * entry, with a len equal to 0.
-                         */
-                        if (state == DCCP_ACKPKTS_STATE_NOT_RECEIVED &&
-                            len == 0 && delta == 0) { /* Found our
-                                                         reserved seat! */
-                                dccp_pr_debug("Found %llu reserved seat!\n",
-                                              (unsigned long long) ackno);
-                                ap->dccpap_buf[index] = state;
-                                goto out;
-                        }
-                        /* len == 0 means one packet */
-                        if (delta < len + 1)
-                                goto out_duplicate;
-
-                        delta -= len + 1;
-                        if (++index == ap->dccpap_buf_len)
-                                index = 0;
-                }
-        }
-
-        ap->dccpap_buf_ackno = ackno;
-        dccp_timestamp(sk, &ap->dccpap_time);
-out:
-        dccp_pr_debug("");
-        dccp_ackpkts_print(ap);
-        return 0;
-
-out_duplicate:
-        /* Duplicate packet */
-        dccp_pr_debug("Received a dup or already considered lost "
-                      "packet: %llu\n", (unsigned long long) ackno);
-        return -EILSEQ;
-}
-
-#ifdef CONFIG_IP_DCCP_DEBUG
-void dccp_ackvector_print(const u64 ackno, const unsigned char *vector,
-                          int len)
-{
-        if (!dccp_debug)
-                return;
-
-        printk("ACK vector len=%d, ackno=%llu |", len,
-               (unsigned long long) ackno);
-
-        while (len--) {
-                const u8 state = (*vector & DCCP_ACKPKTS_STATE_MASK) >> 6;
-                const u8 rl = (*vector & DCCP_ACKPKTS_LEN_MASK);
-
-                printk("%d,%d|", state, rl);
-                ++vector;
-        }
-
-        printk("\n");
-}
-
-void dccp_ackpkts_print(const struct dccp_ackpkts *ap)
-{
-        dccp_ackvector_print(ap->dccpap_buf_ackno,
-                             ap->dccpap_buf + ap->dccpap_buf_head,
-                             ap->dccpap_buf_vector_len);
-}
-#endif
-
-static void dccp_ackpkts_trow_away_ack_record(struct dccp_ackpkts *ap)
-{
-        /*
-         * As we're keeping track of the ack vector size
-         * (dccpap_buf_vector_len) and the sent ack vector size
-         * (dccpap_ack_vector_len) we don't need dccpap_buf_tail at all, but
-         * keep this code here as in the future we'll implement a vector of
-         * ack records, as suggested in draft-ietf-dccp-spec-11.txt
-         * Appendix A. -acme
-         */
-#if 0
-        ap->dccpap_buf_tail = ap->dccpap_ack_ptr + 1;
-        if (ap->dccpap_buf_tail >= ap->dccpap_buf_len)
-                ap->dccpap_buf_tail -= ap->dccpap_buf_len;
-#endif
-        ap->dccpap_buf_vector_len -= ap->dccpap_ack_vector_len;
-}
-
-void dccp_ackpkts_check_rcv_ackno(struct dccp_ackpkts *ap, struct sock *sk,
-                                 u64 ackno)
-{
-        /* Check if we actually sent an ACK vector */
-        if (ap->dccpap_ack_seqno == DCCP_MAX_SEQNO + 1)
-                return;
-
-        if (ackno == ap->dccpap_ack_seqno) {
-#ifdef CONFIG_IP_DCCP_DEBUG
-                struct dccp_sock *dp = dccp_sk(sk);
-                const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ?
-                                        "CLIENT rx ack: " : "server rx ack: ";
-#endif
-                dccp_pr_debug("%sACK packet 0, len=%d, ack_seqno=%llu, "
-                              "ack_ackno=%llu, ACKED!\n",
-                              debug_prefix, 1,
-                              (unsigned long long) ap->dccpap_ack_seqno,
-                              (unsigned long long) ap->dccpap_ack_ackno);
-                dccp_ackpkts_trow_away_ack_record(ap);
-                ap->dccpap_ack_seqno = DCCP_MAX_SEQNO + 1;
-        }
-}
-
-static void dccp_ackpkts_check_rcv_ackvector(struct dccp_ackpkts *ap,
-                                             struct sock *sk, u64 ackno,
-                                             const unsigned char len,
-                                             const unsigned char *vector)
-{
-        unsigned char i;
-
-        /* Check if we actually sent an ACK vector */
-        if (ap->dccpap_ack_seqno == DCCP_MAX_SEQNO + 1)
-                return;
-        /*
-         * We're in the receiver half connection, so if the received an ACK
-         * vector ackno (e.g. 50) before dccpap_ack_seqno (e.g. 52), we're
-         * not interested.
-         *
-         * Extra explanation with example:
-         * 
-         * if we received an ACK vector with ackno 50, it can only be acking
-         * 50, 49, 48, etc, not 52 (the seqno for the ACK vector we sent).
-         */
-        /* dccp_pr_debug("is %llu < %llu? ", ackno, ap->dccpap_ack_seqno); */
-        if (before48(ackno, ap->dccpap_ack_seqno)) {
-                /* dccp_pr_debug_cat("yes\n"); */
-                return;
-        }
-        /* dccp_pr_debug_cat("no\n"); */
-
-        i = len;
-        while (i--) {
-                const u8 rl = (*vector & DCCP_ACKPKTS_LEN_MASK);
-                u64 ackno_end_rl;
-
-                dccp_set_seqno(&ackno_end_rl, ackno - rl);
-
-                /*
-                 * dccp_pr_debug("is %llu <= %llu <= %llu? ", ackno_end_rl,
-                 * ap->dccpap_ack_seqno, ackno);
-                 */
-                if (between48(ap->dccpap_ack_seqno, ackno_end_rl, ackno)) {
-                        const u8 state = (*vector &
-                                          DCCP_ACKPKTS_STATE_MASK) >> 6;
-                        /* dccp_pr_debug_cat("yes\n"); */
-
-                        if (state != DCCP_ACKPKTS_STATE_NOT_RECEIVED) {
-#ifdef CONFIG_IP_DCCP_DEBUG
-                                struct dccp_sock *dp = dccp_sk(sk);
-                                const char *debug_prefix =
-                                        dp->dccps_role == DCCP_ROLE_CLIENT ?
-                                        "CLIENT rx ack: " : "server rx ack: ";
-#endif
-                                dccp_pr_debug("%sACK vector 0, len=%d, "
-                                              "ack_seqno=%llu, ack_ackno=%llu, "
-                                              "ACKED!\n",
-                                              debug_prefix, len,
-                                              (unsigned long long)
-                                              ap->dccpap_ack_seqno,
-                                              (unsigned long long)
-                                              ap->dccpap_ack_ackno);
-                                dccp_ackpkts_trow_away_ack_record(ap);
-                        }
-                        /*
-                         * If dccpap_ack_seqno was not received, no problem
-                         * we'll send another ACK vector.
-                         */
-                        ap->dccpap_ack_seqno = DCCP_MAX_SEQNO + 1;
-                        break;
-                }
-                /* dccp_pr_debug_cat("no\n"); */
-
-                dccp_set_seqno(&ackno, ackno_end_rl - 1);
-                ++vector;
-        }
-}
diff --git a/net/dccp/output.c b/net/dccp/output.c
index 156b1d29a156..4786bdcddcc9 100644
--- a/net/dccp/output.c
+++ b/net/dccp/output.c
@@ -16,6 +16,7 @@
 
 #include <net/sock.h>
 
+#include "ackvec.h"
 #include "ccid.h"
 #include "dccp.h"
 
@@ -225,7 +226,6 @@ int dccp_write_xmit(struct sock *sk, struct sk_buff *skb, long *timeo)
                 err = dccp_wait_for_ccid(sk, skb, timeo);
 
         if (err == 0) {
-                const struct dccp_ackpkts *ap = dp->dccps_hc_rx_ackpkts;
                 struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
                 const int len = skb->len;
 
@@ -236,15 +236,7 @@ int dccp_write_xmit(struct sock *sk, struct sk_buff *skb, long *timeo)
                                                   inet_csk(sk)->icsk_rto,
                                                   DCCP_RTO_MAX);
                         dcb->dccpd_type = DCCP_PKT_DATAACK;
-                        /*
-                         * FIXME: we really should have a
-                         * dccps_ack_pending or use icsk.
-                         */
-                } else if (inet_csk_ack_scheduled(sk) ||
-                           dp->dccps_timestamp_echo != 0 ||
-                           (dp->dccps_options.dccpo_send_ack_vector &&
-                            ap->dccpap_buf_ackno != DCCP_MAX_SEQNO + 1 &&
-                            ap->dccpap_ack_seqno == DCCP_MAX_SEQNO + 1))
+                } else if (dccp_ack_pending(sk))
                         dcb->dccpd_type = DCCP_PKT_DATAACK;
                 else
                         dcb->dccpd_type = DCCP_PKT_DATA;