2008-01-11 07:57:09 -07:00
|
|
|
/* SCTP kernel implementation
|
2005-04-16 16:20:36 -06:00
|
|
|
* Copyright (c) 1999-2000 Cisco, Inc.
|
|
|
|
* Copyright (c) 1999-2001 Motorola, Inc.
|
|
|
|
* Copyright (c) 2001-2003 International Business Machines, Corp.
|
|
|
|
* Copyright (c) 2001 Intel Corp.
|
|
|
|
* Copyright (c) 2001 Nokia, Inc.
|
|
|
|
* Copyright (c) 2001 La Monte H.P. Yarroll
|
|
|
|
*
|
2008-01-11 07:57:09 -07:00
|
|
|
* This file is part of the SCTP kernel implementation
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* These functions handle all input from the IP layer into SCTP.
|
|
|
|
*
|
2008-01-11 07:57:09 -07:00
|
|
|
* This SCTP implementation is free software;
|
2005-04-16 16:20:36 -06:00
|
|
|
* you can redistribute it and/or modify it under the terms of
|
|
|
|
* the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
* any later version.
|
|
|
|
*
|
2008-01-11 07:57:09 -07:00
|
|
|
* This SCTP implementation is distributed in the hope that it
|
2005-04-16 16:20:36 -06:00
|
|
|
* will be useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
|
|
* ************************
|
|
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
* See the GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with GNU CC; see the file COPYING. If not, write to
|
|
|
|
* the Free Software Foundation, 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 02111-1307, USA.
|
|
|
|
*
|
|
|
|
* Please send any bug reports or fixes you make to the
|
|
|
|
* email address(es):
|
2013-07-23 06:51:47 -06:00
|
|
|
* lksctp developers <linux-sctp@vger.kernel.org>
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Written or modified by:
|
|
|
|
* La Monte H.P. Yarroll <piggy@acm.org>
|
|
|
|
* Karl Knutson <karl@athena.chicago.il.us>
|
|
|
|
* Xingang Guo <xingang.guo@intel.com>
|
|
|
|
* Jon Grimm <jgrimm@us.ibm.com>
|
|
|
|
* Hui Huang <hui.huang@nokia.com>
|
|
|
|
* Daisy Chang <daisyc@us.ibm.com>
|
|
|
|
* Sridhar Samudrala <sri@us.ibm.com>
|
|
|
|
* Ardelle Fan <ardelle.fan@intel.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/list.h> /* For struct list_head */
|
|
|
|
#include <linux/socket.h>
|
|
|
|
#include <linux/ip.h>
|
|
|
|
#include <linux/time.h> /* For struct timeval */
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/ip.h>
|
|
|
|
#include <net/icmp.h>
|
|
|
|
#include <net/snmp.h>
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/xfrm.h>
|
|
|
|
#include <net/sctp/sctp.h>
|
|
|
|
#include <net/sctp/sm.h>
|
2007-12-16 15:06:41 -07:00
|
|
|
#include <net/sctp/checksum.h>
|
2008-07-15 00:03:00 -06:00
|
|
|
#include <net/net_namespace.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Forward declarations for internal helpers. */
|
|
|
|
static int sctp_rcv_ootb(struct sk_buff *);
|
2012-08-06 02:41:13 -06:00
|
|
|
static struct sctp_association *__sctp_rcv_lookup(struct net *net,
|
|
|
|
struct sk_buff *skb,
|
2005-04-16 16:20:36 -06:00
|
|
|
const union sctp_addr *paddr,
|
2012-10-02 23:43:21 -06:00
|
|
|
const union sctp_addr *laddr,
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_transport **transportp);
|
2012-08-06 02:40:21 -06:00
|
|
|
static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(struct net *net,
|
|
|
|
const union sctp_addr *laddr);
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct sctp_association *__sctp_lookup_association(
|
2012-08-06 02:41:13 -06:00
|
|
|
struct net *net,
|
2005-04-16 16:20:36 -06:00
|
|
|
const union sctp_addr *local,
|
|
|
|
const union sctp_addr *peer,
|
|
|
|
struct sctp_transport **pt);
|
|
|
|
|
2010-03-04 11:01:44 -07:00
|
|
|
static int sctp_add_backlog(struct sock *sk, struct sk_buff *skb);
|
2006-05-19 12:01:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Calculate the SCTP checksum of an SCTP packet. */
|
2012-08-06 02:47:55 -06:00
|
|
|
static inline int sctp_rcv_checksum(struct net *net, struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-03-13 10:59:32 -06:00
|
|
|
struct sctphdr *sh = sctp_hdr(skb);
|
2009-02-13 01:33:42 -07:00
|
|
|
__le32 cmp = sh->checksum;
|
2013-07-24 19:52:05 -06:00
|
|
|
__le32 val = sctp_compute_cksum(skb, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (val != cmp) {
|
|
|
|
/* CRC failure, dump it. */
|
2012-08-06 02:47:55 -06:00
|
|
|
SCTP_INC_STATS_BH(net, SCTP_MIB_CHECKSUMERRORS);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-07-08 22:47:49 -06:00
|
|
|
struct sctp_input_cb {
|
|
|
|
union {
|
|
|
|
struct inet_skb_parm h4;
|
2011-12-10 02:48:31 -07:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2005-07-08 22:47:49 -06:00
|
|
|
struct inet6_skb_parm h6;
|
|
|
|
#endif
|
|
|
|
} header;
|
|
|
|
struct sctp_chunk *chunk;
|
|
|
|
};
|
|
|
|
#define SCTP_INPUT_CB(__skb) ((struct sctp_input_cb *)&((__skb)->cb[0]))
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* This is the routine which IP calls when receiving an SCTP packet.
|
|
|
|
*/
|
|
|
|
int sctp_rcv(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct sock *sk;
|
|
|
|
struct sctp_association *asoc;
|
|
|
|
struct sctp_endpoint *ep = NULL;
|
|
|
|
struct sctp_ep_common *rcvr;
|
|
|
|
struct sctp_transport *transport = NULL;
|
|
|
|
struct sctp_chunk *chunk;
|
|
|
|
struct sctphdr *sh;
|
|
|
|
union sctp_addr src;
|
|
|
|
union sctp_addr dest;
|
|
|
|
int family;
|
|
|
|
struct sctp_af *af;
|
2012-08-06 02:40:21 -06:00
|
|
|
struct net *net = dev_net(skb->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (skb->pkt_type!=PACKET_HOST)
|
|
|
|
goto discard_it;
|
|
|
|
|
2012-08-06 02:47:55 -06:00
|
|
|
SCTP_INC_STATS_BH(net, SCTP_MIB_INSCTPPACKS);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-10-30 00:46:42 -07:00
|
|
|
if (skb_linearize(skb))
|
|
|
|
goto discard_it;
|
|
|
|
|
2007-03-13 10:59:32 -06:00
|
|
|
sh = sctp_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Pull up the IP and SCTP headers. */
|
2007-04-25 18:55:53 -06:00
|
|
|
__skb_pull(skb, skb_transport_offset(skb));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (skb->len < sizeof(struct sctphdr))
|
|
|
|
goto discard_it;
|
2013-08-09 14:09:41 -06:00
|
|
|
if (!sctp_checksum_disable && !skb_csum_unnecessary(skb) &&
|
|
|
|
sctp_rcv_checksum(net, skb) < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto discard_it;
|
|
|
|
|
|
|
|
skb_pull(skb, sizeof(struct sctphdr));
|
|
|
|
|
|
|
|
/* Make sure we at least have chunk headers worth of data left. */
|
|
|
|
if (skb->len < sizeof(struct sctp_chunkhdr))
|
|
|
|
goto discard_it;
|
|
|
|
|
2007-04-20 23:47:35 -06:00
|
|
|
family = ipver2af(ip_hdr(skb)->version);
|
2005-04-16 16:20:36 -06:00
|
|
|
af = sctp_get_af_specific(family);
|
|
|
|
if (unlikely(!af))
|
|
|
|
goto discard_it;
|
|
|
|
|
|
|
|
/* Initialize local addresses for lookups. */
|
|
|
|
af->from_skb(&src, skb, 1);
|
|
|
|
af->from_skb(&dest, skb, 0);
|
|
|
|
|
|
|
|
/* If the packet is to or from a non-unicast address,
|
|
|
|
* silently discard the packet.
|
|
|
|
*
|
|
|
|
* This is not clearly defined in the RFC except in section
|
|
|
|
* 8.4 - OOTB handling. However, based on the book "Stream Control
|
|
|
|
* Transmission Protocol" 2.1, "It is important to note that the
|
|
|
|
* IP address of an SCTP transport address must be a routable
|
|
|
|
* unicast address. In other words, IP multicast addresses and
|
|
|
|
* IP broadcast addresses cannot be used in an SCTP transport
|
|
|
|
* address."
|
|
|
|
*/
|
2006-06-17 23:55:35 -06:00
|
|
|
if (!af->addr_valid(&src, NULL, skb) ||
|
|
|
|
!af->addr_valid(&dest, NULL, skb))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto discard_it;
|
|
|
|
|
2012-08-06 02:41:13 -06:00
|
|
|
asoc = __sctp_rcv_lookup(net, skb, &src, &dest, &transport);
|
2006-11-20 18:08:09 -07:00
|
|
|
|
2005-06-13 16:11:24 -06:00
|
|
|
if (!asoc)
|
2012-08-06 02:40:21 -06:00
|
|
|
ep = __sctp_rcv_lookup_endpoint(net, &dest);
|
2005-06-13 16:11:24 -06:00
|
|
|
|
|
|
|
/* Retrieve the common input handling substructure. */
|
|
|
|
rcvr = asoc ? &asoc->base : &ep->base;
|
|
|
|
sk = rcvr->sk;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a frame arrives on an interface and the receiving socket is
|
|
|
|
* bound to another interface, via SO_BINDTODEVICE, treat it as OOTB
|
|
|
|
*/
|
|
|
|
if (sk->sk_bound_dev_if && (sk->sk_bound_dev_if != af->skb_iif(skb)))
|
|
|
|
{
|
|
|
|
if (asoc) {
|
|
|
|
sctp_association_put(asoc);
|
|
|
|
asoc = NULL;
|
|
|
|
} else {
|
|
|
|
sctp_endpoint_put(ep);
|
|
|
|
ep = NULL;
|
|
|
|
}
|
2012-08-06 02:43:06 -06:00
|
|
|
sk = net->sctp.ctl_sock;
|
2005-06-13 16:11:24 -06:00
|
|
|
ep = sctp_sk(sk)->ep;
|
|
|
|
sctp_endpoint_hold(ep);
|
|
|
|
rcvr = &ep->base;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* RFC 2960, 8.4 - Handle "Out of the blue" Packets.
|
|
|
|
* An SCTP packet is called an "out of the blue" (OOTB)
|
|
|
|
* packet if it is correctly formed, i.e., passed the
|
|
|
|
* receiver's checksum check, but the receiver is not
|
|
|
|
* able to identify the association to which this
|
|
|
|
* packet belongs.
|
|
|
|
*/
|
|
|
|
if (!asoc) {
|
|
|
|
if (sctp_rcv_ootb(skb)) {
|
2012-08-06 02:47:55 -06:00
|
|
|
SCTP_INC_STATS_BH(net, SCTP_MIB_OUTOFBLUES);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto discard_release;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!xfrm_policy_check(sk, XFRM_POLICY_IN, skb, family))
|
|
|
|
goto discard_release;
|
2006-01-07 00:06:10 -07:00
|
|
|
nf_reset(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-31 16:28:39 -06:00
|
|
|
if (sk_filter(sk, skb))
|
2007-02-09 07:25:18 -07:00
|
|
|
goto discard_release;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Create an SCTP packet structure. */
|
|
|
|
chunk = sctp_chunkify(skb, asoc, sk);
|
2006-03-25 02:25:29 -07:00
|
|
|
if (!chunk)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto discard_release;
|
2005-07-08 22:47:49 -06:00
|
|
|
SCTP_INPUT_CB(skb)->chunk = chunk;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Remember what endpoint is to handle this packet. */
|
|
|
|
chunk->rcvr = rcvr;
|
|
|
|
|
|
|
|
/* Remember the SCTP header. */
|
|
|
|
chunk->sctp_hdr = sh;
|
|
|
|
|
|
|
|
/* Set the source and destination addresses of the incoming chunk. */
|
2006-11-20 18:09:40 -07:00
|
|
|
sctp_init_addrs(chunk, &src, &dest);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Remember where we came from. */
|
|
|
|
chunk->transport = transport;
|
|
|
|
|
|
|
|
/* Acquire access to the sock lock. Note: We are safe from other
|
|
|
|
* bottom halves on this lock, but a user may be in the lock too,
|
|
|
|
* so check if it is busy.
|
|
|
|
*/
|
|
|
|
sctp_bh_lock_sock(sk);
|
|
|
|
|
2009-01-22 15:53:23 -07:00
|
|
|
if (sk != rcvr->sk) {
|
|
|
|
/* Our cached sk is different from the rcvr->sk. This is
|
|
|
|
* because migrate()/accept() may have moved the association
|
|
|
|
* to a new socket and released all the sockets. So now we
|
|
|
|
* are holding a lock on the old socket while the user may
|
|
|
|
* be doing something with the new socket. Switch our veiw
|
|
|
|
* of the current sk.
|
|
|
|
*/
|
|
|
|
sctp_bh_unlock_sock(sk);
|
|
|
|
sk = rcvr->sk;
|
|
|
|
sctp_bh_lock_sock(sk);
|
|
|
|
}
|
|
|
|
|
2006-08-22 01:15:33 -06:00
|
|
|
if (sock_owned_by_user(sk)) {
|
2010-03-04 11:01:44 -07:00
|
|
|
if (sctp_add_backlog(sk, skb)) {
|
|
|
|
sctp_bh_unlock_sock(sk);
|
|
|
|
sctp_chunk_free(chunk);
|
|
|
|
skb = NULL; /* sctp_chunk_free already freed the skb */
|
|
|
|
goto discard_release;
|
|
|
|
}
|
2012-08-06 02:47:55 -06:00
|
|
|
SCTP_INC_STATS_BH(net, SCTP_MIB_IN_PKT_BACKLOG);
|
2006-08-22 01:15:33 -06:00
|
|
|
} else {
|
2012-08-06 02:47:55 -06:00
|
|
|
SCTP_INC_STATS_BH(net, SCTP_MIB_IN_PKT_SOFTIRQ);
|
2006-05-19 12:01:18 -06:00
|
|
|
sctp_inq_push(&chunk->rcvr->inqueue, chunk);
|
2006-08-22 01:15:33 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
sctp_bh_unlock_sock(sk);
|
2006-05-19 12:01:18 -06:00
|
|
|
|
|
|
|
/* Release the asoc/ep ref we took in the lookup calls. */
|
|
|
|
if (asoc)
|
|
|
|
sctp_association_put(asoc);
|
|
|
|
else
|
|
|
|
sctp_endpoint_put(ep);
|
2006-01-17 12:51:28 -07:00
|
|
|
|
2006-03-25 02:25:29 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
discard_it:
|
2012-08-06 02:47:55 -06:00
|
|
|
SCTP_INC_STATS_BH(net, SCTP_MIB_IN_PKT_DISCARDS);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree_skb(skb);
|
2006-03-25 02:25:29 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
discard_release:
|
2006-05-19 12:01:18 -06:00
|
|
|
/* Release the asoc/ep ref we took in the lookup calls. */
|
2005-06-13 16:11:24 -06:00
|
|
|
if (asoc)
|
2005-04-16 16:20:36 -06:00
|
|
|
sctp_association_put(asoc);
|
2005-06-13 16:11:24 -06:00
|
|
|
else
|
2005-04-16 16:20:36 -06:00
|
|
|
sctp_endpoint_put(ep);
|
|
|
|
|
|
|
|
goto discard_it;
|
|
|
|
}
|
|
|
|
|
2006-05-19 12:01:18 -06:00
|
|
|
/* Process the backlog queue of the socket. Every skb on
|
|
|
|
* the backlog holds a ref on an association or endpoint.
|
|
|
|
* We hold this ref throughout the state machine to make
|
|
|
|
* sure that the structure we need is still around.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb)
|
|
|
|
{
|
2005-07-08 22:47:49 -06:00
|
|
|
struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
|
2007-02-09 07:25:18 -07:00
|
|
|
struct sctp_inq *inqueue = &chunk->rcvr->inqueue;
|
|
|
|
struct sctp_ep_common *rcvr = NULL;
|
2006-05-19 12:01:18 -06:00
|
|
|
int backloged = 0;
|
2006-01-17 12:51:28 -07:00
|
|
|
|
2007-02-09 07:25:18 -07:00
|
|
|
rcvr = chunk->rcvr;
|
2006-01-17 12:56:26 -07:00
|
|
|
|
2006-05-19 12:01:18 -06:00
|
|
|
/* If the rcvr is dead then the association or endpoint
|
|
|
|
* has been deleted and we can safely drop the chunk
|
|
|
|
* and refs that we are holding.
|
|
|
|
*/
|
|
|
|
if (rcvr->dead) {
|
|
|
|
sctp_chunk_free(chunk);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(rcvr->sk != sk)) {
|
|
|
|
/* In this case, the association moved from one socket to
|
|
|
|
* another. We are currently sitting on the backlog of the
|
|
|
|
* old socket, so we need to move.
|
|
|
|
* However, since we are here in the process context we
|
|
|
|
* need to take make sure that the user doesn't own
|
|
|
|
* the new socket when we process the packet.
|
|
|
|
* If the new socket is user-owned, queue the chunk to the
|
|
|
|
* backlog of the new socket without dropping any refs.
|
|
|
|
* Otherwise, we can safely push the chunk on the inqueue.
|
|
|
|
*/
|
|
|
|
|
|
|
|
sk = rcvr->sk;
|
|
|
|
sctp_bh_lock_sock(sk);
|
|
|
|
|
|
|
|
if (sock_owned_by_user(sk)) {
|
2012-04-22 17:34:26 -06:00
|
|
|
if (sk_add_backlog(sk, skb, sk->sk_rcvbuf))
|
2010-03-04 11:01:44 -07:00
|
|
|
sctp_chunk_free(chunk);
|
|
|
|
else
|
|
|
|
backloged = 1;
|
2006-05-19 12:01:18 -06:00
|
|
|
} else
|
|
|
|
sctp_inq_push(inqueue, chunk);
|
|
|
|
|
|
|
|
sctp_bh_unlock_sock(sk);
|
|
|
|
|
|
|
|
/* If the chunk was backloged again, don't drop refs */
|
|
|
|
if (backloged)
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
sctp_inq_push(inqueue, chunk);
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
/* Release the refs we took in sctp_add_backlog */
|
|
|
|
if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)
|
|
|
|
sctp_association_put(sctp_assoc(rcvr));
|
|
|
|
else if (SCTP_EP_TYPE_SOCKET == rcvr->type)
|
|
|
|
sctp_endpoint_put(sctp_ep(rcvr));
|
|
|
|
else
|
|
|
|
BUG();
|
|
|
|
|
2007-02-09 07:25:18 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-03-04 11:01:44 -07:00
|
|
|
static int sctp_add_backlog(struct sock *sk, struct sk_buff *skb)
|
2006-01-17 12:56:26 -07:00
|
|
|
{
|
2006-05-19 12:01:18 -06:00
|
|
|
struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
|
|
|
|
struct sctp_ep_common *rcvr = chunk->rcvr;
|
2010-03-04 11:01:44 -07:00
|
|
|
int ret;
|
2006-01-17 12:56:26 -07:00
|
|
|
|
2012-04-22 17:34:26 -06:00
|
|
|
ret = sk_add_backlog(sk, skb, sk->sk_rcvbuf);
|
2010-03-04 11:01:44 -07:00
|
|
|
if (!ret) {
|
|
|
|
/* Hold the assoc/ep while hanging on the backlog queue.
|
|
|
|
* This way, we know structures we need will not disappear
|
|
|
|
* from us
|
|
|
|
*/
|
|
|
|
if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)
|
|
|
|
sctp_association_hold(sctp_assoc(rcvr));
|
|
|
|
else if (SCTP_EP_TYPE_SOCKET == rcvr->type)
|
|
|
|
sctp_endpoint_hold(sctp_ep(rcvr));
|
|
|
|
else
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
return ret;
|
2006-05-19 12:01:18 -06:00
|
|
|
|
2006-01-17 12:56:26 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Handle icmp frag needed error. */
|
|
|
|
void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc,
|
|
|
|
struct sctp_transport *t, __u32 pmtu)
|
|
|
|
{
|
2008-10-23 01:59:52 -06:00
|
|
|
if (!t || (t->pathmtu <= pmtu))
|
2005-12-22 12:36:46 -07:00
|
|
|
return;
|
|
|
|
|
2007-06-07 12:21:05 -06:00
|
|
|
if (sock_owned_by_user(sk)) {
|
|
|
|
asoc->pmtu_pending = 1;
|
|
|
|
t->pmtu_pending = 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-12-22 12:36:46 -07:00
|
|
|
if (t->param_flags & SPP_PMTUD_ENABLE) {
|
2007-06-07 11:47:03 -06:00
|
|
|
/* Update transports view of the MTU */
|
2012-07-16 04:57:14 -06:00
|
|
|
sctp_transport_update_pmtu(sk, t, pmtu);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-12-22 12:36:46 -07:00
|
|
|
/* Update association pmtu. */
|
2012-07-16 04:57:14 -06:00
|
|
|
sctp_assoc_sync_pmtu(sk, asoc);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-12-22 12:36:46 -07:00
|
|
|
|
|
|
|
/* Retransmit with the new pmtu setting.
|
|
|
|
* Normally, if PMTU discovery is disabled, an ICMP Fragmentation
|
|
|
|
* Needed will never be sent, but if a message was sent before
|
|
|
|
* PMTU discovery was disabled that was larger than the PMTU, it
|
2007-02-09 07:25:18 -07:00
|
|
|
* would not be fragmented, so it must be re-transmitted fragmented.
|
2005-12-22 12:36:46 -07:00
|
|
|
*/
|
|
|
|
sctp_retransmit(&asoc->outqueue, t, SCTP_RTXR_PMTUD);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-07-12 01:25:15 -06:00
|
|
|
void sctp_icmp_redirect(struct sock *sk, struct sctp_transport *t,
|
|
|
|
struct sk_buff *skb)
|
2012-07-11 22:27:49 -06:00
|
|
|
{
|
|
|
|
struct dst_entry *dst;
|
|
|
|
|
|
|
|
if (!t)
|
|
|
|
return;
|
|
|
|
dst = sctp_transport_dst_check(t);
|
2012-07-12 01:41:25 -06:00
|
|
|
if (dst)
|
2012-07-17 04:29:28 -06:00
|
|
|
dst->ops->redirect(dst, sk, skb);
|
2012-07-11 22:27:49 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* SCTP Implementer's Guide, 2.37 ICMP handling procedures
|
|
|
|
*
|
|
|
|
* ICMP8) If the ICMP code is a "Unrecognized next header type encountered"
|
|
|
|
* or a "Protocol Unreachable" treat this message as an abort
|
|
|
|
* with the T bit set.
|
|
|
|
*
|
|
|
|
* This function sends an event to the state machine, which will abort the
|
|
|
|
* association.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void sctp_icmp_proto_unreachable(struct sock *sk,
|
2007-02-09 07:25:18 -07:00
|
|
|
struct sctp_association *asoc,
|
|
|
|
struct sctp_transport *t)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-05-06 01:56:07 -06:00
|
|
|
if (sock_owned_by_user(sk)) {
|
|
|
|
if (timer_pending(&t->proto_unreach_timer))
|
|
|
|
return;
|
|
|
|
else {
|
|
|
|
if (!mod_timer(&t->proto_unreach_timer,
|
|
|
|
jiffies + (HZ/20)))
|
|
|
|
sctp_association_hold(asoc);
|
|
|
|
}
|
|
|
|
} else {
|
2012-08-07 01:25:24 -06:00
|
|
|
struct net *net = sock_net(sk);
|
|
|
|
|
net: sctp: rework debugging framework to use pr_debug and friends
We should get rid of all own SCTP debug printk macros and use the ones
that the kernel offers anyway instead. This makes the code more readable
and conform to the kernel code, and offers all the features of dynamic
debbuging that pr_debug() et al has, such as only turning on/off portions
of debug messages at runtime through debugfs. The runtime cost of having
CONFIG_DYNAMIC_DEBUG enabled, but none of the debug statements printing,
is negligible [1]. If kernel debugging is completly turned off, then these
statements will also compile into "empty" functions.
While we're at it, we also need to change the Kconfig option as it /now/
only refers to the ifdef'ed code portions in outqueue.c that enable further
debugging/tracing of SCTP transaction fields. Also, since SCTP_ASSERT code
was enabled with this Kconfig option and has now been removed, we
transform those code parts into WARNs resp. where appropriate BUG_ONs so
that those bugs can be more easily detected as probably not many people
have SCTP debugging permanently turned on.
To turn on all SCTP debugging, the following steps are needed:
# mount -t debugfs none /sys/kernel/debug
# echo -n 'module sctp +p' > /sys/kernel/debug/dynamic_debug/control
This can be done more fine-grained on a per file, per line basis and others
as described in [2].
[1] https://www.kernel.org/doc/ols/2009/ols2009-pages-39-46.pdf
[2] Documentation/dynamic-debug-howto.txt
Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-06-28 11:49:40 -06:00
|
|
|
pr_debug("%s: unrecognized next header type "
|
|
|
|
"encountered!\n", __func__);
|
|
|
|
|
2013-02-03 13:32:57 -07:00
|
|
|
if (del_timer(&t->proto_unreach_timer))
|
2010-05-06 01:56:07 -06:00
|
|
|
sctp_association_put(asoc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-07 01:25:24 -06:00
|
|
|
sctp_do_sm(net, SCTP_EVENT_T_OTHER,
|
2010-05-06 01:56:07 -06:00
|
|
|
SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),
|
|
|
|
asoc->state, asoc->ep, asoc, t,
|
|
|
|
GFP_ATOMIC);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Common lookup code for icmp/icmpv6 error handler. */
|
2012-08-06 02:41:13 -06:00
|
|
|
struct sock *sctp_err_lookup(struct net *net, int family, struct sk_buff *skb,
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctphdr *sctphdr,
|
|
|
|
struct sctp_association **app,
|
|
|
|
struct sctp_transport **tpp)
|
|
|
|
{
|
|
|
|
union sctp_addr saddr;
|
|
|
|
union sctp_addr daddr;
|
|
|
|
struct sctp_af *af;
|
|
|
|
struct sock *sk = NULL;
|
2006-05-19 11:58:12 -06:00
|
|
|
struct sctp_association *asoc;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_transport *transport = NULL;
|
2008-06-19 17:07:48 -06:00
|
|
|
struct sctp_init_chunk *chunkhdr;
|
|
|
|
__u32 vtag = ntohl(sctphdr->vtag);
|
|
|
|
int len = skb->len - ((void *)sctphdr - (void *)skb->data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-18 14:44:10 -06:00
|
|
|
*app = NULL; *tpp = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
af = sctp_get_af_specific(family);
|
|
|
|
if (unlikely(!af)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize local addresses for lookups. */
|
|
|
|
af->from_skb(&saddr, skb, 1);
|
|
|
|
af->from_skb(&daddr, skb, 0);
|
|
|
|
|
|
|
|
/* Look for an association that matches the incoming ICMP error
|
|
|
|
* packet.
|
|
|
|
*/
|
2012-08-06 02:41:13 -06:00
|
|
|
asoc = __sctp_lookup_association(net, &saddr, &daddr, &transport);
|
2005-07-18 14:44:10 -06:00
|
|
|
if (!asoc)
|
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-18 14:44:10 -06:00
|
|
|
sk = asoc->base.sk;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-06-19 17:07:48 -06:00
|
|
|
/* RFC 4960, Appendix C. ICMP Handling
|
|
|
|
*
|
|
|
|
* ICMP6) An implementation MUST validate that the Verification Tag
|
|
|
|
* contained in the ICMP message matches the Verification Tag of
|
|
|
|
* the peer. If the Verification Tag is not 0 and does NOT
|
|
|
|
* match, discard the ICMP message. If it is 0 and the ICMP
|
|
|
|
* message contains enough bytes to verify that the chunk type is
|
|
|
|
* an INIT chunk and that the Initiate Tag matches the tag of the
|
|
|
|
* peer, continue with ICMP7. If the ICMP message is too short
|
|
|
|
* or the chunk type or the Initiate Tag does not match, silently
|
|
|
|
* discard the packet.
|
|
|
|
*/
|
|
|
|
if (vtag == 0) {
|
2011-06-13 10:21:26 -06:00
|
|
|
chunkhdr = (void *)sctphdr + sizeof(struct sctphdr);
|
2008-06-19 17:07:48 -06:00
|
|
|
if (len < sizeof(struct sctphdr) + sizeof(sctp_chunkhdr_t)
|
|
|
|
+ sizeof(__be32) ||
|
|
|
|
chunkhdr->chunk_hdr.type != SCTP_CID_INIT ||
|
|
|
|
ntohl(chunkhdr->init_hdr.init_tag) != asoc->c.my_vtag) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else if (vtag != asoc->c.peer_vtag) {
|
2005-07-18 14:44:10 -06:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
sctp_bh_lock_sock(sk);
|
|
|
|
|
|
|
|
/* If too many ICMPs get dropped on busy
|
|
|
|
* servers this needs to be solved differently.
|
|
|
|
*/
|
|
|
|
if (sock_owned_by_user(sk))
|
2012-08-06 02:47:55 -06:00
|
|
|
NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
*app = asoc;
|
|
|
|
*tpp = transport;
|
|
|
|
return sk;
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (asoc)
|
|
|
|
sctp_association_put(asoc);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Common cleanup code for icmp/icmpv6 error handler. */
|
2005-07-18 14:44:10 -06:00
|
|
|
void sctp_err_finish(struct sock *sk, struct sctp_association *asoc)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
sctp_bh_unlock_sock(sk);
|
|
|
|
if (asoc)
|
|
|
|
sctp_association_put(asoc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called by the ICMP module when it gets some
|
|
|
|
* sort of error condition. If err < 0 then the socket should
|
|
|
|
* be closed and the error returned to the user. If err > 0
|
|
|
|
* it's just the icmp type << 8 | icmp code. After adjustment
|
|
|
|
* header points to the first 8 bytes of the sctp header. We need
|
|
|
|
* to find the appropriate port.
|
|
|
|
*
|
|
|
|
* The locking strategy used here is very "optimistic". When
|
|
|
|
* someone else accesses the socket the ICMP is just dropped
|
|
|
|
* and for some paths there is no check at all.
|
|
|
|
* A more general error queue to queue errors for later handling
|
|
|
|
* is probably better.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void sctp_v4_err(struct sk_buff *skb, __u32 info)
|
|
|
|
{
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct iphdr *iph = (const struct iphdr *)skb->data;
|
2007-03-13 14:17:10 -06:00
|
|
|
const int ihlen = iph->ihl * 4;
|
2007-03-13 11:43:18 -06:00
|
|
|
const int type = icmp_hdr(skb)->type;
|
|
|
|
const int code = icmp_hdr(skb)->code;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sock *sk;
|
2006-05-19 11:58:12 -06:00
|
|
|
struct sctp_association *asoc = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_transport *transport;
|
|
|
|
struct inet_sock *inet;
|
2013-05-30 14:36:11 -06:00
|
|
|
__u16 saveip, savesctp;
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
2012-08-06 02:41:13 -06:00
|
|
|
struct net *net = dev_net(skb->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-13 14:17:10 -06:00
|
|
|
if (skb->len < ihlen + 8) {
|
2012-08-06 02:47:55 -06:00
|
|
|
ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fix up skb to look at the embedded net header. */
|
2007-04-10 22:21:55 -06:00
|
|
|
saveip = skb->network_header;
|
|
|
|
savesctp = skb->transport_header;
|
2007-03-10 15:04:55 -07:00
|
|
|
skb_reset_network_header(skb);
|
2007-03-13 14:17:10 -06:00
|
|
|
skb_set_transport_header(skb, ihlen);
|
2012-08-06 02:41:13 -06:00
|
|
|
sk = sctp_err_lookup(net, AF_INET, skb, sctp_hdr(skb), &asoc, &transport);
|
[SK_BUFF]: Use offsets for skb->{mac,network,transport}_header on 64bit architectures
With this we save 8 bytes per network packet, leaving a 4 bytes hole to be used
in further shrinking work, likely with the offsetization of other pointers,
such as ->{data,tail,end}, at the cost of adds, that were minimized by the
usual practice of setting skb->{mac,nh,n}.raw to a local variable that is then
accessed multiple times in each function, it also is not more expensive than
before with regards to most of the handling of such headers, like setting one
of these headers to another (transport to network, etc), or subtracting, adding
to/from it, comparing them, etc.
Now we have this layout for sk_buff on a x86_64 machine:
[acme@mica net-2.6.22]$ pahole vmlinux sk_buff
struct sk_buff {
struct sk_buff * next; /* 0 8 */
struct sk_buff * prev; /* 8 8 */
struct rb_node rb; /* 16 24 */
struct sock * sk; /* 40 8 */
ktime_t tstamp; /* 48 8 */
struct net_device * dev; /* 56 8 */
/* --- cacheline 1 boundary (64 bytes) --- */
struct net_device * input_dev; /* 64 8 */
sk_buff_data_t transport_header; /* 72 4 */
sk_buff_data_t network_header; /* 76 4 */
sk_buff_data_t mac_header; /* 80 4 */
/* XXX 4 bytes hole, try to pack */
struct dst_entry * dst; /* 88 8 */
struct sec_path * sp; /* 96 8 */
char cb[48]; /* 104 48 */
/* cacheline 2 boundary (128 bytes) was 24 bytes ago*/
unsigned int len; /* 152 4 */
unsigned int data_len; /* 156 4 */
unsigned int mac_len; /* 160 4 */
union {
__wsum csum; /* 4 */
__u32 csum_offset; /* 4 */
}; /* 164 4 */
__u32 priority; /* 168 4 */
__u8 local_df:1; /* 172 1 */
__u8 cloned:1; /* 172 1 */
__u8 ip_summed:2; /* 172 1 */
__u8 nohdr:1; /* 172 1 */
__u8 nfctinfo:3; /* 172 1 */
__u8 pkt_type:3; /* 173 1 */
__u8 fclone:2; /* 173 1 */
__u8 ipvs_property:1; /* 173 1 */
/* XXX 2 bits hole, try to pack */
__be16 protocol; /* 174 2 */
void (*destructor)(struct sk_buff *); /* 176 8 */
struct nf_conntrack * nfct; /* 184 8 */
/* --- cacheline 3 boundary (192 bytes) --- */
struct sk_buff * nfct_reasm; /* 192 8 */
struct nf_bridge_info *nf_bridge; /* 200 8 */
__u16 tc_index; /* 208 2 */
__u16 tc_verd; /* 210 2 */
dma_cookie_t dma_cookie; /* 212 4 */
__u32 secmark; /* 216 4 */
__u32 mark; /* 220 4 */
unsigned int truesize; /* 224 4 */
atomic_t users; /* 228 4 */
unsigned char * head; /* 232 8 */
unsigned char * data; /* 240 8 */
unsigned char * tail; /* 248 8 */
/* --- cacheline 4 boundary (256 bytes) --- */
unsigned char * end; /* 256 8 */
}; /* size: 264, cachelines: 5 */
/* sum members: 260, holes: 1, sum holes: 4 */
/* bit holes: 1, sum bit holes: 2 bits */
/* last cacheline: 8 bytes */
On 32 bits nothing changes, and pointers continue to be used with the compiler
turning all this abstraction layer into dust. But there are some sk_buff
validation tricks that are now possible, humm... :-)
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-04-10 22:22:35 -06:00
|
|
|
/* Put back, the original values. */
|
2007-04-10 22:21:55 -06:00
|
|
|
skb->network_header = saveip;
|
|
|
|
skb->transport_header = savesctp;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!sk) {
|
2012-08-06 02:47:55 -06:00
|
|
|
ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Warning: The sock lock is held. Remember to call
|
|
|
|
* sctp_err_finish!
|
|
|
|
*/
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case ICMP_PARAMETERPROB:
|
|
|
|
err = EPROTO;
|
|
|
|
break;
|
|
|
|
case ICMP_DEST_UNREACH:
|
|
|
|
if (code > NR_ICMP_UNREACH)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
/* PMTU discovery (RFC1191) */
|
|
|
|
if (ICMP_FRAG_NEEDED == code) {
|
|
|
|
sctp_icmp_frag_needed(sk, asoc, transport, info);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (ICMP_PROT_UNREACH == code) {
|
2005-07-18 14:44:10 -06:00
|
|
|
sctp_icmp_proto_unreachable(sk, asoc,
|
2005-04-16 16:20:36 -06:00
|
|
|
transport);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
err = icmp_err_convert[code].errno;
|
|
|
|
break;
|
|
|
|
case ICMP_TIME_EXCEEDED:
|
|
|
|
/* Ignore any time exceeded errors due to fragment reassembly
|
|
|
|
* timeouts.
|
|
|
|
*/
|
|
|
|
if (ICMP_EXC_FRAGTIME == code)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
err = EHOSTUNREACH;
|
|
|
|
break;
|
2012-07-11 22:27:49 -06:00
|
|
|
case ICMP_REDIRECT:
|
|
|
|
sctp_icmp_redirect(sk, transport, skb);
|
2013-09-16 04:36:02 -06:00
|
|
|
/* Fall through to out_unlock. */
|
2005-04-16 16:20:36 -06:00
|
|
|
default:
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
inet = inet_sk(sk);
|
|
|
|
if (!sock_owned_by_user(sk) && inet->recverr) {
|
|
|
|
sk->sk_err = err;
|
|
|
|
sk->sk_error_report(sk);
|
|
|
|
} else { /* Only an error on timeout */
|
|
|
|
sk->sk_err_soft = err;
|
|
|
|
}
|
|
|
|
|
|
|
|
out_unlock:
|
2005-07-18 14:44:10 -06:00
|
|
|
sctp_err_finish(sk, asoc);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* RFC 2960, 8.4 - Handle "Out of the blue" Packets.
|
|
|
|
*
|
|
|
|
* This function scans all the chunks in the OOTB packet to determine if
|
|
|
|
* the packet should be discarded right away. If a response might be needed
|
|
|
|
* for this packet, or, if further processing is possible, the packet will
|
|
|
|
* be queued to a proper inqueue for the next phase of handling.
|
|
|
|
*
|
|
|
|
* Output:
|
|
|
|
* Return 0 - If further processing is needed.
|
|
|
|
* Return 1 - If the packet can be discarded right away.
|
|
|
|
*/
|
2007-07-26 15:21:31 -06:00
|
|
|
static int sctp_rcv_ootb(struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
sctp_chunkhdr_t *ch;
|
|
|
|
__u8 *ch_end;
|
|
|
|
|
|
|
|
ch = (sctp_chunkhdr_t *) skb->data;
|
|
|
|
|
|
|
|
/* Scan through all the chunks in the packet. */
|
2006-01-17 12:57:09 -07:00
|
|
|
do {
|
|
|
|
/* Break out if chunk length is less then minimal. */
|
|
|
|
if (ntohs(ch->length) < sizeof(sctp_chunkhdr_t))
|
|
|
|
break;
|
|
|
|
|
|
|
|
ch_end = ((__u8 *)ch) + WORD_ROUND(ntohs(ch->length));
|
2007-04-19 21:29:13 -06:00
|
|
|
if (ch_end > skb_tail_pointer(skb))
|
2006-01-17 12:57:09 -07:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* RFC 8.4, 2) If the OOTB packet contains an ABORT chunk, the
|
|
|
|
* receiver MUST silently discard the OOTB packet and take no
|
|
|
|
* further action.
|
|
|
|
*/
|
|
|
|
if (SCTP_CID_ABORT == ch->type)
|
|
|
|
goto discard;
|
|
|
|
|
|
|
|
/* RFC 8.4, 6) If the packet contains a SHUTDOWN COMPLETE
|
|
|
|
* chunk, the receiver should silently discard the packet
|
|
|
|
* and take no further action.
|
|
|
|
*/
|
|
|
|
if (SCTP_CID_SHUTDOWN_COMPLETE == ch->type)
|
|
|
|
goto discard;
|
|
|
|
|
2007-09-17 13:14:28 -06:00
|
|
|
/* RFC 4460, 2.11.2
|
|
|
|
* This will discard packets with INIT chunk bundled as
|
|
|
|
* subsequent chunks in the packet. When INIT is first,
|
|
|
|
* the normal INIT processing will discard the chunk.
|
|
|
|
*/
|
|
|
|
if (SCTP_CID_INIT == ch->type && (void *)ch != skb->data)
|
|
|
|
goto discard;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ch = (sctp_chunkhdr_t *) ch_end;
|
2007-04-19 21:29:13 -06:00
|
|
|
} while (ch_end < skb_tail_pointer(skb));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
discard:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Insert endpoint into the hash table. */
|
|
|
|
static void __sctp_hash_endpoint(struct sctp_endpoint *ep)
|
|
|
|
{
|
2012-08-06 02:40:21 -06:00
|
|
|
struct net *net = sock_net(ep->base.sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_ep_common *epb;
|
|
|
|
struct sctp_hashbucket *head;
|
|
|
|
|
|
|
|
epb = &ep->base;
|
|
|
|
|
2012-08-06 02:40:21 -06:00
|
|
|
epb->hashent = sctp_ep_hashfn(net, epb->bind_addr.port);
|
2005-04-16 16:20:36 -06:00
|
|
|
head = &sctp_ep_hashtable[epb->hashent];
|
|
|
|
|
|
|
|
sctp_write_lock(&head->lock);
|
2007-11-09 09:43:40 -07:00
|
|
|
hlist_add_head(&epb->node, &head->chain);
|
2005-04-16 16:20:36 -06:00
|
|
|
sctp_write_unlock(&head->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add an endpoint to the hash. Local BH-safe. */
|
|
|
|
void sctp_hash_endpoint(struct sctp_endpoint *ep)
|
|
|
|
{
|
|
|
|
sctp_local_bh_disable();
|
|
|
|
__sctp_hash_endpoint(ep);
|
|
|
|
sctp_local_bh_enable();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove endpoint from the hash table. */
|
|
|
|
static void __sctp_unhash_endpoint(struct sctp_endpoint *ep)
|
|
|
|
{
|
2012-08-06 02:40:21 -06:00
|
|
|
struct net *net = sock_net(ep->base.sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_hashbucket *head;
|
|
|
|
struct sctp_ep_common *epb;
|
|
|
|
|
|
|
|
epb = &ep->base;
|
|
|
|
|
2012-08-06 02:40:21 -06:00
|
|
|
epb->hashent = sctp_ep_hashfn(net, epb->bind_addr.port);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
head = &sctp_ep_hashtable[epb->hashent];
|
|
|
|
|
|
|
|
sctp_write_lock(&head->lock);
|
sctp: Fix list corruption resulting from freeing an association on a list
A few days ago Dave Jones reported this oops:
[22766.294255] general protection fault: 0000 [#1] PREEMPT SMP
[22766.295376] CPU 0
[22766.295384] Modules linked in:
[22766.387137] ffffffffa169f292 6b6b6b6b6b6b6b6b ffff880147c03a90
ffff880147c03a74
[22766.387135] DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 00000000000
[22766.387136] Process trinity-watchdo (pid: 10896, threadinfo ffff88013e7d2000,
[22766.387137] Stack:
[22766.387140] ffff880147c03a10
[22766.387140] ffffffffa169f2b6
[22766.387140] ffff88013ed95728
[22766.387143] 0000000000000002
[22766.387143] 0000000000000000
[22766.387143] ffff880003fad062
[22766.387144] ffff88013c120000
[22766.387144]
[22766.387145] Call Trace:
[22766.387145] <IRQ>
[22766.387150] [<ffffffffa169f292>] ? __sctp_lookup_association+0x62/0xd0
[sctp]
[22766.387154] [<ffffffffa169f2b6>] __sctp_lookup_association+0x86/0xd0 [sctp]
[22766.387157] [<ffffffffa169f597>] sctp_rcv+0x207/0xbb0 [sctp]
[22766.387161] [<ffffffff810d4da8>] ? trace_hardirqs_off_caller+0x28/0xd0
[22766.387163] [<ffffffff815827e3>] ? nf_hook_slow+0x133/0x210
[22766.387166] [<ffffffff815902fc>] ? ip_local_deliver_finish+0x4c/0x4c0
[22766.387168] [<ffffffff8159043d>] ip_local_deliver_finish+0x18d/0x4c0
[22766.387169] [<ffffffff815902fc>] ? ip_local_deliver_finish+0x4c/0x4c0
[22766.387171] [<ffffffff81590a07>] ip_local_deliver+0x47/0x80
[22766.387172] [<ffffffff8158fd80>] ip_rcv_finish+0x150/0x680
[22766.387174] [<ffffffff81590c54>] ip_rcv+0x214/0x320
[22766.387176] [<ffffffff81558c07>] __netif_receive_skb+0x7b7/0x910
[22766.387178] [<ffffffff8155856c>] ? __netif_receive_skb+0x11c/0x910
[22766.387180] [<ffffffff810d423e>] ? put_lock_stats.isra.25+0xe/0x40
[22766.387182] [<ffffffff81558f83>] netif_receive_skb+0x23/0x1f0
[22766.387183] [<ffffffff815596a9>] ? dev_gro_receive+0x139/0x440
[22766.387185] [<ffffffff81559280>] napi_skb_finish+0x70/0xa0
[22766.387187] [<ffffffff81559cb5>] napi_gro_receive+0xf5/0x130
[22766.387218] [<ffffffffa01c4679>] e1000_receive_skb+0x59/0x70 [e1000e]
[22766.387242] [<ffffffffa01c5aab>] e1000_clean_rx_irq+0x28b/0x460 [e1000e]
[22766.387266] [<ffffffffa01c9c18>] e1000e_poll+0x78/0x430 [e1000e]
[22766.387268] [<ffffffff81559fea>] net_rx_action+0x1aa/0x3d0
[22766.387270] [<ffffffff810a495f>] ? account_system_vtime+0x10f/0x130
[22766.387273] [<ffffffff810734d0>] __do_softirq+0xe0/0x420
[22766.387275] [<ffffffff8169826c>] call_softirq+0x1c/0x30
[22766.387278] [<ffffffff8101db15>] do_softirq+0xd5/0x110
[22766.387279] [<ffffffff81073bc5>] irq_exit+0xd5/0xe0
[22766.387281] [<ffffffff81698b03>] do_IRQ+0x63/0xd0
[22766.387283] [<ffffffff8168ee2f>] common_interrupt+0x6f/0x6f
[22766.387283] <EOI>
[22766.387284]
[22766.387285] [<ffffffff8168eed9>] ? retint_swapgs+0x13/0x1b
[22766.387285] Code: c0 90 5d c3 66 0f 1f 44 00 00 4c 89 c8 5d c3 0f 1f 00 55 48
89 e5 48 83
ec 20 48 89 5d e8 4c 89 65 f0 4c 89 6d f8 66 66 66 66 90 <0f> b7 87 98 00 00 00
48 89 fb
49 89 f5 66 c1 c0 08 66 39 46 02
[22766.387307]
[22766.387307] RIP
[22766.387311] [<ffffffffa168a2c9>] sctp_assoc_is_match+0x19/0x90 [sctp]
[22766.387311] RSP <ffff880147c039b0>
[22766.387142] ffffffffa16ab120
[22766.599537] ---[ end trace 3f6dae82e37b17f5 ]---
[22766.601221] Kernel panic - not syncing: Fatal exception in interrupt
It appears from his analysis and some staring at the code that this is likely
occuring because an association is getting freed while still on the
sctp_assoc_hashtable. As a result, we get a gpf when traversing the hashtable
while a freed node corrupts part of the list.
Nominally I would think that an mibalanced refcount was responsible for this,
but I can't seem to find any obvious imbalance. What I did note however was
that the two places where we create an association using
sctp_primitive_ASSOCIATE (__sctp_connect and sctp_sendmsg), have failure paths
which free a newly created association after calling sctp_primitive_ASSOCIATE.
sctp_primitive_ASSOCIATE brings us into the sctp_sf_do_prm_asoc path, which
issues a SCTP_CMD_NEW_ASOC side effect, which in turn adds a new association to
the aforementioned hash table. the sctp command interpreter that process side
effects has not way to unwind previously processed commands, so freeing the
association from the __sctp_connect or sctp_sendmsg error path would lead to a
freed association remaining on this hash table.
I've fixed this but modifying sctp_[un]hash_established to use hlist_del_init,
which allows us to proerly use hlist_unhashed to check if the node is on a
hashlist safely during a delete. That in turn alows us to safely call
sctp_unhash_established in the __sctp_connect and sctp_sendmsg error paths
before freeing them, regardles of what the associations state is on the hash
list.
I noted, while I was doing this, that the __sctp_unhash_endpoint was using
hlist_unhsashed in a simmilar fashion, but never nullified any removed nodes
pointers to make that function work properly, so I fixed that up in a simmilar
fashion.
I attempted to test this using a virtual guest running the SCTP_RR test from
netperf in a loop while running the trinity fuzzer, both in a loop. I wasn't
able to recreate the problem prior to this fix, nor was I able to trigger the
failure after (neither of which I suppose is suprising). Given the trace above
however, I think its likely that this is what we hit.
Signed-off-by: Neil Horman <nhorman@tuxdriver.com>
Reported-by: davej@redhat.com
CC: davej@redhat.com
CC: "David S. Miller" <davem@davemloft.net>
CC: Vlad Yasevich <vyasevich@gmail.com>
CC: Sridhar Samudrala <sri@us.ibm.com>
CC: linux-sctp@vger.kernel.org
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-07-16 03:13:51 -06:00
|
|
|
hlist_del_init(&epb->node);
|
2005-04-16 16:20:36 -06:00
|
|
|
sctp_write_unlock(&head->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove endpoint from the hash. Local BH-safe. */
|
|
|
|
void sctp_unhash_endpoint(struct sctp_endpoint *ep)
|
|
|
|
{
|
|
|
|
sctp_local_bh_disable();
|
|
|
|
__sctp_unhash_endpoint(ep);
|
|
|
|
sctp_local_bh_enable();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Look up an endpoint. */
|
2012-08-06 02:40:21 -06:00
|
|
|
static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(struct net *net,
|
|
|
|
const union sctp_addr *laddr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct sctp_hashbucket *head;
|
|
|
|
struct sctp_ep_common *epb;
|
|
|
|
struct sctp_endpoint *ep;
|
|
|
|
int hash;
|
|
|
|
|
2012-08-06 02:40:21 -06:00
|
|
|
hash = sctp_ep_hashfn(net, ntohs(laddr->v4.sin_port));
|
2005-04-16 16:20:36 -06:00
|
|
|
head = &sctp_ep_hashtable[hash];
|
|
|
|
read_lock(&head->lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
sctp_for_each_hentry(epb, &head->chain) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ep = sctp_ep(epb);
|
2012-08-06 02:40:21 -06:00
|
|
|
if (sctp_endpoint_is_match(ep, net, laddr))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto hit;
|
|
|
|
}
|
|
|
|
|
2012-08-06 02:43:06 -06:00
|
|
|
ep = sctp_sk(net->sctp.ctl_sock)->ep;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
hit:
|
|
|
|
sctp_endpoint_hold(ep);
|
|
|
|
read_unlock(&head->lock);
|
|
|
|
return ep;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Insert association into the hash table. */
|
|
|
|
static void __sctp_hash_established(struct sctp_association *asoc)
|
|
|
|
{
|
2012-08-06 02:41:13 -06:00
|
|
|
struct net *net = sock_net(asoc->base.sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_ep_common *epb;
|
|
|
|
struct sctp_hashbucket *head;
|
|
|
|
|
|
|
|
epb = &asoc->base;
|
|
|
|
|
|
|
|
/* Calculate which chain this entry will belong to. */
|
2012-08-06 02:41:13 -06:00
|
|
|
epb->hashent = sctp_assoc_hashfn(net, epb->bind_addr.port,
|
|
|
|
asoc->peer.port);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
head = &sctp_assoc_hashtable[epb->hashent];
|
|
|
|
|
|
|
|
sctp_write_lock(&head->lock);
|
2007-11-09 09:43:40 -07:00
|
|
|
hlist_add_head(&epb->node, &head->chain);
|
2005-04-16 16:20:36 -06:00
|
|
|
sctp_write_unlock(&head->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add an association to the hash. Local BH-safe. */
|
|
|
|
void sctp_hash_established(struct sctp_association *asoc)
|
|
|
|
{
|
2006-10-30 19:55:11 -07:00
|
|
|
if (asoc->temp)
|
|
|
|
return;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
sctp_local_bh_disable();
|
|
|
|
__sctp_hash_established(asoc);
|
|
|
|
sctp_local_bh_enable();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove association from the hash table. */
|
|
|
|
static void __sctp_unhash_established(struct sctp_association *asoc)
|
|
|
|
{
|
2012-08-06 02:41:13 -06:00
|
|
|
struct net *net = sock_net(asoc->base.sk);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sctp_hashbucket *head;
|
|
|
|
struct sctp_ep_common *epb;
|
|
|
|
|
|
|
|
epb = &asoc->base;
|
|
|
|
|
2012-08-06 02:41:13 -06:00
|
|
|
epb->hashent = sctp_assoc_hashfn(net, epb->bind_addr.port,
|
2005-04-16 16:20:36 -06:00
|
|
|
asoc->peer.port);
|
|
|
|
|
|
|
|
head = &sctp_assoc_hashtable[epb->hashent];
|
|
|
|
|
|
|
|
sctp_write_lock(&head->lock);
|
sctp: Fix list corruption resulting from freeing an association on a list
A few days ago Dave Jones reported this oops:
[22766.294255] general protection fault: 0000 [#1] PREEMPT SMP
[22766.295376] CPU 0
[22766.295384] Modules linked in:
[22766.387137] ffffffffa169f292 6b6b6b6b6b6b6b6b ffff880147c03a90
ffff880147c03a74
[22766.387135] DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 00000000000
[22766.387136] Process trinity-watchdo (pid: 10896, threadinfo ffff88013e7d2000,
[22766.387137] Stack:
[22766.387140] ffff880147c03a10
[22766.387140] ffffffffa169f2b6
[22766.387140] ffff88013ed95728
[22766.387143] 0000000000000002
[22766.387143] 0000000000000000
[22766.387143] ffff880003fad062
[22766.387144] ffff88013c120000
[22766.387144]
[22766.387145] Call Trace:
[22766.387145] <IRQ>
[22766.387150] [<ffffffffa169f292>] ? __sctp_lookup_association+0x62/0xd0
[sctp]
[22766.387154] [<ffffffffa169f2b6>] __sctp_lookup_association+0x86/0xd0 [sctp]
[22766.387157] [<ffffffffa169f597>] sctp_rcv+0x207/0xbb0 [sctp]
[22766.387161] [<ffffffff810d4da8>] ? trace_hardirqs_off_caller+0x28/0xd0
[22766.387163] [<ffffffff815827e3>] ? nf_hook_slow+0x133/0x210
[22766.387166] [<ffffffff815902fc>] ? ip_local_deliver_finish+0x4c/0x4c0
[22766.387168] [<ffffffff8159043d>] ip_local_deliver_finish+0x18d/0x4c0
[22766.387169] [<ffffffff815902fc>] ? ip_local_deliver_finish+0x4c/0x4c0
[22766.387171] [<ffffffff81590a07>] ip_local_deliver+0x47/0x80
[22766.387172] [<ffffffff8158fd80>] ip_rcv_finish+0x150/0x680
[22766.387174] [<ffffffff81590c54>] ip_rcv+0x214/0x320
[22766.387176] [<ffffffff81558c07>] __netif_receive_skb+0x7b7/0x910
[22766.387178] [<ffffffff8155856c>] ? __netif_receive_skb+0x11c/0x910
[22766.387180] [<ffffffff810d423e>] ? put_lock_stats.isra.25+0xe/0x40
[22766.387182] [<ffffffff81558f83>] netif_receive_skb+0x23/0x1f0
[22766.387183] [<ffffffff815596a9>] ? dev_gro_receive+0x139/0x440
[22766.387185] [<ffffffff81559280>] napi_skb_finish+0x70/0xa0
[22766.387187] [<ffffffff81559cb5>] napi_gro_receive+0xf5/0x130
[22766.387218] [<ffffffffa01c4679>] e1000_receive_skb+0x59/0x70 [e1000e]
[22766.387242] [<ffffffffa01c5aab>] e1000_clean_rx_irq+0x28b/0x460 [e1000e]
[22766.387266] [<ffffffffa01c9c18>] e1000e_poll+0x78/0x430 [e1000e]
[22766.387268] [<ffffffff81559fea>] net_rx_action+0x1aa/0x3d0
[22766.387270] [<ffffffff810a495f>] ? account_system_vtime+0x10f/0x130
[22766.387273] [<ffffffff810734d0>] __do_softirq+0xe0/0x420
[22766.387275] [<ffffffff8169826c>] call_softirq+0x1c/0x30
[22766.387278] [<ffffffff8101db15>] do_softirq+0xd5/0x110
[22766.387279] [<ffffffff81073bc5>] irq_exit+0xd5/0xe0
[22766.387281] [<ffffffff81698b03>] do_IRQ+0x63/0xd0
[22766.387283] [<ffffffff8168ee2f>] common_interrupt+0x6f/0x6f
[22766.387283] <EOI>
[22766.387284]
[22766.387285] [<ffffffff8168eed9>] ? retint_swapgs+0x13/0x1b
[22766.387285] Code: c0 90 5d c3 66 0f 1f 44 00 00 4c 89 c8 5d c3 0f 1f 00 55 48
89 e5 48 83
ec 20 48 89 5d e8 4c 89 65 f0 4c 89 6d f8 66 66 66 66 90 <0f> b7 87 98 00 00 00
48 89 fb
49 89 f5 66 c1 c0 08 66 39 46 02
[22766.387307]
[22766.387307] RIP
[22766.387311] [<ffffffffa168a2c9>] sctp_assoc_is_match+0x19/0x90 [sctp]
[22766.387311] RSP <ffff880147c039b0>
[22766.387142] ffffffffa16ab120
[22766.599537] ---[ end trace 3f6dae82e37b17f5 ]---
[22766.601221] Kernel panic - not syncing: Fatal exception in interrupt
It appears from his analysis and some staring at the code that this is likely
occuring because an association is getting freed while still on the
sctp_assoc_hashtable. As a result, we get a gpf when traversing the hashtable
while a freed node corrupts part of the list.
Nominally I would think that an mibalanced refcount was responsible for this,
but I can't seem to find any obvious imbalance. What I did note however was
that the two places where we create an association using
sctp_primitive_ASSOCIATE (__sctp_connect and sctp_sendmsg), have failure paths
which free a newly created association after calling sctp_primitive_ASSOCIATE.
sctp_primitive_ASSOCIATE brings us into the sctp_sf_do_prm_asoc path, which
issues a SCTP_CMD_NEW_ASOC side effect, which in turn adds a new association to
the aforementioned hash table. the sctp command interpreter that process side
effects has not way to unwind previously processed commands, so freeing the
association from the __sctp_connect or sctp_sendmsg error path would lead to a
freed association remaining on this hash table.
I've fixed this but modifying sctp_[un]hash_established to use hlist_del_init,
which allows us to proerly use hlist_unhashed to check if the node is on a
hashlist safely during a delete. That in turn alows us to safely call
sctp_unhash_established in the __sctp_connect and sctp_sendmsg error paths
before freeing them, regardles of what the associations state is on the hash
list.
I noted, while I was doing this, that the __sctp_unhash_endpoint was using
hlist_unhsashed in a simmilar fashion, but never nullified any removed nodes
pointers to make that function work properly, so I fixed that up in a simmilar
fashion.
I attempted to test this using a virtual guest running the SCTP_RR test from
netperf in a loop while running the trinity fuzzer, both in a loop. I wasn't
able to recreate the problem prior to this fix, nor was I able to trigger the
failure after (neither of which I suppose is suprising). Given the trace above
however, I think its likely that this is what we hit.
Signed-off-by: Neil Horman <nhorman@tuxdriver.com>
Reported-by: davej@redhat.com
CC: davej@redhat.com
CC: "David S. Miller" <davem@davemloft.net>
CC: Vlad Yasevich <vyasevich@gmail.com>
CC: Sridhar Samudrala <sri@us.ibm.com>
CC: linux-sctp@vger.kernel.org
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-07-16 03:13:51 -06:00
|
|
|
hlist_del_init(&epb->node);
|
2005-04-16 16:20:36 -06:00
|
|
|
sctp_write_unlock(&head->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove association from the hash table. Local BH-safe. */
|
|
|
|
void sctp_unhash_established(struct sctp_association *asoc)
|
|
|
|
{
|
2006-10-30 19:55:11 -07:00
|
|
|
if (asoc->temp)
|
|
|
|
return;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
sctp_local_bh_disable();
|
|
|
|
__sctp_unhash_established(asoc);
|
|
|
|
sctp_local_bh_enable();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Look up an association. */
|
|
|
|
static struct sctp_association *__sctp_lookup_association(
|
2012-08-06 02:41:13 -06:00
|
|
|
struct net *net,
|
2005-04-16 16:20:36 -06:00
|
|
|
const union sctp_addr *local,
|
|
|
|
const union sctp_addr *peer,
|
|
|
|
struct sctp_transport **pt)
|
|
|
|
{
|
|
|
|
struct sctp_hashbucket *head;
|
|
|
|
struct sctp_ep_common *epb;
|
|
|
|
struct sctp_association *asoc;
|
|
|
|
struct sctp_transport *transport;
|
|
|
|
int hash;
|
|
|
|
|
|
|
|
/* Optimize here for direct hit, only listening connections can
|
|
|
|
* have wildcards anyways.
|
|
|
|
*/
|
2012-08-06 02:41:13 -06:00
|
|
|
hash = sctp_assoc_hashfn(net, ntohs(local->v4.sin_port),
|
|
|
|
ntohs(peer->v4.sin_port));
|
2005-04-16 16:20:36 -06:00
|
|
|
head = &sctp_assoc_hashtable[hash];
|
|
|
|
read_lock(&head->lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
sctp_for_each_hentry(epb, &head->chain) {
|
2005-04-16 16:20:36 -06:00
|
|
|
asoc = sctp_assoc(epb);
|
2012-08-06 02:41:13 -06:00
|
|
|
transport = sctp_assoc_is_match(asoc, net, local, peer);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (transport)
|
|
|
|
goto hit;
|
|
|
|
}
|
|
|
|
|
|
|
|
read_unlock(&head->lock);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
hit:
|
|
|
|
*pt = transport;
|
|
|
|
sctp_association_hold(asoc);
|
|
|
|
read_unlock(&head->lock);
|
|
|
|
return asoc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Look up an association. BH-safe. */
|
2013-06-17 03:40:05 -06:00
|
|
|
static
|
2012-08-06 02:41:13 -06:00
|
|
|
struct sctp_association *sctp_lookup_association(struct net *net,
|
|
|
|
const union sctp_addr *laddr,
|
2005-04-16 16:20:36 -06:00
|
|
|
const union sctp_addr *paddr,
|
2013-06-17 03:40:05 -06:00
|
|
|
struct sctp_transport **transportp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct sctp_association *asoc;
|
|
|
|
|
|
|
|
sctp_local_bh_disable();
|
2012-08-06 02:41:13 -06:00
|
|
|
asoc = __sctp_lookup_association(net, laddr, paddr, transportp);
|
2005-04-16 16:20:36 -06:00
|
|
|
sctp_local_bh_enable();
|
|
|
|
|
|
|
|
return asoc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is there an association matching the given local and peer addresses? */
|
2012-08-06 02:41:13 -06:00
|
|
|
int sctp_has_association(struct net *net,
|
|
|
|
const union sctp_addr *laddr,
|
2005-04-16 16:20:36 -06:00
|
|
|
const union sctp_addr *paddr)
|
|
|
|
{
|
|
|
|
struct sctp_association *asoc;
|
|
|
|
struct sctp_transport *transport;
|
|
|
|
|
2012-08-06 02:41:13 -06:00
|
|
|
if ((asoc = sctp_lookup_association(net, laddr, paddr, &transport))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
sctp_association_put(asoc);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SCTP Implementors Guide, 2.18 Handling of address
|
|
|
|
* parameters within the INIT or INIT-ACK.
|
|
|
|
*
|
|
|
|
* D) When searching for a matching TCB upon reception of an INIT
|
|
|
|
* or INIT-ACK chunk the receiver SHOULD use not only the
|
|
|
|
* source address of the packet (containing the INIT or
|
|
|
|
* INIT-ACK) but the receiver SHOULD also use all valid
|
|
|
|
* address parameters contained within the chunk.
|
|
|
|
*
|
|
|
|
* 2.18.3 Solution description
|
|
|
|
*
|
|
|
|
* This new text clearly specifies to an implementor the need
|
|
|
|
* to look within the INIT or INIT-ACK. Any implementation that
|
|
|
|
* does not do this, may not be able to establish associations
|
|
|
|
* in certain circumstances.
|
|
|
|
*
|
|
|
|
*/
|
2012-08-06 02:41:13 -06:00
|
|
|
static struct sctp_association *__sctp_rcv_init_lookup(struct net *net,
|
|
|
|
struct sk_buff *skb,
|
2005-04-16 16:20:36 -06:00
|
|
|
const union sctp_addr *laddr, struct sctp_transport **transportp)
|
|
|
|
{
|
|
|
|
struct sctp_association *asoc;
|
|
|
|
union sctp_addr addr;
|
|
|
|
union sctp_addr *paddr = &addr;
|
2007-03-13 10:59:32 -06:00
|
|
|
struct sctphdr *sh = sctp_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
union sctp_params params;
|
|
|
|
sctp_init_chunk_t *init;
|
|
|
|
struct sctp_transport *transport;
|
|
|
|
struct sctp_af *af;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This code will NOT touch anything inside the chunk--it is
|
|
|
|
* strictly READ-ONLY.
|
|
|
|
*
|
|
|
|
* RFC 2960 3 SCTP packet Format
|
|
|
|
*
|
|
|
|
* Multiple chunks can be bundled into one SCTP packet up to
|
|
|
|
* the MTU size, except for the INIT, INIT ACK, and SHUTDOWN
|
|
|
|
* COMPLETE chunks. These chunks MUST NOT be bundled with any
|
|
|
|
* other chunk in a packet. See Section 6.10 for more details
|
|
|
|
* on chunk bundling.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Find the start of the TLVs and the end of the chunk. This is
|
|
|
|
* the region we search for address parameters.
|
|
|
|
*/
|
|
|
|
init = (sctp_init_chunk_t *)skb->data;
|
|
|
|
|
|
|
|
/* Walk the parameters looking for embedded addresses. */
|
|
|
|
sctp_walk_params(params, init, init_hdr.params) {
|
|
|
|
|
|
|
|
/* Note: Ignoring hostname addresses. */
|
|
|
|
af = sctp_get_af_specific(param_type2af(params.p->type));
|
|
|
|
if (!af)
|
|
|
|
continue;
|
|
|
|
|
2006-11-20 18:11:13 -07:00
|
|
|
af->from_addr_param(paddr, params.addr, sh->source, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-08-06 02:41:13 -06:00
|
|
|
asoc = __sctp_lookup_association(net, laddr, paddr, &transport);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (asoc)
|
|
|
|
return asoc;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-12-20 15:10:38 -07:00
|
|
|
/* ADD-IP, Section 5.2
|
|
|
|
* When an endpoint receives an ASCONF Chunk from the remote peer
|
|
|
|
* special procedures may be needed to identify the association the
|
|
|
|
* ASCONF Chunk is associated with. To properly find the association
|
|
|
|
* the following procedures SHOULD be followed:
|
|
|
|
*
|
|
|
|
* D2) If the association is not found, use the address found in the
|
|
|
|
* Address Parameter TLV combined with the port number found in the
|
|
|
|
* SCTP common header. If found proceed to rule D4.
|
|
|
|
*
|
|
|
|
* D2-ext) If more than one ASCONF Chunks are packed together, use the
|
|
|
|
* address found in the ASCONF Address Parameter TLV of each of the
|
|
|
|
* subsequent ASCONF Chunks. If found, proceed to rule D4.
|
|
|
|
*/
|
|
|
|
static struct sctp_association *__sctp_rcv_asconf_lookup(
|
2012-08-06 02:41:13 -06:00
|
|
|
struct net *net,
|
2007-12-20 15:10:38 -07:00
|
|
|
sctp_chunkhdr_t *ch,
|
|
|
|
const union sctp_addr *laddr,
|
2008-03-17 23:47:32 -06:00
|
|
|
__be16 peer_port,
|
2007-12-20 15:10:38 -07:00
|
|
|
struct sctp_transport **transportp)
|
|
|
|
{
|
|
|
|
sctp_addip_chunk_t *asconf = (struct sctp_addip_chunk *)ch;
|
|
|
|
struct sctp_af *af;
|
|
|
|
union sctp_addr_param *param;
|
|
|
|
union sctp_addr paddr;
|
|
|
|
|
|
|
|
/* Skip over the ADDIP header and find the Address parameter */
|
|
|
|
param = (union sctp_addr_param *)(asconf + 1);
|
|
|
|
|
2011-04-18 13:11:47 -06:00
|
|
|
af = sctp_get_af_specific(param_type2af(param->p.type));
|
2007-12-20 15:10:38 -07:00
|
|
|
if (unlikely(!af))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
af->from_addr_param(&paddr, param, peer_port, 0);
|
|
|
|
|
2012-08-06 02:41:13 -06:00
|
|
|
return __sctp_lookup_association(net, laddr, &paddr, transportp);
|
2007-12-20 15:10:38 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-03 18:51:34 -06:00
|
|
|
/* SCTP-AUTH, Section 6.3:
|
|
|
|
* If the receiver does not find a STCB for a packet containing an AUTH
|
|
|
|
* chunk as the first chunk and not a COOKIE-ECHO chunk as the second
|
|
|
|
* chunk, it MUST use the chunks after the AUTH chunk to look up an existing
|
|
|
|
* association.
|
|
|
|
*
|
|
|
|
* This means that any chunks that can help us identify the association need
|
2011-03-30 19:57:33 -06:00
|
|
|
* to be looked at to find this association.
|
2007-10-03 18:51:34 -06:00
|
|
|
*/
|
2012-08-06 02:41:13 -06:00
|
|
|
static struct sctp_association *__sctp_rcv_walk_lookup(struct net *net,
|
|
|
|
struct sk_buff *skb,
|
2007-10-03 18:51:34 -06:00
|
|
|
const union sctp_addr *laddr,
|
|
|
|
struct sctp_transport **transportp)
|
|
|
|
{
|
2007-12-20 15:10:38 -07:00
|
|
|
struct sctp_association *asoc = NULL;
|
|
|
|
sctp_chunkhdr_t *ch;
|
|
|
|
int have_auth = 0;
|
|
|
|
unsigned int chunk_num = 1;
|
|
|
|
__u8 *ch_end;
|
|
|
|
|
|
|
|
/* Walk through the chunks looking for AUTH or ASCONF chunks
|
|
|
|
* to help us find the association.
|
2007-10-03 18:51:34 -06:00
|
|
|
*/
|
2007-12-20 15:10:38 -07:00
|
|
|
ch = (sctp_chunkhdr_t *) skb->data;
|
|
|
|
do {
|
|
|
|
/* Break out if chunk length is less then minimal. */
|
|
|
|
if (ntohs(ch->length) < sizeof(sctp_chunkhdr_t))
|
|
|
|
break;
|
|
|
|
|
|
|
|
ch_end = ((__u8 *)ch) + WORD_ROUND(ntohs(ch->length));
|
|
|
|
if (ch_end > skb_tail_pointer(skb))
|
|
|
|
break;
|
|
|
|
|
|
|
|
switch(ch->type) {
|
|
|
|
case SCTP_CID_AUTH:
|
|
|
|
have_auth = chunk_num;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SCTP_CID_COOKIE_ECHO:
|
|
|
|
/* If a packet arrives containing an AUTH chunk as
|
|
|
|
* a first chunk, a COOKIE-ECHO chunk as the second
|
|
|
|
* chunk, and possibly more chunks after them, and
|
|
|
|
* the receiver does not have an STCB for that
|
|
|
|
* packet, then authentication is based on
|
|
|
|
* the contents of the COOKIE- ECHO chunk.
|
|
|
|
*/
|
|
|
|
if (have_auth == 1 && chunk_num == 2)
|
|
|
|
return NULL;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SCTP_CID_ASCONF:
|
2012-08-07 01:29:57 -06:00
|
|
|
if (have_auth || net->sctp.addip_noauth)
|
2012-08-06 02:41:13 -06:00
|
|
|
asoc = __sctp_rcv_asconf_lookup(
|
|
|
|
net, ch, laddr,
|
2007-12-20 15:10:38 -07:00
|
|
|
sctp_hdr(skb)->source,
|
|
|
|
transportp);
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (asoc)
|
|
|
|
break;
|
|
|
|
|
|
|
|
ch = (sctp_chunkhdr_t *) ch_end;
|
|
|
|
chunk_num++;
|
|
|
|
} while (ch_end < skb_tail_pointer(skb));
|
|
|
|
|
|
|
|
return asoc;
|
2007-10-03 18:51:34 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There are circumstances when we need to look inside the SCTP packet
|
|
|
|
* for information to help us find the association. Examples
|
|
|
|
* include looking inside of INIT/INIT-ACK chunks or after the AUTH
|
|
|
|
* chunks.
|
|
|
|
*/
|
2012-08-06 02:41:13 -06:00
|
|
|
static struct sctp_association *__sctp_rcv_lookup_harder(struct net *net,
|
|
|
|
struct sk_buff *skb,
|
2007-10-03 18:51:34 -06:00
|
|
|
const union sctp_addr *laddr,
|
|
|
|
struct sctp_transport **transportp)
|
|
|
|
{
|
|
|
|
sctp_chunkhdr_t *ch;
|
|
|
|
|
|
|
|
ch = (sctp_chunkhdr_t *) skb->data;
|
|
|
|
|
2007-12-20 15:10:38 -07:00
|
|
|
/* The code below will attempt to walk the chunk and extract
|
|
|
|
* parameter information. Before we do that, we need to verify
|
|
|
|
* that the chunk length doesn't cause overflow. Otherwise, we'll
|
|
|
|
* walk off the end.
|
|
|
|
*/
|
|
|
|
if (WORD_ROUND(ntohs(ch->length)) > skb->len)
|
|
|
|
return NULL;
|
|
|
|
|
2007-10-03 18:51:34 -06:00
|
|
|
/* If this is INIT/INIT-ACK look inside the chunk too. */
|
|
|
|
switch (ch->type) {
|
|
|
|
case SCTP_CID_INIT:
|
|
|
|
case SCTP_CID_INIT_ACK:
|
2012-08-06 02:41:13 -06:00
|
|
|
return __sctp_rcv_init_lookup(net, skb, laddr, transportp);
|
2007-10-03 18:51:34 -06:00
|
|
|
break;
|
|
|
|
|
2007-12-20 15:10:38 -07:00
|
|
|
default:
|
2012-08-06 02:41:13 -06:00
|
|
|
return __sctp_rcv_walk_lookup(net, skb, laddr, transportp);
|
2007-10-03 18:51:34 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-12-20 15:10:38 -07:00
|
|
|
|
2007-10-03 18:51:34 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Lookup an association for an inbound skb. */
|
2012-08-06 02:41:13 -06:00
|
|
|
static struct sctp_association *__sctp_rcv_lookup(struct net *net,
|
|
|
|
struct sk_buff *skb,
|
2005-04-16 16:20:36 -06:00
|
|
|
const union sctp_addr *paddr,
|
|
|
|
const union sctp_addr *laddr,
|
|
|
|
struct sctp_transport **transportp)
|
|
|
|
{
|
|
|
|
struct sctp_association *asoc;
|
|
|
|
|
2012-08-06 02:41:13 -06:00
|
|
|
asoc = __sctp_lookup_association(net, laddr, paddr, transportp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Further lookup for INIT/INIT-ACK packets.
|
|
|
|
* SCTP Implementors Guide, 2.18 Handling of address
|
|
|
|
* parameters within the INIT or INIT-ACK.
|
|
|
|
*/
|
|
|
|
if (!asoc)
|
2012-08-06 02:41:13 -06:00
|
|
|
asoc = __sctp_rcv_lookup_harder(net, skb, laddr, transportp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return asoc;
|
|
|
|
}
|