net: ipv4: split skbuff into fragments transformer

This patch exposes a new API to refragment a skbuff. This allows you to
split either a linear skbuff or to force the refragmentation of an
existing fraglist using a different mtu. The API consists of:

* ip_frag_init(), that initializes the internal state of the transformer.
* ip_frag_next(), that allows you to fetch the next fragment. This function
  internally allocates the skbuff that represents the fragment, it pushes
  the IPv4 header, and it also copies the payload for each fragment.

The ip_frag_state object stores the internal state of the splitter.

This code has been extracted from ip_do_fragment(). Symbols are also
exported to allow to reuse this iterator from the bridge codepath to
build its own refragmentation routine by reusing the existing codebase.

Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/net/ip.h b/include/net/ip.h
index be899677504b18464aceb280215d9cac76e6c946..029cc3fd26bd7bfb1324100e068346700d0ed494 100644 (file)
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -188,6 +188,22 @@ static inline struct sk_buff *ip_fraglist_next(struct ip_fraglist_iter *iter)
        return skb;
 }
 
+struct ip_frag_state {
+       struct iphdr    *iph;
+       unsigned int    hlen;
+       unsigned int    ll_rs;
+       unsigned int    mtu;
+       unsigned int    left;
+       int             offset;
+       int             ptr;
+       __be16          not_last_frag;
+};
+
+void ip_frag_init(struct sk_buff *skb, unsigned int hlen, unsigned int ll_rs,
+                 unsigned int mtu, struct ip_frag_state *state);
+struct sk_buff *ip_frag_next(struct sk_buff *skb,
+                            struct ip_frag_state *state);
+
 void ip_send_check(struct iphdr *ip);
 int __ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb);
 int ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb);

diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index d03eb4ae0dd464b705134d0918e79d6cc325ef5a..c3f139843eca47af3da10c788ea015bfa9dab796 100644 (file)
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -609,6 +609,111 @@ void ip_fraglist_prepare(struct sk_buff *skb, struct ip_fraglist_iter *iter)
 }
 EXPORT_SYMBOL(ip_fraglist_prepare);
 
+void ip_frag_init(struct sk_buff *skb, unsigned int hlen,
+                 unsigned int ll_rs, unsigned int mtu,
+                 struct ip_frag_state *state)
+{
+       struct iphdr *iph = ip_hdr(skb);
+
+       state->hlen = hlen;
+       state->ll_rs = ll_rs;
+       state->mtu = mtu;
+
+       state->left = skb->len - hlen;  /* Space per frame */
+       state->ptr = hlen;              /* Where to start from */
+
+       state->offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;
+       state->not_last_frag = iph->frag_off & htons(IP_MF);
+}
+EXPORT_SYMBOL(ip_frag_init);
+
+struct sk_buff *ip_frag_next(struct sk_buff *skb, struct ip_frag_state *state)
+{
+       unsigned int len = state->left;
+       struct sk_buff *skb2;
+       struct iphdr *iph;
+
+       len = state->left;
+       /* IF: it doesn't fit, use 'mtu' - the data space left */
+       if (len > state->mtu)
+               len = state->mtu;
+       /* IF: we are not sending up to and including the packet end
+          then align the next start on an eight byte boundary */
+       if (len < state->left)  {
+               len &= ~7;
+       }
+
+       /* Allocate buffer */
+       skb2 = alloc_skb(len + state->hlen + state->ll_rs, GFP_ATOMIC);
+       if (!skb2)
+               return ERR_PTR(-ENOMEM);
+
+       /*
+        *      Set up data on packet
+        */
+
+       ip_copy_metadata(skb2, skb);
+       skb_reserve(skb2, state->ll_rs);
+       skb_put(skb2, len + state->hlen);
+       skb_reset_network_header(skb2);
+       skb2->transport_header = skb2->network_header + state->hlen;
+
+       /*
+        *      Charge the memory for the fragment to any owner
+        *      it might possess
+        */
+
+       if (skb->sk)
+               skb_set_owner_w(skb2, skb->sk);
+
+       /*
+        *      Copy the packet header into the new buffer.
+        */
+
+       skb_copy_from_linear_data(skb, skb_network_header(skb2), state->hlen);
+
+       /*
+        *      Copy a block of the IP datagram.
+        */
+       if (skb_copy_bits(skb, state->ptr, skb_transport_header(skb2), len))
+               BUG();
+       state->left -= len;
+
+       /*
+        *      Fill in the new header fields.
+        */
+       iph = ip_hdr(skb2);
+       iph->frag_off = htons((state->offset >> 3));
+
+       if (IPCB(skb)->flags & IPSKB_FRAG_PMTU)
+               iph->frag_off |= htons(IP_DF);
+
+       /* ANK: dirty, but effective trick. Upgrade options only if
+        * the segment to be fragmented was THE FIRST (otherwise,
+        * options are already fixed) and make it ONCE
+        * on the initial skb, so that all the following fragments
+        * will inherit fixed options.
+        */
+       if (state->offset == 0)
+               ip_options_fragment(skb);
+
+       /*
+        *      Added AC : If we are fragmenting a fragment that's not the
+        *                 last fragment then keep MF on each bit
+        */
+       if (state->left > 0 || state->not_last_frag)
+               iph->frag_off |= htons(IP_MF);
+       state->ptr += len;
+       state->offset += len;
+
+       iph->tot_len = htons(len + state->hlen);
+
+       ip_send_check(iph);
+
+       return skb2;
+}
+EXPORT_SYMBOL(ip_frag_next);
+
 /*
  *     This IP datagram is too large to be sent in one piece.  Break it up into
  *     smaller pieces (each of size equal to IP header plus
@@ -620,13 +725,11 @@ int ip_do_fragment(struct net *net, struct sock *sk, struct sk_buff *skb,
                   int (*output)(struct net *, struct sock *, struct sk_buff *))
 {
        struct iphdr *iph;
-       int ptr;
        struct sk_buff *skb2;
-       unsigned int mtu, hlen, left, len, ll_rs;
-       int offset;
-       __be16 not_last_frag;
        struct rtable *rt = skb_rtable(skb);
+       unsigned int mtu, hlen, ll_rs;
        struct ip_fraglist_iter iter;
+       struct ip_frag_state state;
        int err = 0;
 
        /* for offloaded checksums cleanup checksum before fragmentation */
