mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Eric Dumazet](/assets/img/avatar_default.png)
ip_frag_queue() might call pskb_pull() on one skb that
is already in the fragment queue.
We need to take care of possible truesize change, or we
might have an imbalance of the netns frags memory usage.
IPv6 is immune to this bug, because RFC5722, Section 4,
amended by Errata ID 3089 states :
When reassembling an IPv6 datagram, if
one or more its constituent fragments is determined to be an
overlapping fragment, the entire datagram (and any constituent
fragments) MUST be silently discarded.
Fixes: 158f323b98
("net: adjust skb->truesize in pskb_expand_head()")
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
882 lines
21 KiB
C
882 lines
21 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* INET An implementation of the TCP/IP protocol suite for the LINUX
|
|
* operating system. INET is implemented using the BSD Socket
|
|
* interface as the means of communication with the user level.
|
|
*
|
|
* The IP fragmentation functionality.
|
|
*
|
|
* Authors: Fred N. van Kempen <waltje@uWalt.NL.Mugnet.ORG>
|
|
* Alan Cox <alan@lxorguk.ukuu.org.uk>
|
|
*
|
|
* Fixes:
|
|
* Alan Cox : Split from ip.c , see ip_input.c for history.
|
|
* David S. Miller : Begin massive cleanup...
|
|
* Andi Kleen : Add sysctls.
|
|
* xxxx : Overlapfrag bug.
|
|
* Ultima : ip_expire() kernel panic.
|
|
* Bill Hawes : Frag accounting and evictor fixes.
|
|
* John McDonald : 0 length frag bug.
|
|
* Alexey Kuznetsov: SMP races, threading, cleanup.
|
|
* Patrick McHardy : LRU queue of frag heads for evictor.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "IPv4: " fmt
|
|
|
|
#include <linux/compiler.h>
|
|
#include <linux/module.h>
|
|
#include <linux/types.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/list.h>
|
|
#include <linux/ip.h>
|
|
#include <linux/icmp.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/jhash.h>
|
|
#include <linux/random.h>
|
|
#include <linux/slab.h>
|
|
#include <net/route.h>
|
|
#include <net/dst.h>
|
|
#include <net/sock.h>
|
|
#include <net/ip.h>
|
|
#include <net/icmp.h>
|
|
#include <net/checksum.h>
|
|
#include <net/inetpeer.h>
|
|
#include <net/inet_frag.h>
|
|
#include <linux/tcp.h>
|
|
#include <linux/udp.h>
|
|
#include <linux/inet.h>
|
|
#include <linux/netfilter_ipv4.h>
|
|
#include <net/inet_ecn.h>
|
|
#include <net/l3mdev.h>
|
|
|
|
/* NOTE. Logic of IP defragmentation is parallel to corresponding IPv6
|
|
* code now. If you change something here, _PLEASE_ update ipv6/reassembly.c
|
|
* as well. Or notify me, at least. --ANK
|
|
*/
|
|
static const char ip_frag_cache_name[] = "ip4-frags";
|
|
|
|
/* Describe an entry in the "incomplete datagrams" queue. */
|
|
struct ipq {
|
|
struct inet_frag_queue q;
|
|
|
|
u8 ecn; /* RFC3168 support */
|
|
u16 max_df_size; /* largest frag with DF set seen */
|
|
int iif;
|
|
unsigned int rid;
|
|
struct inet_peer *peer;
|
|
};
|
|
|
|
static u8 ip4_frag_ecn(u8 tos)
|
|
{
|
|
return 1 << (tos & INET_ECN_MASK);
|
|
}
|
|
|
|
static struct inet_frags ip4_frags;
|
|
|
|
static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
|
|
struct net_device *dev);
|
|
|
|
|
|
static void ip4_frag_init(struct inet_frag_queue *q, const void *a)
|
|
{
|
|
struct ipq *qp = container_of(q, struct ipq, q);
|
|
struct netns_ipv4 *ipv4 = container_of(q->net, struct netns_ipv4,
|
|
frags);
|
|
struct net *net = container_of(ipv4, struct net, ipv4);
|
|
|
|
const struct frag_v4_compare_key *key = a;
|
|
|
|
q->key.v4 = *key;
|
|
qp->ecn = 0;
|
|
qp->peer = q->net->max_dist ?
|
|
inet_getpeer_v4(net->ipv4.peers, key->saddr, key->vif, 1) :
|
|
NULL;
|
|
}
|
|
|
|
static void ip4_frag_free(struct inet_frag_queue *q)
|
|
{
|
|
struct ipq *qp;
|
|
|
|
qp = container_of(q, struct ipq, q);
|
|
if (qp->peer)
|
|
inet_putpeer(qp->peer);
|
|
}
|
|
|
|
|
|
/* Destruction primitives. */
|
|
|
|
static void ipq_put(struct ipq *ipq)
|
|
{
|
|
inet_frag_put(&ipq->q);
|
|
}
|
|
|
|
/* Kill ipq entry. It is not destroyed immediately,
|
|
* because caller (and someone more) holds reference count.
|
|
*/
|
|
static void ipq_kill(struct ipq *ipq)
|
|
{
|
|
inet_frag_kill(&ipq->q);
|
|
}
|
|
|
|
static bool frag_expire_skip_icmp(u32 user)
|
|
{
|
|
return user == IP_DEFRAG_AF_PACKET ||
|
|
ip_defrag_user_in_between(user, IP_DEFRAG_CONNTRACK_IN,
|
|
__IP_DEFRAG_CONNTRACK_IN_END) ||
|
|
ip_defrag_user_in_between(user, IP_DEFRAG_CONNTRACK_BRIDGE_IN,
|
|
__IP_DEFRAG_CONNTRACK_BRIDGE_IN);
|
|
}
|
|
|
|
/*
|
|
* Oops, a fragment queue timed out. Kill it and send an ICMP reply.
|
|
*/
|
|
static void ip_expire(struct timer_list *t)
|
|
{
|
|
struct inet_frag_queue *frag = from_timer(frag, t, timer);
|
|
const struct iphdr *iph;
|
|
struct sk_buff *head;
|
|
struct net *net;
|
|
struct ipq *qp;
|
|
int err;
|
|
|
|
qp = container_of(frag, struct ipq, q);
|
|
net = container_of(qp->q.net, struct net, ipv4.frags);
|
|
|
|
rcu_read_lock();
|
|
spin_lock(&qp->q.lock);
|
|
|
|
if (qp->q.flags & INET_FRAG_COMPLETE)
|
|
goto out;
|
|
|
|
ipq_kill(qp);
|
|
__IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS);
|
|
|
|
head = qp->q.fragments;
|
|
|
|
__IP_INC_STATS(net, IPSTATS_MIB_REASMTIMEOUT);
|
|
|
|
if (!(qp->q.flags & INET_FRAG_FIRST_IN) || !head)
|
|
goto out;
|
|
|
|
head->dev = dev_get_by_index_rcu(net, qp->iif);
|
|
if (!head->dev)
|
|
goto out;
|
|
|
|
|
|
/* skb has no dst, perform route lookup again */
|
|
iph = ip_hdr(head);
|
|
err = ip_route_input_noref(head, iph->daddr, iph->saddr,
|
|
iph->tos, head->dev);
|
|
if (err)
|
|
goto out;
|
|
|
|
/* Only an end host needs to send an ICMP
|
|
* "Fragment Reassembly Timeout" message, per RFC792.
|
|
*/
|
|
if (frag_expire_skip_icmp(qp->q.key.v4.user) &&
|
|
(skb_rtable(head)->rt_type != RTN_LOCAL))
|
|
goto out;
|
|
|
|
skb_get(head);
|
|
spin_unlock(&qp->q.lock);
|
|
icmp_send(head, ICMP_TIME_EXCEEDED, ICMP_EXC_FRAGTIME, 0);
|
|
kfree_skb(head);
|
|
goto out_rcu_unlock;
|
|
|
|
out:
|
|
spin_unlock(&qp->q.lock);
|
|
out_rcu_unlock:
|
|
rcu_read_unlock();
|
|
ipq_put(qp);
|
|
}
|
|
|
|
/* Find the correct entry in the "incomplete datagrams" queue for
|
|
* this IP datagram, and create new one, if nothing is found.
|
|
*/
|
|
static struct ipq *ip_find(struct net *net, struct iphdr *iph,
|
|
u32 user, int vif)
|
|
{
|
|
struct frag_v4_compare_key key = {
|
|
.saddr = iph->saddr,
|
|
.daddr = iph->daddr,
|
|
.user = user,
|
|
.vif = vif,
|
|
.id = iph->id,
|
|
.protocol = iph->protocol,
|
|
};
|
|
struct inet_frag_queue *q;
|
|
|
|
q = inet_frag_find(&net->ipv4.frags, &key);
|
|
if (!q)
|
|
return NULL;
|
|
|
|
return container_of(q, struct ipq, q);
|
|
}
|
|
|
|
/* Is the fragment too far ahead to be part of ipq? */
|
|
static int ip_frag_too_far(struct ipq *qp)
|
|
{
|
|
struct inet_peer *peer = qp->peer;
|
|
unsigned int max = qp->q.net->max_dist;
|
|
unsigned int start, end;
|
|
|
|
int rc;
|
|
|
|
if (!peer || !max)
|
|
return 0;
|
|
|
|
start = qp->rid;
|
|
end = atomic_inc_return(&peer->rid);
|
|
qp->rid = end;
|
|
|
|
rc = qp->q.fragments && (end - start) > max;
|
|
|
|
if (rc) {
|
|
struct net *net;
|
|
|
|
net = container_of(qp->q.net, struct net, ipv4.frags);
|
|
__IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int ip_frag_reinit(struct ipq *qp)
|
|
{
|
|
struct sk_buff *fp;
|
|
unsigned int sum_truesize = 0;
|
|
|
|
if (!mod_timer(&qp->q.timer, jiffies + qp->q.net->timeout)) {
|
|
refcount_inc(&qp->q.refcnt);
|
|
return -ETIMEDOUT;
|
|
}
|
|
|
|
fp = qp->q.fragments;
|
|
do {
|
|
struct sk_buff *xp = fp->next;
|
|
|
|
sum_truesize += fp->truesize;
|
|
kfree_skb(fp);
|
|
fp = xp;
|
|
} while (fp);
|
|
sub_frag_mem_limit(qp->q.net, sum_truesize);
|
|
|
|
qp->q.flags = 0;
|
|
qp->q.len = 0;
|
|
qp->q.meat = 0;
|
|
qp->q.fragments = NULL;
|
|
qp->q.fragments_tail = NULL;
|
|
qp->iif = 0;
|
|
qp->ecn = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Add new segment to existing queue. */
|
|
static int ip_frag_queue(struct ipq *qp, struct sk_buff *skb)
|
|
{
|
|
struct sk_buff *prev, *next;
|
|
struct net_device *dev;
|
|
unsigned int fragsize;
|
|
int flags, offset;
|
|
int ihl, end;
|
|
int err = -ENOENT;
|
|
u8 ecn;
|
|
|
|
if (qp->q.flags & INET_FRAG_COMPLETE)
|
|
goto err;
|
|
|
|
if (!(IPCB(skb)->flags & IPSKB_FRAG_COMPLETE) &&
|
|
unlikely(ip_frag_too_far(qp)) &&
|
|
unlikely(err = ip_frag_reinit(qp))) {
|
|
ipq_kill(qp);
|
|
goto err;
|
|
}
|
|
|
|
ecn = ip4_frag_ecn(ip_hdr(skb)->tos);
|
|
offset = ntohs(ip_hdr(skb)->frag_off);
|
|
flags = offset & ~IP_OFFSET;
|
|
offset &= IP_OFFSET;
|
|
offset <<= 3; /* offset is in 8-byte chunks */
|
|
ihl = ip_hdrlen(skb);
|
|
|
|
/* Determine the position of this fragment. */
|
|
end = offset + skb->len - skb_network_offset(skb) - ihl;
|
|
err = -EINVAL;
|
|
|
|
/* Is this the final fragment? */
|
|
if ((flags & IP_MF) == 0) {
|
|
/* If we already have some bits beyond end
|
|
* or have different end, the segment is corrupted.
|
|
*/
|
|
if (end < qp->q.len ||
|
|
((qp->q.flags & INET_FRAG_LAST_IN) && end != qp->q.len))
|
|
goto err;
|
|
qp->q.flags |= INET_FRAG_LAST_IN;
|
|
qp->q.len = end;
|
|
} else {
|
|
if (end&7) {
|
|
end &= ~7;
|
|
if (skb->ip_summed != CHECKSUM_UNNECESSARY)
|
|
skb->ip_summed = CHECKSUM_NONE;
|
|
}
|
|
if (end > qp->q.len) {
|
|
/* Some bits beyond end -> corruption. */
|
|
if (qp->q.flags & INET_FRAG_LAST_IN)
|
|
goto err;
|
|
qp->q.len = end;
|
|
}
|
|
}
|
|
if (end == offset)
|
|
goto err;
|
|
|
|
err = -ENOMEM;
|
|
if (!pskb_pull(skb, skb_network_offset(skb) + ihl))
|
|
goto err;
|
|
|
|
err = pskb_trim_rcsum(skb, end - offset);
|
|
if (err)
|
|
goto err;
|
|
|
|
/* Find out which fragments are in front and at the back of us
|
|
* in the chain of fragments so far. We must know where to put
|
|
* this fragment, right?
|
|
*/
|
|
prev = qp->q.fragments_tail;
|
|
if (!prev || prev->ip_defrag_offset < offset) {
|
|
next = NULL;
|
|
goto found;
|
|
}
|
|
prev = NULL;
|
|
for (next = qp->q.fragments; next != NULL; next = next->next) {
|
|
if (next->ip_defrag_offset >= offset)
|
|
break; /* bingo! */
|
|
prev = next;
|
|
}
|
|
|
|
found:
|
|
/* We found where to put this one. Check for overlap with
|
|
* preceding fragment, and, if needed, align things so that
|
|
* any overlaps are eliminated.
|
|
*/
|
|
if (prev) {
|
|
int i = (prev->ip_defrag_offset + prev->len) - offset;
|
|
|
|
if (i > 0) {
|
|
offset += i;
|
|
err = -EINVAL;
|
|
if (end <= offset)
|
|
goto err;
|
|
err = -ENOMEM;
|
|
if (!pskb_pull(skb, i))
|
|
goto err;
|
|
if (skb->ip_summed != CHECKSUM_UNNECESSARY)
|
|
skb->ip_summed = CHECKSUM_NONE;
|
|
}
|
|
}
|
|
|
|
err = -ENOMEM;
|
|
|
|
while (next && next->ip_defrag_offset < end) {
|
|
int i = end - next->ip_defrag_offset; /* overlap is 'i' bytes */
|
|
|
|
if (i < next->len) {
|
|
int delta = -next->truesize;
|
|
|
|
/* Eat head of the next overlapped fragment
|
|
* and leave the loop. The next ones cannot overlap.
|
|
*/
|
|
if (!pskb_pull(next, i))
|
|
goto err;
|
|
delta += next->truesize;
|
|
if (delta)
|
|
add_frag_mem_limit(qp->q.net, delta);
|
|
next->ip_defrag_offset += i;
|
|
qp->q.meat -= i;
|
|
if (next->ip_summed != CHECKSUM_UNNECESSARY)
|
|
next->ip_summed = CHECKSUM_NONE;
|
|
break;
|
|
} else {
|
|
struct sk_buff *free_it = next;
|
|
|
|
/* Old fragment is completely overridden with
|
|
* new one drop it.
|
|
*/
|
|
next = next->next;
|
|
|
|
if (prev)
|
|
prev->next = next;
|
|
else
|
|
qp->q.fragments = next;
|
|
|
|
qp->q.meat -= free_it->len;
|
|
sub_frag_mem_limit(qp->q.net, free_it->truesize);
|
|
kfree_skb(free_it);
|
|
}
|
|
}
|
|
|
|
/* Note : skb->ip_defrag_offset and skb->dev share the same location */
|
|
dev = skb->dev;
|
|
if (dev)
|
|
qp->iif = dev->ifindex;
|
|
/* Makes sure compiler wont do silly aliasing games */
|
|
barrier();
|
|
skb->ip_defrag_offset = offset;
|
|
|
|
/* Insert this fragment in the chain of fragments. */
|
|
skb->next = next;
|
|
if (!next)
|
|
qp->q.fragments_tail = skb;
|
|
if (prev)
|
|
prev->next = skb;
|
|
else
|
|
qp->q.fragments = skb;
|
|
|
|
qp->q.stamp = skb->tstamp;
|
|
qp->q.meat += skb->len;
|
|
qp->ecn |= ecn;
|
|
add_frag_mem_limit(qp->q.net, skb->truesize);
|
|
if (offset == 0)
|
|
qp->q.flags |= INET_FRAG_FIRST_IN;
|
|
|
|
fragsize = skb->len + ihl;
|
|
|
|
if (fragsize > qp->q.max_size)
|
|
qp->q.max_size = fragsize;
|
|
|
|
if (ip_hdr(skb)->frag_off & htons(IP_DF) &&
|
|
fragsize > qp->max_df_size)
|
|
qp->max_df_size = fragsize;
|
|
|
|
if (qp->q.flags == (INET_FRAG_FIRST_IN | INET_FRAG_LAST_IN) &&
|
|
qp->q.meat == qp->q.len) {
|
|
unsigned long orefdst = skb->_skb_refdst;
|
|
|
|
skb->_skb_refdst = 0UL;
|
|
err = ip_frag_reasm(qp, prev, dev);
|
|
skb->_skb_refdst = orefdst;
|
|
return err;
|
|
}
|
|
|
|
skb_dst_drop(skb);
|
|
return -EINPROGRESS;
|
|
|
|
err:
|
|
kfree_skb(skb);
|
|
return err;
|
|
}
|
|
|
|
|
|
/* Build a new IP datagram from all its fragments. */
|
|
|
|
static int ip_frag_reasm(struct ipq *qp, struct sk_buff *prev,
|
|
struct net_device *dev)
|
|
{
|
|
struct net *net = container_of(qp->q.net, struct net, ipv4.frags);
|
|
struct iphdr *iph;
|
|
struct sk_buff *fp, *head = qp->q.fragments;
|
|
int len;
|
|
int ihlen;
|
|
int err;
|
|
u8 ecn;
|
|
|
|
ipq_kill(qp);
|
|
|
|
ecn = ip_frag_ecn_table[qp->ecn];
|
|
if (unlikely(ecn == 0xff)) {
|
|
err = -EINVAL;
|
|
goto out_fail;
|
|
}
|
|
/* Make the one we just received the head. */
|
|
if (prev) {
|
|
head = prev->next;
|
|
fp = skb_clone(head, GFP_ATOMIC);
|
|
if (!fp)
|
|
goto out_nomem;
|
|
|
|
fp->next = head->next;
|
|
if (!fp->next)
|
|
qp->q.fragments_tail = fp;
|
|
prev->next = fp;
|
|
|
|
skb_morph(head, qp->q.fragments);
|
|
head->next = qp->q.fragments->next;
|
|
|
|
consume_skb(qp->q.fragments);
|
|
qp->q.fragments = head;
|
|
}
|
|
|
|
WARN_ON(!head);
|
|
WARN_ON(head->ip_defrag_offset != 0);
|
|
|
|
/* Allocate a new buffer for the datagram. */
|
|
ihlen = ip_hdrlen(head);
|
|
len = ihlen + qp->q.len;
|
|
|
|
err = -E2BIG;
|
|
if (len > 65535)
|
|
goto out_oversize;
|
|
|
|
/* Head of list must not be cloned. */
|
|
if (skb_unclone(head, GFP_ATOMIC))
|
|
goto out_nomem;
|
|
|
|
/* If the first fragment is fragmented itself, we split
|
|
* it to two chunks: the first with data and paged part
|
|
* and the second, holding only fragments. */
|
|
if (skb_has_frag_list(head)) {
|
|
struct sk_buff *clone;
|
|
int i, plen = 0;
|
|
|
|
clone = alloc_skb(0, GFP_ATOMIC);
|
|
if (!clone)
|
|
goto out_nomem;
|
|
clone->next = head->next;
|
|
head->next = clone;
|
|
skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
|
|
skb_frag_list_init(head);
|
|
for (i = 0; i < skb_shinfo(head)->nr_frags; i++)
|
|
plen += skb_frag_size(&skb_shinfo(head)->frags[i]);
|
|
clone->len = clone->data_len = head->data_len - plen;
|
|
head->data_len -= clone->len;
|
|
head->len -= clone->len;
|
|
clone->csum = 0;
|
|
clone->ip_summed = head->ip_summed;
|
|
add_frag_mem_limit(qp->q.net, clone->truesize);
|
|
}
|
|
|
|
skb_shinfo(head)->frag_list = head->next;
|
|
skb_push(head, head->data - skb_network_header(head));
|
|
|
|
for (fp=head->next; fp; fp = fp->next) {
|
|
head->data_len += fp->len;
|
|
head->len += fp->len;
|
|
if (head->ip_summed != fp->ip_summed)
|
|
head->ip_summed = CHECKSUM_NONE;
|
|
else if (head->ip_summed == CHECKSUM_COMPLETE)
|
|
head->csum = csum_add(head->csum, fp->csum);
|
|
head->truesize += fp->truesize;
|
|
}
|
|
sub_frag_mem_limit(qp->q.net, head->truesize);
|
|
|
|
head->next = NULL;
|
|
head->dev = dev;
|
|
head->tstamp = qp->q.stamp;
|
|
IPCB(head)->frag_max_size = max(qp->max_df_size, qp->q.max_size);
|
|
|
|
iph = ip_hdr(head);
|
|
iph->tot_len = htons(len);
|
|
iph->tos |= ecn;
|
|
|
|
/* When we set IP_DF on a refragmented skb we must also force a
|
|
* call to ip_fragment to avoid forwarding a DF-skb of size s while
|
|
* original sender only sent fragments of size f (where f < s).
|
|
*
|
|
* We only set DF/IPSKB_FRAG_PMTU if such DF fragment was the largest
|
|
* frag seen to avoid sending tiny DF-fragments in case skb was built
|
|
* from one very small df-fragment and one large non-df frag.
|
|
*/
|
|
if (qp->max_df_size == qp->q.max_size) {
|
|
IPCB(head)->flags |= IPSKB_FRAG_PMTU;
|
|
iph->frag_off = htons(IP_DF);
|
|
} else {
|
|
iph->frag_off = 0;
|
|
}
|
|
|
|
ip_send_check(iph);
|
|
|
|
__IP_INC_STATS(net, IPSTATS_MIB_REASMOKS);
|
|
qp->q.fragments = NULL;
|
|
qp->q.fragments_tail = NULL;
|
|
return 0;
|
|
|
|
out_nomem:
|
|
net_dbg_ratelimited("queue_glue: no memory for gluing queue %p\n", qp);
|
|
err = -ENOMEM;
|
|
goto out_fail;
|
|
out_oversize:
|
|
net_info_ratelimited("Oversized IP packet from %pI4\n", &qp->q.key.v4.saddr);
|
|
out_fail:
|
|
__IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS);
|
|
return err;
|
|
}
|
|
|
|
/* Process an incoming IP datagram fragment. */
|
|
int ip_defrag(struct net *net, struct sk_buff *skb, u32 user)
|
|
{
|
|
struct net_device *dev = skb->dev ? : skb_dst(skb)->dev;
|
|
int vif = l3mdev_master_ifindex_rcu(dev);
|
|
struct ipq *qp;
|
|
|
|
__IP_INC_STATS(net, IPSTATS_MIB_REASMREQDS);
|
|
skb_orphan(skb);
|
|
|
|
/* Lookup (or create) queue header */
|
|
qp = ip_find(net, ip_hdr(skb), user, vif);
|
|
if (qp) {
|
|
int ret;
|
|
|
|
spin_lock(&qp->q.lock);
|
|
|
|
ret = ip_frag_queue(qp, skb);
|
|
|
|
spin_unlock(&qp->q.lock);
|
|
ipq_put(qp);
|
|
return ret;
|
|
}
|
|
|
|
__IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS);
|
|
kfree_skb(skb);
|
|
return -ENOMEM;
|
|
}
|
|
EXPORT_SYMBOL(ip_defrag);
|
|
|
|
struct sk_buff *ip_check_defrag(struct net *net, struct sk_buff *skb, u32 user)
|
|
{
|
|
struct iphdr iph;
|
|
int netoff;
|
|
u32 len;
|
|
|
|
if (skb->protocol != htons(ETH_P_IP))
|
|
return skb;
|
|
|
|
netoff = skb_network_offset(skb);
|
|
|
|
if (skb_copy_bits(skb, netoff, &iph, sizeof(iph)) < 0)
|
|
return skb;
|
|
|
|
if (iph.ihl < 5 || iph.version != 4)
|
|
return skb;
|
|
|
|
len = ntohs(iph.tot_len);
|
|
if (skb->len < netoff + len || len < (iph.ihl * 4))
|
|
return skb;
|
|
|
|
if (ip_is_fragment(&iph)) {
|
|
skb = skb_share_check(skb, GFP_ATOMIC);
|
|
if (skb) {
|
|
if (!pskb_may_pull(skb, netoff + iph.ihl * 4))
|
|
return skb;
|
|
if (pskb_trim_rcsum(skb, netoff + len))
|
|
return skb;
|
|
memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));
|
|
if (ip_defrag(net, skb, user))
|
|
return NULL;
|
|
skb_clear_hash(skb);
|
|
}
|
|
}
|
|
return skb;
|
|
}
|
|
EXPORT_SYMBOL(ip_check_defrag);
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
static int dist_min;
|
|
|
|
static struct ctl_table ip4_frags_ns_ctl_table[] = {
|
|
{
|
|
.procname = "ipfrag_high_thresh",
|
|
.data = &init_net.ipv4.frags.high_thresh,
|
|
.maxlen = sizeof(unsigned long),
|
|
.mode = 0644,
|
|
.proc_handler = proc_doulongvec_minmax,
|
|
.extra1 = &init_net.ipv4.frags.low_thresh
|
|
},
|
|
{
|
|
.procname = "ipfrag_low_thresh",
|
|
.data = &init_net.ipv4.frags.low_thresh,
|
|
.maxlen = sizeof(unsigned long),
|
|
.mode = 0644,
|
|
.proc_handler = proc_doulongvec_minmax,
|
|
.extra2 = &init_net.ipv4.frags.high_thresh
|
|
},
|
|
{
|
|
.procname = "ipfrag_time",
|
|
.data = &init_net.ipv4.frags.timeout,
|
|
.maxlen = sizeof(int),
|
|
.mode = 0644,
|
|
.proc_handler = proc_dointvec_jiffies,
|
|
},
|
|
{
|
|
.procname = "ipfrag_max_dist",
|
|
.data = &init_net.ipv4.frags.max_dist,
|
|
.maxlen = sizeof(int),
|
|
.mode = 0644,
|
|
.proc_handler = proc_dointvec_minmax,
|
|
.extra1 = &dist_min,
|
|
},
|
|
{ }
|
|
};
|
|
|
|
/* secret interval has been deprecated */
|
|
static int ip4_frags_secret_interval_unused;
|
|
static struct ctl_table ip4_frags_ctl_table[] = {
|
|
{
|
|
.procname = "ipfrag_secret_interval",
|
|
.data = &ip4_frags_secret_interval_unused,
|
|
.maxlen = sizeof(int),
|
|
.mode = 0644,
|
|
.proc_handler = proc_dointvec_jiffies,
|
|
},
|
|
{ }
|
|
};
|
|
|
|
static int __net_init ip4_frags_ns_ctl_register(struct net *net)
|
|
{
|
|
struct ctl_table *table;
|
|
struct ctl_table_header *hdr;
|
|
|
|
table = ip4_frags_ns_ctl_table;
|
|
if (!net_eq(net, &init_net)) {
|
|
table = kmemdup(table, sizeof(ip4_frags_ns_ctl_table), GFP_KERNEL);
|
|
if (!table)
|
|
goto err_alloc;
|
|
|
|
table[0].data = &net->ipv4.frags.high_thresh;
|
|
table[0].extra1 = &net->ipv4.frags.low_thresh;
|
|
table[0].extra2 = &init_net.ipv4.frags.high_thresh;
|
|
table[1].data = &net->ipv4.frags.low_thresh;
|
|
table[1].extra2 = &net->ipv4.frags.high_thresh;
|
|
table[2].data = &net->ipv4.frags.timeout;
|
|
table[3].data = &net->ipv4.frags.max_dist;
|
|
}
|
|
|
|
hdr = register_net_sysctl(net, "net/ipv4", table);
|
|
if (!hdr)
|
|
goto err_reg;
|
|
|
|
net->ipv4.frags_hdr = hdr;
|
|
return 0;
|
|
|
|
err_reg:
|
|
if (!net_eq(net, &init_net))
|
|
kfree(table);
|
|
err_alloc:
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static void __net_exit ip4_frags_ns_ctl_unregister(struct net *net)
|
|
{
|
|
struct ctl_table *table;
|
|
|
|
table = net->ipv4.frags_hdr->ctl_table_arg;
|
|
unregister_net_sysctl_table(net->ipv4.frags_hdr);
|
|
kfree(table);
|
|
}
|
|
|
|
static void __init ip4_frags_ctl_register(void)
|
|
{
|
|
register_net_sysctl(&init_net, "net/ipv4", ip4_frags_ctl_table);
|
|
}
|
|
#else
|
|
static int ip4_frags_ns_ctl_register(struct net *net)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void ip4_frags_ns_ctl_unregister(struct net *net)
|
|
{
|
|
}
|
|
|
|
static void __init ip4_frags_ctl_register(void)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
static int __net_init ipv4_frags_init_net(struct net *net)
|
|
{
|
|
int res;
|
|
|
|
/* Fragment cache limits.
|
|
*
|
|
* The fragment memory accounting code, (tries to) account for
|
|
* the real memory usage, by measuring both the size of frag
|
|
* queue struct (inet_frag_queue (ipv4:ipq/ipv6:frag_queue))
|
|
* and the SKB's truesize.
|
|
*
|
|
* A 64K fragment consumes 129736 bytes (44*2944)+200
|
|
* (1500 truesize == 2944, sizeof(struct ipq) == 200)
|
|
*
|
|
* We will commit 4MB at one time. Should we cross that limit
|
|
* we will prune down to 3MB, making room for approx 8 big 64K
|
|
* fragments 8x128k.
|
|
*/
|
|
net->ipv4.frags.high_thresh = 4 * 1024 * 1024;
|
|
net->ipv4.frags.low_thresh = 3 * 1024 * 1024;
|
|
/*
|
|
* Important NOTE! Fragment queue must be destroyed before MSL expires.
|
|
* RFC791 is wrong proposing to prolongate timer each fragment arrival
|
|
* by TTL.
|
|
*/
|
|
net->ipv4.frags.timeout = IP_FRAG_TIME;
|
|
|
|
net->ipv4.frags.max_dist = 64;
|
|
net->ipv4.frags.f = &ip4_frags;
|
|
|
|
res = inet_frags_init_net(&net->ipv4.frags);
|
|
if (res < 0)
|
|
return res;
|
|
res = ip4_frags_ns_ctl_register(net);
|
|
if (res < 0)
|
|
inet_frags_exit_net(&net->ipv4.frags);
|
|
return res;
|
|
}
|
|
|
|
static void __net_exit ipv4_frags_exit_net(struct net *net)
|
|
{
|
|
ip4_frags_ns_ctl_unregister(net);
|
|
inet_frags_exit_net(&net->ipv4.frags);
|
|
}
|
|
|
|
static struct pernet_operations ip4_frags_ops = {
|
|
.init = ipv4_frags_init_net,
|
|
.exit = ipv4_frags_exit_net,
|
|
};
|
|
|
|
|
|
static u32 ip4_key_hashfn(const void *data, u32 len, u32 seed)
|
|
{
|
|
return jhash2(data,
|
|
sizeof(struct frag_v4_compare_key) / sizeof(u32), seed);
|
|
}
|
|
|
|
static u32 ip4_obj_hashfn(const void *data, u32 len, u32 seed)
|
|
{
|
|
const struct inet_frag_queue *fq = data;
|
|
|
|
return jhash2((const u32 *)&fq->key.v4,
|
|
sizeof(struct frag_v4_compare_key) / sizeof(u32), seed);
|
|
}
|
|
|
|
static int ip4_obj_cmpfn(struct rhashtable_compare_arg *arg, const void *ptr)
|
|
{
|
|
const struct frag_v4_compare_key *key = arg->key;
|
|
const struct inet_frag_queue *fq = ptr;
|
|
|
|
return !!memcmp(&fq->key, key, sizeof(*key));
|
|
}
|
|
|
|
static const struct rhashtable_params ip4_rhash_params = {
|
|
.head_offset = offsetof(struct inet_frag_queue, node),
|
|
.key_offset = offsetof(struct inet_frag_queue, key),
|
|
.key_len = sizeof(struct frag_v4_compare_key),
|
|
.hashfn = ip4_key_hashfn,
|
|
.obj_hashfn = ip4_obj_hashfn,
|
|
.obj_cmpfn = ip4_obj_cmpfn,
|
|
.automatic_shrinking = true,
|
|
};
|
|
|
|
void __init ipfrag_init(void)
|
|
{
|
|
ip4_frags.constructor = ip4_frag_init;
|
|
ip4_frags.destructor = ip4_frag_free;
|
|
ip4_frags.qsize = sizeof(struct ipq);
|
|
ip4_frags.frag_expire = ip_expire;
|
|
ip4_frags.frags_cache_name = ip_frag_cache_name;
|
|
ip4_frags.rhash_params = ip4_rhash_params;
|
|
if (inet_frags_init(&ip4_frags))
|
|
panic("IP: failed to allocate ip4_frags cache\n");
|
|
ip4_frags_ctl_register();
|
|
register_pernet_subsys(&ip4_frags_ops);
|
|
}
|