@@ -730,105 +833,26 @@ slow_path_clean:
        }
 
 slow_path:
-       iph = ip_hdr(skb);
-
-       left = skb->len - hlen;         /* Space per frame */
-       ptr = hlen;             /* Where to start from */
-
        /*
         *      Fragment the datagram.
         */
 
-       offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;
-       not_last_frag = iph->frag_off & htons(IP_MF);
+       ip_frag_init(skb, hlen, ll_rs, mtu, &state);
 
        /*
         *      Keep copying data until we run out.
         */
 
-       while (left > 0) {
-               len = left;
-               /* IF: it doesn't fit, use 'mtu' - the data space left */
-               if (len > mtu)
-                       len = mtu;
-               /* IF: we are not sending up to and including the packet end
-                  then align the next start on an eight byte boundary */
-               if (len < left) {
-                       len &= ~7;
-               }
-
-               /* Allocate buffer */
-               skb2 = alloc_skb(len + hlen + ll_rs, GFP_ATOMIC);
-               if (!skb2) {
-                       err = -ENOMEM;
+       while (state.left > 0) {
+               skb2 = ip_frag_next(skb, &state);
+               if (IS_ERR(skb2)) {
+                       err = PTR_ERR(skb2);
                        goto fail;
                }
 
-               /*
-                *      Set up data on packet
-                */
-
-               ip_copy_metadata(skb2, skb);
-               skb_reserve(skb2, ll_rs);
-               skb_put(skb2, len + hlen);
-               skb_reset_network_header(skb2);
-               skb2->transport_header = skb2->network_header + hlen;
-
-               /*
-                *      Charge the memory for the fragment to any owner
-                *      it might possess
-                */
-
-               if (skb->sk)
-                       skb_set_owner_w(skb2, skb->sk);
-
-               /*
-                *      Copy the packet header into the new buffer.
-                */
-
-               skb_copy_from_linear_data(skb, skb_network_header(skb2), hlen);
-
-               /*
-                *      Copy a block of the IP datagram.
-                */
-               if (skb_copy_bits(skb, ptr, skb_transport_header(skb2), len))
-                       BUG();
-               left -= len;
-
-               /*
-                *      Fill in the new header fields.
-                */
-               iph = ip_hdr(skb2);
-               iph->frag_off = htons((offset >> 3));
-
-               if (IPCB(skb)->flags & IPSKB_FRAG_PMTU)
-                       iph->frag_off |= htons(IP_DF);
-
-               /* ANK: dirty, but effective trick. Upgrade options only if
-                * the segment to be fragmented was THE FIRST (otherwise,
-                * options are already fixed) and make it ONCE
-                * on the initial skb, so that all the following fragments
-                * will inherit fixed options.
-                */
-               if (offset == 0)
-                       ip_options_fragment(skb);
-
-               /*
-                *      Added AC : If we are fragmenting a fragment that's not the
-                *                 last fragment then keep MF on each bit
-                */
-               if (left > 0 || not_last_frag)
-                       iph->frag_off |= htons(IP_MF);
-               ptr += len;
-               offset += len;
-
                /*
                 *      Put this fragment into the sending queue.
                 */
-               iph->tot_len = htons(len + hlen);
-
-               ip_send_check(iph);
-
                err = output(net, sk, skb2);
                if (err)
                        goto fail;