2019-05-23 12:14:41 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2008-01-11 17:57:09 +03:00
|
|
|
/* SCTP kernel implementation
|
2005-04-17 02:20:36 +04: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 17:57:09 +03:00
|
|
|
* This file is part of the SCTP kernel implementation
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
|
|
|
* These functions handle all input from the IP layer into SCTP.
|
|
|
|
*
|
|
|
|
* Please send any bug reports or fixes you make to the
|
|
|
|
* email address(es):
|
2013-07-23 16:51:47 +04:00
|
|
|
* lksctp developers <linux-sctp@vger.kernel.org>
|
2005-04-17 02:20:36 +04: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 11:04:11 +03:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 02:20:36 +04: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-17 01:06:41 +03:00
|
|
|
#include <net/sctp/checksum.h>
|
2008-07-15 10:03:00 +04:00
|
|
|
#include <net/net_namespace.h>
|
2018-06-18 05:52:50 +03:00
|
|
|
#include <linux/rhashtable.h>
|
2018-11-12 13:27:15 +03:00
|
|
|
#include <net/sock_reuseport.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Forward declarations for internal helpers. */
|
|
|
|
static int sctp_rcv_ootb(struct sk_buff *);
|
2012-08-06 12:41:13 +04:00
|
|
|
static struct sctp_association *__sctp_rcv_lookup(struct net *net,
|
|
|
|
struct sk_buff *skb,
|
2005-04-17 02:20:36 +04:00
|
|
|
const union sctp_addr *paddr,
|
2012-10-03 09:43:21 +04:00
|
|
|
const union sctp_addr *laddr,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct sctp_transport **transportp);
|
2018-11-12 13:27:15 +03:00
|
|
|
static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(
|
|
|
|
struct net *net, struct sk_buff *skb,
|
|
|
|
const union sctp_addr *laddr,
|
|
|
|
const union sctp_addr *daddr);
|
2005-04-17 02:20:36 +04:00
|
|
|
static struct sctp_association *__sctp_lookup_association(
|
2012-08-06 12:41:13 +04:00
|
|
|
struct net *net,
|
2005-04-17 02:20:36 +04:00
|
|
|
const union sctp_addr *local,
|
|
|
|
const union sctp_addr *peer,
|
|
|
|
struct sctp_transport **pt);
|
|
|
|
|
2010-03-04 21:01:44 +03:00
|
|
|
static int sctp_add_backlog(struct sock *sk, struct sk_buff *skb);
|
2006-05-19 22:01:18 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Calculate the SCTP checksum of an SCTP packet. */
|
2012-08-06 12:47:55 +04:00
|
|
|
static inline int sctp_rcv_checksum(struct net *net, struct sk_buff *skb)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2007-03-13 19:59:32 +03:00
|
|
|
struct sctphdr *sh = sctp_hdr(skb);
|
2009-02-13 11:33:42 +03:00
|
|
|
__le32 cmp = sh->checksum;
|
2013-07-25 05:52:05 +04:00
|
|
|
__le32 val = sctp_compute_cksum(skb, 0);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
if (val != cmp) {
|
|
|
|
/* CRC failure, dump it. */
|
2016-04-28 02:44:34 +03:00
|
|
|
__SCTP_INC_STATS(net, SCTP_MIB_CHECKSUMERRORS);
|
2005-04-17 02:20:36 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
union sctp_addr src;
|
|
|
|
union sctp_addr dest;
|
2022-05-13 21:55:42 +03:00
|
|
|
int bound_dev_if;
|
2005-04-17 02:20:36 +04:00
|
|
|
int family;
|
|
|
|
struct sctp_af *af;
|
2012-08-06 12:40:21 +04:00
|
|
|
struct net *net = dev_net(skb->dev);
|
2018-03-09 06:06:09 +03:00
|
|
|
bool is_gso = skb_is_gso(skb) && skb_is_gso_sctp(skb);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-12-23 08:16:50 +04:00
|
|
|
if (skb->pkt_type != PACKET_HOST)
|
2005-04-17 02:20:36 +04:00
|
|
|
goto discard_it;
|
|
|
|
|
2016-04-28 02:44:34 +03:00
|
|
|
__SCTP_INC_STATS(net, SCTP_MIB_INSCTPPACKS);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-06-02 21:05:42 +03:00
|
|
|
/* If packet is too small to contain a single chunk, let's not
|
|
|
|
* waste time on it anymore.
|
|
|
|
*/
|
|
|
|
if (skb->len < sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr) +
|
|
|
|
skb_transport_offset(skb))
|
2006-10-30 10:46:42 +03:00
|
|
|
goto discard_it;
|
|
|
|
|
sctp: linearize early if it's not GSO
Because otherwise when crc computation is still needed it's way more
expensive than on a linear buffer to the point that it affects
performance.
It's so expensive that netperf test gives a perf output as below:
Overhead Command Shared Object Symbol
18,62% netserver [kernel.vmlinux] [k] crc32_generic_shift
2,57% netserver [kernel.vmlinux] [k] __pskb_pull_tail
1,94% netserver [kernel.vmlinux] [k] fib_table_lookup
1,90% netserver [kernel.vmlinux] [k] copy_user_enhanced_fast_string
1,66% swapper [kernel.vmlinux] [k] intel_idle
1,63% netserver [kernel.vmlinux] [k] _raw_spin_lock
1,59% netserver [sctp] [k] sctp_packet_transmit
1,55% netserver [kernel.vmlinux] [k] memcpy_erms
1,42% netserver [sctp] [k] sctp_rcv
# netperf -H 192.168.10.1 -l 10 -t SCTP_STREAM -cC -- -m 12000
SCTP STREAM TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 192.168.10.1 () port 0 AF_INET
Recv Send Send Utilization Service Demand
Socket Socket Message Elapsed Send Recv Send Recv
Size Size Size Time Throughput local remote local remote
bytes bytes bytes secs. 10^6bits/s % S % S us/KB us/KB
212992 212992 12000 10.00 3016.42 2.88 3.78 1.874 2.462
After patch:
Overhead Command Shared Object Symbol
2,75% netserver [kernel.vmlinux] [k] memcpy_erms
2,63% netserver [kernel.vmlinux] [k] copy_user_enhanced_fast_string
2,39% netserver [kernel.vmlinux] [k] fib_table_lookup
2,04% netserver [kernel.vmlinux] [k] __pskb_pull_tail
1,91% netserver [kernel.vmlinux] [k] _raw_spin_lock
1,91% netserver [sctp] [k] sctp_packet_transmit
1,72% netserver [mlx4_en] [k] mlx4_en_process_rx_cq
1,68% netserver [sctp] [k] sctp_rcv
# netperf -H 192.168.10.1 -l 10 -t SCTP_STREAM -cC -- -m 12000
SCTP STREAM TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 192.168.10.1 () port 0 AF_INET
Recv Send Send Utilization Service Demand
Socket Socket Message Elapsed Send Recv Send Recv
Size Size Size Time Throughput local remote local remote
bytes bytes bytes secs. 10^6bits/s % S % S us/KB us/KB
212992 212992 12000 10.00 3681.77 3.83 3.46 2.045 1.849
Fixes: 3acb50c18d8d ("sctp: delay as much as possible skb_linearize")
Signed-off-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-08-18 20:58:35 +03:00
|
|
|
/* If the packet is fragmented and we need to do crc checking,
|
|
|
|
* it's better to just linearize it otherwise crc computing
|
|
|
|
* takes longer.
|
|
|
|
*/
|
2018-03-09 06:06:09 +03:00
|
|
|
if ((!is_gso && skb_linearize(skb)) ||
|
sctp: linearize early if it's not GSO
Because otherwise when crc computation is still needed it's way more
expensive than on a linear buffer to the point that it affects
performance.
It's so expensive that netperf test gives a perf output as below:
Overhead Command Shared Object Symbol
18,62% netserver [kernel.vmlinux] [k] crc32_generic_shift
2,57% netserver [kernel.vmlinux] [k] __pskb_pull_tail
1,94% netserver [kernel.vmlinux] [k] fib_table_lookup
1,90% netserver [kernel.vmlinux] [k] copy_user_enhanced_fast_string
1,66% swapper [kernel.vmlinux] [k] intel_idle
1,63% netserver [kernel.vmlinux] [k] _raw_spin_lock
1,59% netserver [sctp] [k] sctp_packet_transmit
1,55% netserver [kernel.vmlinux] [k] memcpy_erms
1,42% netserver [sctp] [k] sctp_rcv
# netperf -H 192.168.10.1 -l 10 -t SCTP_STREAM -cC -- -m 12000
SCTP STREAM TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 192.168.10.1 () port 0 AF_INET
Recv Send Send Utilization Service Demand
Socket Socket Message Elapsed Send Recv Send Recv
Size Size Size Time Throughput local remote local remote
bytes bytes bytes secs. 10^6bits/s % S % S us/KB us/KB
212992 212992 12000 10.00 3016.42 2.88 3.78 1.874 2.462
After patch:
Overhead Command Shared Object Symbol
2,75% netserver [kernel.vmlinux] [k] memcpy_erms
2,63% netserver [kernel.vmlinux] [k] copy_user_enhanced_fast_string
2,39% netserver [kernel.vmlinux] [k] fib_table_lookup
2,04% netserver [kernel.vmlinux] [k] __pskb_pull_tail
1,91% netserver [kernel.vmlinux] [k] _raw_spin_lock
1,91% netserver [sctp] [k] sctp_packet_transmit
1,72% netserver [mlx4_en] [k] mlx4_en_process_rx_cq
1,68% netserver [sctp] [k] sctp_rcv
# netperf -H 192.168.10.1 -l 10 -t SCTP_STREAM -cC -- -m 12000
SCTP STREAM TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 192.168.10.1 () port 0 AF_INET
Recv Send Send Utilization Service Demand
Socket Socket Message Elapsed Send Recv Send Recv
Size Size Size Time Throughput local remote local remote
bytes bytes bytes secs. 10^6bits/s % S % S us/KB us/KB
212992 212992 12000 10.00 3681.77 3.83 3.46 2.045 1.849
Fixes: 3acb50c18d8d ("sctp: delay as much as possible skb_linearize")
Signed-off-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-08-18 20:58:35 +03:00
|
|
|
!pskb_may_pull(skb, sizeof(struct sctphdr)))
|
2016-06-02 21:05:42 +03:00
|
|
|
goto discard_it;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-06-02 21:05:42 +03:00
|
|
|
/* Pull up the IP header. */
|
2007-04-26 04:55:53 +04:00
|
|
|
__skb_pull(skb, skb_transport_offset(skb));
|
2014-08-28 08:27:06 +04:00
|
|
|
|
|
|
|
skb->csum_valid = 0; /* Previous value not applicable */
|
|
|
|
if (skb_csum_unnecessary(skb))
|
|
|
|
__skb_decr_checksum_unnecessary(skb);
|
2016-06-02 21:05:43 +03:00
|
|
|
else if (!sctp_checksum_disable &&
|
2018-03-09 06:06:09 +03:00
|
|
|
!is_gso &&
|
2016-06-02 21:05:43 +03:00
|
|
|
sctp_rcv_checksum(net, skb) < 0)
|
2005-04-17 02:20:36 +04:00
|
|
|
goto discard_it;
|
2014-08-28 08:27:06 +04:00
|
|
|
skb->csum_valid = 1;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-06-02 21:05:42 +03:00
|
|
|
__skb_pull(skb, sizeof(struct sctphdr));
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-04-21 09:47:35 +04:00
|
|
|
family = ipver2af(ip_hdr(skb)->version);
|
2005-04-17 02:20:36 +04:00
|
|
|
af = sctp_get_af_specific(family);
|
|
|
|
if (unlikely(!af))
|
|
|
|
goto discard_it;
|
2016-07-13 21:08:58 +03:00
|
|
|
SCTP_INPUT_CB(skb)->af = af;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* 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-18 09:55:35 +04:00
|
|
|
if (!af->addr_valid(&src, NULL, skb) ||
|
|
|
|
!af->addr_valid(&dest, NULL, skb))
|
2005-04-17 02:20:36 +04:00
|
|
|
goto discard_it;
|
|
|
|
|
2012-08-06 12:41:13 +04:00
|
|
|
asoc = __sctp_rcv_lookup(net, skb, &src, &dest, &transport);
|
2006-11-21 04:08:09 +03:00
|
|
|
|
2005-06-14 02:11:24 +04:00
|
|
|
if (!asoc)
|
2018-11-12 13:27:15 +03:00
|
|
|
ep = __sctp_rcv_lookup_endpoint(net, skb, &dest, &src);
|
2005-06-14 02:11:24 +04: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
|
|
|
|
*/
|
2022-05-13 21:55:42 +03:00
|
|
|
bound_dev_if = READ_ONCE(sk->sk_bound_dev_if);
|
|
|
|
if (bound_dev_if && (bound_dev_if != af->skb_iif(skb))) {
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
if (transport) {
|
|
|
|
sctp_transport_put(transport);
|
2005-06-14 02:11:24 +04:00
|
|
|
asoc = NULL;
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
transport = NULL;
|
2005-06-14 02:11:24 +04:00
|
|
|
} else {
|
|
|
|
sctp_endpoint_put(ep);
|
|
|
|
ep = NULL;
|
|
|
|
}
|
2012-08-06 12:43:06 +04:00
|
|
|
sk = net->sctp.ctl_sock;
|
2005-06-14 02:11:24 +04:00
|
|
|
ep = sctp_sk(sk)->ep;
|
|
|
|
sctp_endpoint_hold(ep);
|
|
|
|
rcvr = &ep->base;
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04: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)) {
|
2016-04-28 02:44:34 +03:00
|
|
|
__SCTP_INC_STATS(net, SCTP_MIB_OUTOFBLUES);
|
2005-04-17 02:20:36 +04:00
|
|
|
goto discard_release;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!xfrm_policy_check(sk, XFRM_POLICY_IN, skb, family))
|
|
|
|
goto discard_release;
|
2019-09-29 21:54:03 +03:00
|
|
|
nf_reset_ct(skb);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-09-01 02:28:39 +04:00
|
|
|
if (sk_filter(sk, skb))
|
2007-02-09 17:25:18 +03:00
|
|
|
goto discard_release;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Create an SCTP packet structure. */
|
2016-03-11 00:33:07 +03:00
|
|
|
chunk = sctp_chunkify(skb, asoc, sk, GFP_ATOMIC);
|
2006-03-25 12:25:29 +03:00
|
|
|
if (!chunk)
|
2005-04-17 02:20:36 +04:00
|
|
|
goto discard_release;
|
2005-07-09 08:47:49 +04:00
|
|
|
SCTP_INPUT_CB(skb)->chunk = chunk;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Remember what endpoint is to handle this packet. */
|
|
|
|
chunk->rcvr = rcvr;
|
|
|
|
|
|
|
|
/* Remember the SCTP header. */
|
2016-06-02 21:05:42 +03:00
|
|
|
chunk->sctp_hdr = sctp_hdr(skb);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Set the source and destination addresses of the incoming chunk. */
|
2006-11-21 04:09:40 +03:00
|
|
|
sctp_init_addrs(chunk, &src, &dest);
|
2005-04-17 02:20:36 +04: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.
|
|
|
|
*/
|
2014-01-21 11:44:12 +04:00
|
|
|
bh_lock_sock(sk);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2009-01-23 01:53:23 +03: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.
|
|
|
|
*/
|
2014-01-21 11:44:12 +04:00
|
|
|
bh_unlock_sock(sk);
|
2009-01-23 01:53:23 +03:00
|
|
|
sk = rcvr->sk;
|
2014-01-21 11:44:12 +04:00
|
|
|
bh_lock_sock(sk);
|
2009-01-23 01:53:23 +03:00
|
|
|
}
|
|
|
|
|
2019-10-08 14:09:23 +03:00
|
|
|
if (sock_owned_by_user(sk) || !sctp_newsk_ready(sk)) {
|
2010-03-04 21:01:44 +03:00
|
|
|
if (sctp_add_backlog(sk, skb)) {
|
2014-01-21 11:44:12 +04:00
|
|
|
bh_unlock_sock(sk);
|
2010-03-04 21:01:44 +03:00
|
|
|
sctp_chunk_free(chunk);
|
|
|
|
skb = NULL; /* sctp_chunk_free already freed the skb */
|
|
|
|
goto discard_release;
|
|
|
|
}
|
2016-04-28 02:44:34 +03:00
|
|
|
__SCTP_INC_STATS(net, SCTP_MIB_IN_PKT_BACKLOG);
|
2006-08-22 11:15:33 +04:00
|
|
|
} else {
|
2016-04-28 02:44:34 +03:00
|
|
|
__SCTP_INC_STATS(net, SCTP_MIB_IN_PKT_SOFTIRQ);
|
2006-05-19 22:01:18 +04:00
|
|
|
sctp_inq_push(&chunk->rcvr->inqueue, chunk);
|
2006-08-22 11:15:33 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-01-21 11:44:12 +04:00
|
|
|
bh_unlock_sock(sk);
|
2006-05-19 22:01:18 +04:00
|
|
|
|
|
|
|
/* Release the asoc/ep ref we took in the lookup calls. */
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
if (transport)
|
|
|
|
sctp_transport_put(transport);
|
2006-05-19 22:01:18 +04:00
|
|
|
else
|
|
|
|
sctp_endpoint_put(ep);
|
2006-01-17 22:51:28 +03:00
|
|
|
|
2006-03-25 12:25:29 +03:00
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
discard_it:
|
2016-04-28 02:44:34 +03:00
|
|
|
__SCTP_INC_STATS(net, SCTP_MIB_IN_PKT_DISCARDS);
|
2005-04-17 02:20:36 +04:00
|
|
|
kfree_skb(skb);
|
2006-03-25 12:25:29 +03:00
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
discard_release:
|
2006-05-19 22:01:18 +04:00
|
|
|
/* Release the asoc/ep ref we took in the lookup calls. */
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
if (transport)
|
|
|
|
sctp_transport_put(transport);
|
2005-06-14 02:11:24 +04:00
|
|
|
else
|
2005-04-17 02:20:36 +04:00
|
|
|
sctp_endpoint_put(ep);
|
|
|
|
|
|
|
|
goto discard_it;
|
|
|
|
}
|
|
|
|
|
2006-05-19 22:01:18 +04: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-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb)
|
|
|
|
{
|
2005-07-09 08:47:49 +04:00
|
|
|
struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
|
2007-02-09 17:25:18 +03:00
|
|
|
struct sctp_inq *inqueue = &chunk->rcvr->inqueue;
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
struct sctp_transport *t = chunk->transport;
|
2007-02-09 17:25:18 +03:00
|
|
|
struct sctp_ep_common *rcvr = NULL;
|
2006-05-19 22:01:18 +04:00
|
|
|
int backloged = 0;
|
2006-01-17 22:51:28 +03:00
|
|
|
|
2007-02-09 17:25:18 +03:00
|
|
|
rcvr = chunk->rcvr;
|
2006-01-17 22:56:26 +03:00
|
|
|
|
2006-05-19 22:01:18 +04: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;
|
2016-07-23 06:32:48 +03:00
|
|
|
local_bh_disable();
|
2014-01-21 11:44:12 +04:00
|
|
|
bh_lock_sock(sk);
|
2006-05-19 22:01:18 +04:00
|
|
|
|
2019-10-08 14:09:23 +03:00
|
|
|
if (sock_owned_by_user(sk) || !sctp_newsk_ready(sk)) {
|
2019-10-10 01:21:13 +03:00
|
|
|
if (sk_add_backlog(sk, skb, READ_ONCE(sk->sk_rcvbuf)))
|
2010-03-04 21:01:44 +03:00
|
|
|
sctp_chunk_free(chunk);
|
|
|
|
else
|
|
|
|
backloged = 1;
|
2006-05-19 22:01:18 +04:00
|
|
|
} else
|
|
|
|
sctp_inq_push(inqueue, chunk);
|
|
|
|
|
2014-01-21 11:44:12 +04:00
|
|
|
bh_unlock_sock(sk);
|
2016-07-23 06:32:48 +03:00
|
|
|
local_bh_enable();
|
2006-05-19 22:01:18 +04:00
|
|
|
|
|
|
|
/* If the chunk was backloged again, don't drop refs */
|
|
|
|
if (backloged)
|
|
|
|
return 0;
|
|
|
|
} else {
|
2019-10-08 14:09:23 +03:00
|
|
|
if (!sctp_newsk_ready(sk)) {
|
2019-10-10 01:21:13 +03:00
|
|
|
if (!sk_add_backlog(sk, skb, READ_ONCE(sk->sk_rcvbuf)))
|
2019-10-08 14:09:23 +03:00
|
|
|
return 0;
|
|
|
|
sctp_chunk_free(chunk);
|
|
|
|
} else {
|
|
|
|
sctp_inq_push(inqueue, chunk);
|
|
|
|
}
|
2006-05-19 22:01:18 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
/* Release the refs we took in sctp_add_backlog */
|
|
|
|
if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
sctp_transport_put(t);
|
2006-05-19 22:01:18 +04:00
|
|
|
else if (SCTP_EP_TYPE_SOCKET == rcvr->type)
|
|
|
|
sctp_endpoint_put(sctp_ep(rcvr));
|
|
|
|
else
|
|
|
|
BUG();
|
|
|
|
|
2007-02-09 17:25:18 +03:00
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2010-03-04 21:01:44 +03:00
|
|
|
static int sctp_add_backlog(struct sock *sk, struct sk_buff *skb)
|
2006-01-17 22:56:26 +03:00
|
|
|
{
|
2006-05-19 22:01:18 +04:00
|
|
|
struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
struct sctp_transport *t = chunk->transport;
|
2006-05-19 22:01:18 +04:00
|
|
|
struct sctp_ep_common *rcvr = chunk->rcvr;
|
2010-03-04 21:01:44 +03:00
|
|
|
int ret;
|
2006-01-17 22:56:26 +03:00
|
|
|
|
2019-10-10 01:21:13 +03:00
|
|
|
ret = sk_add_backlog(sk, skb, READ_ONCE(sk->sk_rcvbuf));
|
2010-03-04 21:01:44 +03: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: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
sctp_transport_hold(t);
|
2010-03-04 21:01:44 +03:00
|
|
|
else if (SCTP_EP_TYPE_SOCKET == rcvr->type)
|
|
|
|
sctp_endpoint_hold(sctp_ep(rcvr));
|
|
|
|
else
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
return ret;
|
2006-05-19 22:01:18 +04:00
|
|
|
|
2006-01-17 22:56:26 +03:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* Handle icmp frag needed error. */
|
|
|
|
void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc,
|
|
|
|
struct sctp_transport *t, __u32 pmtu)
|
|
|
|
{
|
sctp: do state transition when receiving an icmp TOOBIG packet
PLPMTUD will short-circuit the old process for icmp TOOBIG packets.
This part is described in rfc8899#section-4.6.2 (PL_PTB_SIZE =
PTB_SIZE - other_headers_len). Note that from rfc8899#section-5.2
State Machine, each case below is for some specific states only:
a) PL_PTB_SIZE < MIN_PLPMTU || PL_PTB_SIZE >= PROBED_SIZE,
discard it, for any state
b) MIN_PLPMTU < PL_PTB_SIZE < BASE_PLPMTU,
Base -> Error, for Base state
c) BASE_PLPMTU <= PL_PTB_SIZE < PLPMTU,
Search -> Base or Complete -> Base, for Search and Complete states.
d) PLPMTU < PL_PTB_SIZE < PROBED_SIZE,
set pl.probe_size to PL_PTB_SIZE then verify it, for Search state.
The most important one is case d), which will help find the optimal
fast during searching. Like when pathmtu = 1392 for SCTP over IPv4,
the search will be (20 is iphdr_len):
1. probe with 1200 - 20
2. probe with 1232 - 20
3. probe with 1264 - 20
...
7. probe with 1388 - 20
8. probe with 1420 - 20
When sending the probe with 1420 - 20, TOOBIG may come with PL_PTB_SIZE =
1392 - 20. Then it matches case d), and saves some rounds to try with the
1392 - 20 probe. But of course, PLPMTUD doesn't trust TOOBIG packets, and
it will go back to the common searching once the probe with the new size
can't be verified.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2021-06-22 21:04:55 +03:00
|
|
|
if (!t ||
|
|
|
|
(t->pathmtu <= pmtu &&
|
|
|
|
t->pl.probe_size + sctp_transport_pl_hlen(t) <= pmtu))
|
2005-12-22 22:36:46 +03:00
|
|
|
return;
|
|
|
|
|
2007-06-07 22:21:05 +04:00
|
|
|
if (sock_owned_by_user(sk)) {
|
2018-10-15 14:58:29 +03:00
|
|
|
atomic_set(&t->mtu_info, pmtu);
|
2007-06-07 22:21:05 +04:00
|
|
|
asoc->pmtu_pending = 1;
|
|
|
|
t->pmtu_pending = 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-01-05 16:17:17 +03:00
|
|
|
if (!(t->param_flags & SPP_PMTUD_ENABLE))
|
|
|
|
/* We can't allow retransmitting in such case, as the
|
|
|
|
* retransmission would be sized just as before, and thus we
|
|
|
|
* would get another icmp, and retransmit again.
|
|
|
|
*/
|
|
|
|
return;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
sctp: fix the handling of ICMP Frag Needed for too small MTUs
syzbot reported a hang involving SCTP, on which it kept flooding dmesg
with the message:
[ 246.742374] sctp: sctp_transport_update_pmtu: Reported pmtu 508 too
low, using default minimum of 512
That happened because whenever SCTP hits an ICMP Frag Needed, it tries
to adjust to the new MTU and triggers an immediate retransmission. But
it didn't consider the fact that MTUs smaller than the SCTP minimum MTU
allowed (512) would not cause the PMTU to change, and issued the
retransmission anyway (thus leading to another ICMP Frag Needed, and so
on).
As IPv4 (ip_rt_min_pmtu=556) and IPv6 (IPV6_MIN_MTU=1280) minimum MTU
are higher than that, sctp_transport_update_pmtu() is changed to
re-fetch the PMTU that got set after our request, and with that, detect
if there was an actual change or not.
The fix, thus, skips the immediate retransmission if the received ICMP
resulted in no change, in the hope that SCTP will select another path.
Note: The value being used for the minimum MTU (512,
SCTP_DEFAULT_MINSEGMENT) is not right and instead it should be (576,
SCTP_MIN_PMTU), but such change belongs to another patch.
Changes from v1:
- do not disable PMTU discovery, in the light of commit
06ad391919b2 ("[SCTP] Don't disable PMTU discovery when mtu is small")
and as suggested by Xin Long.
- changed the way to break the rtx loop by detecting if the icmp
resulted in a change or not
Changes from v2:
none
See-also: https://lkml.org/lkml/2017/12/22/811
Reported-by: syzbot <syzkaller@googlegroups.com>
Signed-off-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2018-01-05 16:17:18 +03:00
|
|
|
/* Update transports view of the MTU. Return if no update was needed.
|
|
|
|
* If an update wasn't needed/possible, it also doesn't make sense to
|
|
|
|
* try to retransmit now.
|
|
|
|
*/
|
|
|
|
if (!sctp_transport_update_pmtu(t, pmtu))
|
|
|
|
return;
|
2005-12-22 22:36:46 +03:00
|
|
|
|
2018-01-05 16:17:17 +03:00
|
|
|
/* Update association pmtu. */
|
|
|
|
sctp_assoc_sync_pmtu(asoc);
|
|
|
|
|
|
|
|
/* Retransmit with the new pmtu setting. */
|
2005-12-22 22:36:46 +03:00
|
|
|
sctp_retransmit(&asoc->outqueue, t, SCTP_RTXR_PMTUD);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2012-07-12 11:25:15 +04:00
|
|
|
void sctp_icmp_redirect(struct sock *sk, struct sctp_transport *t,
|
|
|
|
struct sk_buff *skb)
|
2012-07-12 08:27:49 +04:00
|
|
|
{
|
|
|
|
struct dst_entry *dst;
|
|
|
|
|
2017-10-18 16:37:49 +03:00
|
|
|
if (sock_owned_by_user(sk) || !t)
|
2012-07-12 08:27:49 +04:00
|
|
|
return;
|
|
|
|
dst = sctp_transport_dst_check(t);
|
2012-07-12 11:41:25 +04:00
|
|
|
if (dst)
|
2012-07-17 14:29:28 +04:00
|
|
|
dst->ops->redirect(dst, sk, skb);
|
2012-07-12 08:27:49 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04: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 17:25:18 +03:00
|
|
|
struct sctp_association *asoc,
|
|
|
|
struct sctp_transport *t)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2010-05-06 11:56:07 +04: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)))
|
2020-11-14 08:22:53 +03:00
|
|
|
sctp_transport_hold(t);
|
2010-05-06 11:56:07 +04:00
|
|
|
}
|
|
|
|
} else {
|
2012-08-07 11:25:24 +04: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 21:49:40 +04:00
|
|
|
pr_debug("%s: unrecognized next header type "
|
|
|
|
"encountered!\n", __func__);
|
|
|
|
|
2013-02-04 00:32:57 +04:00
|
|
|
if (del_timer(&t->proto_unreach_timer))
|
2020-11-14 08:22:53 +03:00
|
|
|
sctp_transport_put(t);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-08-07 11:25:24 +04:00
|
|
|
sctp_do_sm(net, SCTP_EVENT_T_OTHER,
|
2010-05-06 11:56:07 +04:00
|
|
|
SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),
|
|
|
|
asoc->state, asoc->ep, asoc, t,
|
|
|
|
GFP_ATOMIC);
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Common lookup code for icmp/icmpv6 error handler. */
|
2012-08-06 12:41:13 +04:00
|
|
|
struct sock *sctp_err_lookup(struct net *net, int family, struct sk_buff *skb,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct sctphdr *sctphdr,
|
|
|
|
struct sctp_association **app,
|
|
|
|
struct sctp_transport **tpp)
|
|
|
|
{
|
2017-05-25 20:14:56 +03:00
|
|
|
struct sctp_init_chunk *chunkhdr, _chunkhdr;
|
2005-04-17 02:20:36 +04:00
|
|
|
union sctp_addr saddr;
|
|
|
|
union sctp_addr daddr;
|
|
|
|
struct sctp_af *af;
|
|
|
|
struct sock *sk = NULL;
|
2006-05-19 21:58:12 +04:00
|
|
|
struct sctp_association *asoc;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct sctp_transport *transport = NULL;
|
2008-06-20 03:07:48 +04:00
|
|
|
__u32 vtag = ntohl(sctphdr->vtag);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2005-07-19 00:44:10 +04:00
|
|
|
*app = NULL; *tpp = NULL;
|
2005-04-17 02:20:36 +04: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 12:41:13 +04:00
|
|
|
asoc = __sctp_lookup_association(net, &saddr, &daddr, &transport);
|
2005-07-19 00:44:10 +04:00
|
|
|
if (!asoc)
|
|
|
|
return NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2005-07-19 00:44:10 +04:00
|
|
|
sk = asoc->base.sk;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-06-20 03:07:48 +04: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) {
|
2017-05-25 20:14:56 +03:00
|
|
|
/* chunk header + first 4 octects of init header */
|
|
|
|
chunkhdr = skb_header_pointer(skb, skb_transport_offset(skb) +
|
|
|
|
sizeof(struct sctphdr),
|
|
|
|
sizeof(struct sctp_chunkhdr) +
|
|
|
|
sizeof(__be32), &_chunkhdr);
|
|
|
|
if (!chunkhdr ||
|
2008-06-20 03:07:48 +04:00
|
|
|
chunkhdr->chunk_hdr.type != SCTP_CID_INIT ||
|
2017-05-25 20:14:56 +03:00
|
|
|
ntohl(chunkhdr->init_hdr.init_tag) != asoc->c.my_vtag)
|
2008-06-20 03:07:48 +04:00
|
|
|
goto out;
|
2017-05-25 20:14:56 +03:00
|
|
|
|
2008-06-20 03:07:48 +04:00
|
|
|
} else if (vtag != asoc->c.peer_vtag) {
|
2005-07-19 00:44:10 +04:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-01-21 11:44:12 +04:00
|
|
|
bh_lock_sock(sk);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* If too many ICMPs get dropped on busy
|
|
|
|
* servers this needs to be solved differently.
|
|
|
|
*/
|
|
|
|
if (sock_owned_by_user(sk))
|
2016-04-28 02:44:39 +03:00
|
|
|
__NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
*app = asoc;
|
|
|
|
*tpp = transport;
|
|
|
|
return sk;
|
|
|
|
|
|
|
|
out:
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
sctp_transport_put(transport);
|
2005-04-17 02:20:36 +04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Common cleanup code for icmp/icmpv6 error handler. */
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
void sctp_err_finish(struct sock *sk, struct sctp_transport *t)
|
2020-02-24 02:16:45 +03:00
|
|
|
__releases(&((__sk)->sk_lock.slock))
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2014-01-21 11:44:12 +04:00
|
|
|
bh_unlock_sock(sk);
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
sctp_transport_put(t);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2021-06-22 21:04:59 +03:00
|
|
|
static void sctp_v4_err_handle(struct sctp_transport *t, struct sk_buff *skb,
|
|
|
|
__u8 type, __u8 code, __u32 info)
|
|
|
|
{
|
|
|
|
struct sctp_association *asoc = t->asoc;
|
|
|
|
struct sock *sk = asoc->base.sk;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case ICMP_PARAMETERPROB:
|
|
|
|
err = EPROTO;
|
|
|
|
break;
|
|
|
|
case ICMP_DEST_UNREACH:
|
|
|
|
if (code > NR_ICMP_UNREACH)
|
|
|
|
return;
|
|
|
|
if (code == ICMP_FRAG_NEEDED) {
|
|
|
|
sctp_icmp_frag_needed(sk, asoc, t, SCTP_TRUNC4(info));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (code == ICMP_PROT_UNREACH) {
|
|
|
|
sctp_icmp_proto_unreachable(sk, asoc, t);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
err = icmp_err_convert[code].errno;
|
|
|
|
break;
|
|
|
|
case ICMP_TIME_EXCEEDED:
|
|
|
|
if (code == ICMP_EXC_FRAGTIME)
|
|
|
|
return;
|
|
|
|
|
|
|
|
err = EHOSTUNREACH;
|
|
|
|
break;
|
|
|
|
case ICMP_REDIRECT:
|
|
|
|
sctp_icmp_redirect(sk, t, skb);
|
Networking changes for 5.14.
Core:
- BPF:
- add syscall program type and libbpf support for generating
instructions and bindings for in-kernel BPF loaders (BPF loaders
for BPF), this is a stepping stone for signed BPF programs
- infrastructure to migrate TCP child sockets from one listener
to another in the same reuseport group/map to improve flexibility
of service hand-off/restart
- add broadcast support to XDP redirect
- allow bypass of the lockless qdisc to improving performance
(for pktgen: +23% with one thread, +44% with 2 threads)
- add a simpler version of "DO_ONCE()" which does not require
jump labels, intended for slow-path usage
- virtio/vsock: introduce SOCK_SEQPACKET support
- add getsocketopt to retrieve netns cookie
- ip: treat lowest address of a IPv4 subnet as ordinary unicast address
allowing reclaiming of precious IPv4 addresses
- ipv6: use prandom_u32() for ID generation
- ip: add support for more flexible field selection for hashing
across multi-path routes (w/ offload to mlxsw)
- icmp: add support for extended RFC 8335 PROBE (ping)
- seg6: add support for SRv6 End.DT46 behavior
- mptcp:
- DSS checksum support (RFC 8684) to detect middlebox meddling
- support Connection-time 'C' flag
- time stamping support
- sctp: packetization Layer Path MTU Discovery (RFC 8899)
- xfrm: speed up state addition with seq set
- WiFi:
- hidden AP discovery on 6 GHz and other HE 6 GHz improvements
- aggregation handling improvements for some drivers
- minstrel improvements for no-ack frames
- deferred rate control for TXQs to improve reaction times
- switch from round robin to virtual time-based airtime scheduler
- add trace points:
- tcp checksum errors
- openvswitch - action execution, upcalls
- socket errors via sk_error_report
Device APIs:
- devlink: add rate API for hierarchical control of max egress rate
of virtual devices (VFs, SFs etc.)
- don't require RCU read lock to be held around BPF hooks
in NAPI context
- page_pool: generic buffer recycling
New hardware/drivers:
- mobile:
- iosm: PCIe Driver for Intel M.2 Modem
- support for Qualcomm MSM8998 (ipa)
- WiFi: Qualcomm QCN9074 and WCN6855 PCI devices
- sparx5: Microchip SparX-5 family of Enterprise Ethernet switches
- Mellanox BlueField Gigabit Ethernet (control NIC of the DPU)
- NXP SJA1110 Automotive Ethernet 10-port switch
- Qualcomm QCA8327 switch support (qca8k)
- Mikrotik 10/25G NIC (atl1c)
Driver changes:
- ACPI support for some MDIO, MAC and PHY devices from Marvell and NXP
(our first foray into MAC/PHY description via ACPI)
- HW timestamping (PTP) support: bnxt_en, ice, sja1105, hns3, tja11xx
- Mellanox/Nvidia NIC (mlx5)
- NIC VF offload of L2 bridging
- support IRQ distribution to Sub-functions
- Marvell (prestera):
- add flower and match all
- devlink trap
- link aggregation
- Netronome (nfp): connection tracking offload
- Intel 1GE (igc): add AF_XDP support
- Marvell DPU (octeontx2): ingress ratelimit offload
- Google vNIC (gve): new ring/descriptor format support
- Qualcomm mobile (rmnet & ipa): inline checksum offload support
- MediaTek WiFi (mt76)
- mt7915 MSI support
- mt7915 Tx status reporting
- mt7915 thermal sensors support
- mt7921 decapsulation offload
- mt7921 enable runtime pm and deep sleep
- Realtek WiFi (rtw88)
- beacon filter support
- Tx antenna path diversity support
- firmware crash information via devcoredump
- Qualcomm 60GHz WiFi (wcn36xx)
- Wake-on-WLAN support with magic packets and GTK rekeying
- Micrel PHY (ksz886x/ksz8081): add cable test support
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEE6jPA+I1ugmIBA4hXMUZtbf5SIrsFAmDb+fUACgkQMUZtbf5S
Irs2Jg//aqN0Q8CgIvYCVhPxQw1tY7pTAbgyqgBZ01vwjyvtIOgJiWzSfFEU84mX
M8fcpFX5eTKrOyJ9S6UFfQ/JG114n3hjAxFFT4Hxk2gC1Tg0vHuFQTDHcUl28bUE
mTm61e1YpdorILnv2k5JVQ/wu0vs5QKDrjcYcrcPnh+j93wvnPOgAfDBV95nZzjS
OTt4q2fR8GzLcSYWWsclMbDNkzyTG50RW/0Yd6aGjr5QGvXfrMeXfUJNz533PMf/
w5lNyjRKv+x9mdTZJzU0+msNUrZgUdRz7W8Ey8lD3hJZRE+D6/uU7FtsE8Mi3+uc
HWxeZUyzA3YF1MfVl/eesbxyPT7S/OkLzk4O5B35FbqP0YltaP+bOjq1/nM3ce1/
io9Dx9pIl/2JANUgRCAtLi8Z2dkvRoqTaBxZ/nPudCCljFwDwl6joTMJ7Ow22i5Y
5aIkcXFmZq4LbJDiHvbTlqT7yiuaEvu2UK/23bSIg/K3nF4eAmkY9Y1EgiMf60OF
78Ttw0wk2tUegwaS5MZnCniKBKDyl9gM2F6rbZ/IxQRR2LTXFc1B6gC+ynUxgXfh
Ub8O++6qGYGYZ0XvQH4pzco79p3qQWBTK5beIp2eu6BOAjBVIXq4AibUfoQLACsu
hX7jMPYd0kc3WFgUnKgQP8EnjFSwbf4XiaE7fIXvWBY8hzCw2h4=
=LvtX
-----END PGP SIGNATURE-----
Merge tag 'net-next-5.14' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next
Pull networking updates from Jakub Kicinski:
"Core:
- BPF:
- add syscall program type and libbpf support for generating
instructions and bindings for in-kernel BPF loaders (BPF loaders
for BPF), this is a stepping stone for signed BPF programs
- infrastructure to migrate TCP child sockets from one listener to
another in the same reuseport group/map to improve flexibility
of service hand-off/restart
- add broadcast support to XDP redirect
- allow bypass of the lockless qdisc to improving performance (for
pktgen: +23% with one thread, +44% with 2 threads)
- add a simpler version of "DO_ONCE()" which does not require jump
labels, intended for slow-path usage
- virtio/vsock: introduce SOCK_SEQPACKET support
- add getsocketopt to retrieve netns cookie
- ip: treat lowest address of a IPv4 subnet as ordinary unicast
address allowing reclaiming of precious IPv4 addresses
- ipv6: use prandom_u32() for ID generation
- ip: add support for more flexible field selection for hashing
across multi-path routes (w/ offload to mlxsw)
- icmp: add support for extended RFC 8335 PROBE (ping)
- seg6: add support for SRv6 End.DT46 behavior
- mptcp:
- DSS checksum support (RFC 8684) to detect middlebox meddling
- support Connection-time 'C' flag
- time stamping support
- sctp: packetization Layer Path MTU Discovery (RFC 8899)
- xfrm: speed up state addition with seq set
- WiFi:
- hidden AP discovery on 6 GHz and other HE 6 GHz improvements
- aggregation handling improvements for some drivers
- minstrel improvements for no-ack frames
- deferred rate control for TXQs to improve reaction times
- switch from round robin to virtual time-based airtime scheduler
- add trace points:
- tcp checksum errors
- openvswitch - action execution, upcalls
- socket errors via sk_error_report
Device APIs:
- devlink: add rate API for hierarchical control of max egress rate
of virtual devices (VFs, SFs etc.)
- don't require RCU read lock to be held around BPF hooks in NAPI
context
- page_pool: generic buffer recycling
New hardware/drivers:
- mobile:
- iosm: PCIe Driver for Intel M.2 Modem
- support for Qualcomm MSM8998 (ipa)
- WiFi: Qualcomm QCN9074 and WCN6855 PCI devices
- sparx5: Microchip SparX-5 family of Enterprise Ethernet switches
- Mellanox BlueField Gigabit Ethernet (control NIC of the DPU)
- NXP SJA1110 Automotive Ethernet 10-port switch
- Qualcomm QCA8327 switch support (qca8k)
- Mikrotik 10/25G NIC (atl1c)
Driver changes:
- ACPI support for some MDIO, MAC and PHY devices from Marvell and
NXP (our first foray into MAC/PHY description via ACPI)
- HW timestamping (PTP) support: bnxt_en, ice, sja1105, hns3, tja11xx
- Mellanox/Nvidia NIC (mlx5)
- NIC VF offload of L2 bridging
- support IRQ distribution to Sub-functions
- Marvell (prestera):
- add flower and match all
- devlink trap
- link aggregation
- Netronome (nfp): connection tracking offload
- Intel 1GE (igc): add AF_XDP support
- Marvell DPU (octeontx2): ingress ratelimit offload
- Google vNIC (gve): new ring/descriptor format support
- Qualcomm mobile (rmnet & ipa): inline checksum offload support
- MediaTek WiFi (mt76)
- mt7915 MSI support
- mt7915 Tx status reporting
- mt7915 thermal sensors support
- mt7921 decapsulation offload
- mt7921 enable runtime pm and deep sleep
- Realtek WiFi (rtw88)
- beacon filter support
- Tx antenna path diversity support
- firmware crash information via devcoredump
- Qualcomm WiFi (wcn36xx)
- Wake-on-WLAN support with magic packets and GTK rekeying
- Micrel PHY (ksz886x/ksz8081): add cable test support"
* tag 'net-next-5.14' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next: (2168 commits)
tcp: change ICSK_CA_PRIV_SIZE definition
tcp_yeah: check struct yeah size at compile time
gve: DQO: Fix off by one in gve_rx_dqo()
stmmac: intel: set PCI_D3hot in suspend
stmmac: intel: Enable PHY WOL option in EHL
net: stmmac: option to enable PHY WOL with PMT enabled
net: say "local" instead of "static" addresses in ndo_dflt_fdb_{add,del}
net: use netdev_info in ndo_dflt_fdb_{add,del}
ptp: Set lookup cookie when creating a PTP PPS source.
net: sock: add trace for socket errors
net: sock: introduce sk_error_report
net: dsa: replay the local bridge FDB entries pointing to the bridge dev too
net: dsa: ensure during dsa_fdb_offload_notify that dev_hold and dev_put are on the same dev
net: dsa: include fdb entries pointing to bridge in the host fdb list
net: dsa: include bridge addresses which are local in the host fdb list
net: dsa: sync static FDB entries on foreign interfaces to hardware
net: dsa: install the host MDB and FDB entries in the master's RX filter
net: dsa: reference count the FDB addresses at the cross-chip notifier level
net: dsa: introduce a separate cross-chip notifier type for host FDBs
net: dsa: reference count the MDB entries at the cross-chip notifier level
...
2021-07-01 01:51:09 +03:00
|
|
|
return;
|
2021-06-22 21:04:59 +03:00
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!sock_owned_by_user(sk) && inet_sk(sk)->recverr) {
|
|
|
|
sk->sk_err = err;
|
2021-06-28 01:48:21 +03:00
|
|
|
sk_error_report(sk);
|
2021-06-22 21:04:59 +03:00
|
|
|
} else { /* Only an error on timeout */
|
|
|
|
sk->sk_err_soft = err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
2018-11-08 14:19:21 +03:00
|
|
|
int sctp_v4_err(struct sk_buff *skb, __u32 info)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-04-22 08:53:02 +04:00
|
|
|
const struct iphdr *iph = (const struct iphdr *)skb->data;
|
2007-03-13 20:43:18 +03:00
|
|
|
const int type = icmp_hdr(skb)->type;
|
|
|
|
const int code = icmp_hdr(skb)->code;
|
2021-06-22 21:04:59 +03:00
|
|
|
struct net *net = dev_net(skb->dev);
|
2005-04-17 02:20:36 +04:00
|
|
|
struct sctp_transport *transport;
|
2021-06-22 21:04:59 +03:00
|
|
|
struct sctp_association *asoc;
|
2013-05-31 00:36:11 +04:00
|
|
|
__u16 saveip, savesctp;
|
2021-06-22 21:04:59 +03:00
|
|
|
struct sock *sk;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Fix up skb to look at the embedded net header. */
|
2007-04-11 08:21:55 +04:00
|
|
|
saveip = skb->network_header;
|
|
|
|
savesctp = skb->transport_header;
|
2007-03-11 01:04:55 +03:00
|
|
|
skb_reset_network_header(skb);
|
2021-06-22 21:04:59 +03:00
|
|
|
skb_set_transport_header(skb, iph->ihl * 4);
|
2012-08-06 12:41:13 +04: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-11 08:22:35 +04:00
|
|
|
/* Put back, the original values. */
|
2007-04-11 08:21:55 +04:00
|
|
|
skb->network_header = saveip;
|
|
|
|
skb->transport_header = savesctp;
|
2005-04-17 02:20:36 +04:00
|
|
|
if (!sk) {
|
2016-04-28 02:44:29 +03:00
|
|
|
__ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
|
2018-11-08 14:19:21 +03:00
|
|
|
return -ENOENT;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2021-06-22 21:04:59 +03:00
|
|
|
sctp_v4_err_handle(transport, skb, type, code, info);
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
sctp_err_finish(sk, transport);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-11-08 14:19:21 +03:00
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2021-06-22 21:05:00 +03:00
|
|
|
int sctp_udp_v4_err(struct sock *sk, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct net *net = dev_net(skb->dev);
|
|
|
|
struct sctp_association *asoc;
|
|
|
|
struct sctp_transport *t;
|
|
|
|
struct icmphdr *hdr;
|
|
|
|
__u32 info = 0;
|
|
|
|
|
|
|
|
skb->transport_header += sizeof(struct udphdr);
|
|
|
|
sk = sctp_err_lookup(net, AF_INET, skb, sctp_hdr(skb), &asoc, &t);
|
|
|
|
if (!sk) {
|
|
|
|
__ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
|
|
|
|
return -ENOENT;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2021-06-22 21:05:00 +03:00
|
|
|
skb->transport_header -= sizeof(struct udphdr);
|
|
|
|
hdr = (struct icmphdr *)(skb_network_header(skb) - sizeof(struct icmphdr));
|
|
|
|
if (hdr->type == ICMP_REDIRECT) {
|
|
|
|
/* can't be handled without outer iphdr known, leave it to udp_err */
|
|
|
|
sctp_err_finish(sk, t);
|
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2021-06-22 21:05:00 +03:00
|
|
|
if (hdr->type == ICMP_DEST_UNREACH && hdr->code == ICMP_FRAG_NEEDED)
|
|
|
|
info = ntohs(hdr->un.frag.mtu);
|
|
|
|
sctp_v4_err_handle(t, skb, hdr->type, hdr->code, info);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2021-06-22 21:05:00 +03:00
|
|
|
sctp_err_finish(sk, t);
|
|
|
|
return 1;
|
2005-04-17 02:20:36 +04: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-27 01:21:31 +04:00
|
|
|
static int sctp_rcv_ootb(struct sk_buff *skb)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-06-30 06:52:13 +03:00
|
|
|
struct sctp_chunkhdr *ch, _ch;
|
2016-06-02 21:05:42 +03:00
|
|
|
int ch_end, offset = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Scan through all the chunks in the packet. */
|
2006-01-17 22:57:09 +03:00
|
|
|
do {
|
2016-06-02 21:05:42 +03:00
|
|
|
/* Make sure we have at least the header there */
|
2017-06-30 06:52:13 +03:00
|
|
|
if (offset + sizeof(_ch) > skb->len)
|
2016-06-02 21:05:42 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
ch = skb_header_pointer(skb, offset, sizeof(*ch), &_ch);
|
|
|
|
|
2006-01-17 22:57:09 +03:00
|
|
|
/* Break out if chunk length is less then minimal. */
|
2021-09-23 07:05:04 +03:00
|
|
|
if (!ch || ntohs(ch->length) < sizeof(_ch))
|
2006-01-17 22:57:09 +03:00
|
|
|
break;
|
|
|
|
|
2016-09-21 14:45:55 +03:00
|
|
|
ch_end = offset + SCTP_PAD4(ntohs(ch->length));
|
2016-06-02 21:05:42 +03:00
|
|
|
if (ch_end > skb->len)
|
2006-01-17 22:57:09 +03:00
|
|
|
break;
|
2005-04-17 02:20:36 +04: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 23:14:28 +04: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;
|
|
|
|
|
2016-06-02 21:05:42 +03:00
|
|
|
offset = ch_end;
|
|
|
|
} while (ch_end < skb->len);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
discard:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Insert endpoint into the hash table. */
|
2018-11-12 13:27:16 +03:00
|
|
|
static int __sctp_hash_endpoint(struct sctp_endpoint *ep)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2018-11-12 13:27:16 +03:00
|
|
|
struct sock *sk = ep->base.sk;
|
|
|
|
struct net *net = sock_net(sk);
|
2005-04-17 02:20:36 +04:00
|
|
|
struct sctp_hashbucket *head;
|
|
|
|
|
2021-12-22 00:40:30 +03:00
|
|
|
ep->hashent = sctp_ep_hashfn(net, ep->base.bind_addr.port);
|
|
|
|
head = &sctp_ep_hashtable[ep->hashent];
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-11-12 13:27:16 +03:00
|
|
|
if (sk->sk_reuseport) {
|
|
|
|
bool any = sctp_is_ep_boundall(sk);
|
2021-12-22 00:40:30 +03:00
|
|
|
struct sctp_endpoint *ep2;
|
2018-11-12 13:27:16 +03:00
|
|
|
struct list_head *list;
|
|
|
|
int cnt = 0, err = 1;
|
|
|
|
|
|
|
|
list_for_each(list, &ep->base.bind_addr.address_list)
|
|
|
|
cnt++;
|
|
|
|
|
2021-12-22 00:40:30 +03:00
|
|
|
sctp_for_each_hentry(ep2, &head->chain) {
|
|
|
|
struct sock *sk2 = ep2->base.sk;
|
2018-11-12 13:27:16 +03:00
|
|
|
|
|
|
|
if (!net_eq(sock_net(sk2), net) || sk2 == sk ||
|
|
|
|
!uid_eq(sock_i_uid(sk2), sock_i_uid(sk)) ||
|
|
|
|
!sk2->sk_reuseport)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
err = sctp_bind_addrs_check(sctp_sk(sk2),
|
|
|
|
sctp_sk(sk), cnt);
|
|
|
|
if (!err) {
|
|
|
|
err = reuseport_add_sock(sk, sk2, any);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
break;
|
|
|
|
} else if (err < 0) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
err = reuseport_alloc(sk, any);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-21 11:44:09 +04:00
|
|
|
write_lock(&head->lock);
|
2021-12-22 00:40:30 +03:00
|
|
|
hlist_add_head(&ep->node, &head->chain);
|
2014-01-21 11:44:09 +04:00
|
|
|
write_unlock(&head->lock);
|
2018-11-12 13:27:16 +03:00
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Add an endpoint to the hash. Local BH-safe. */
|
2018-11-12 13:27:16 +03:00
|
|
|
int sctp_hash_endpoint(struct sctp_endpoint *ep)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2018-11-12 13:27:16 +03:00
|
|
|
int err;
|
|
|
|
|
2014-01-21 11:44:07 +04:00
|
|
|
local_bh_disable();
|
2018-11-12 13:27:16 +03:00
|
|
|
err = __sctp_hash_endpoint(ep);
|
2014-01-21 11:44:07 +04:00
|
|
|
local_bh_enable();
|
2018-11-12 13:27:16 +03:00
|
|
|
|
|
|
|
return err;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove endpoint from the hash table. */
|
|
|
|
static void __sctp_unhash_endpoint(struct sctp_endpoint *ep)
|
|
|
|
{
|
2018-11-12 13:27:16 +03:00
|
|
|
struct sock *sk = ep->base.sk;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct sctp_hashbucket *head;
|
|
|
|
|
2021-12-22 00:40:30 +03:00
|
|
|
ep->hashent = sctp_ep_hashfn(sock_net(sk), ep->base.bind_addr.port);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2021-12-22 00:40:30 +03:00
|
|
|
head = &sctp_ep_hashtable[ep->hashent];
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-11-12 13:27:16 +03:00
|
|
|
if (rcu_access_pointer(sk->sk_reuseport_cb))
|
|
|
|
reuseport_detach_sock(sk);
|
|
|
|
|
2014-01-21 11:44:09 +04:00
|
|
|
write_lock(&head->lock);
|
2021-12-22 00:40:30 +03:00
|
|
|
hlist_del_init(&ep->node);
|
2014-01-21 11:44:09 +04:00
|
|
|
write_unlock(&head->lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove endpoint from the hash. Local BH-safe. */
|
|
|
|
void sctp_unhash_endpoint(struct sctp_endpoint *ep)
|
|
|
|
{
|
2014-01-21 11:44:07 +04:00
|
|
|
local_bh_disable();
|
2005-04-17 02:20:36 +04:00
|
|
|
__sctp_unhash_endpoint(ep);
|
2014-01-21 11:44:07 +04:00
|
|
|
local_bh_enable();
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2018-11-12 13:27:15 +03:00
|
|
|
static inline __u32 sctp_hashfn(const struct net *net, __be16 lport,
|
|
|
|
const union sctp_addr *paddr, __u32 seed)
|
|
|
|
{
|
|
|
|
__u32 addr;
|
|
|
|
|
|
|
|
if (paddr->sa.sa_family == AF_INET6)
|
|
|
|
addr = jhash(&paddr->v6.sin6_addr, 16, seed);
|
|
|
|
else
|
|
|
|
addr = (__force __u32)paddr->v4.sin_addr.s_addr;
|
|
|
|
|
|
|
|
return jhash_3words(addr, ((__force __u32)paddr->v4.sin_port) << 16 |
|
|
|
|
(__force __u32)lport, net_hash_mix(net), seed);
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* Look up an endpoint. */
|
2018-11-12 13:27:15 +03:00
|
|
|
static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(
|
|
|
|
struct net *net, struct sk_buff *skb,
|
|
|
|
const union sctp_addr *laddr,
|
|
|
|
const union sctp_addr *paddr)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct sctp_hashbucket *head;
|
|
|
|
struct sctp_endpoint *ep;
|
2018-11-12 13:27:15 +03:00
|
|
|
struct sock *sk;
|
|
|
|
__be16 lport;
|
2005-04-17 02:20:36 +04:00
|
|
|
int hash;
|
|
|
|
|
2018-11-12 13:27:15 +03:00
|
|
|
lport = laddr->v4.sin_port;
|
|
|
|
hash = sctp_ep_hashfn(net, ntohs(lport));
|
2005-04-17 02:20:36 +04:00
|
|
|
head = &sctp_ep_hashtable[hash];
|
|
|
|
read_lock(&head->lock);
|
2021-12-22 00:40:30 +03:00
|
|
|
sctp_for_each_hentry(ep, &head->chain) {
|
2012-08-06 12:40:21 +04:00
|
|
|
if (sctp_endpoint_is_match(ep, net, laddr))
|
2005-04-17 02:20:36 +04:00
|
|
|
goto hit;
|
|
|
|
}
|
|
|
|
|
2012-08-06 12:43:06 +04:00
|
|
|
ep = sctp_sk(net->sctp.ctl_sock)->ep;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
hit:
|
2018-11-12 13:27:15 +03:00
|
|
|
sk = ep->base.sk;
|
|
|
|
if (sk->sk_reuseport) {
|
|
|
|
__u32 phash = sctp_hashfn(net, lport, paddr, 0);
|
|
|
|
|
|
|
|
sk = reuseport_select_sock(sk, phash, skb,
|
|
|
|
sizeof(struct sctphdr));
|
|
|
|
if (sk)
|
|
|
|
ep = sctp_sk(sk)->ep;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
sctp_endpoint_hold(ep);
|
|
|
|
read_unlock(&head->lock);
|
|
|
|
return ep;
|
|
|
|
}
|
|
|
|
|
2015-12-30 18:50:46 +03:00
|
|
|
/* rhashtable for transport */
|
|
|
|
struct sctp_hash_cmp_arg {
|
2016-11-15 18:23:11 +03:00
|
|
|
const union sctp_addr *paddr;
|
|
|
|
const struct net *net;
|
2017-10-28 14:43:55 +03:00
|
|
|
__be16 lport;
|
2015-12-30 18:50:46 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline int sctp_hash_cmp(struct rhashtable_compare_arg *arg,
|
|
|
|
const void *ptr)
|
|
|
|
{
|
sctp: hold the transport before using it in sctp_hash_cmp
Since commit 4f0087812648 ("sctp: apply rhashtable api to send/recv
path"), sctp uses transport rhashtable with .obj_cmpfn sctp_hash_cmp,
in which it compares the members of the transport with the rhashtable
args to check if it's the right transport.
But sctp uses the transport without holding it in sctp_hash_cmp, it can
cause a use-after-free panic. As after it gets transport from hashtable,
another CPU may close the sk and free the asoc. In sctp_association_free,
it frees all the transports, meanwhile, the assoc's refcnt may be reduced
to 0, assoc can be destroyed by sctp_association_destroy.
So after that, transport->assoc is actually an unavailable memory address
in sctp_hash_cmp. Although sctp_hash_cmp is under rcu_read_lock, it still
can not avoid this, as assoc is not freed by RCU.
This patch is to hold the transport before checking it's members with
sctp_transport_hold, in which it checks the refcnt first, holds it if
it's not 0.
Fixes: 4f0087812648 ("sctp: apply rhashtable api to send/recv path")
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-09-10 18:11:23 +03:00
|
|
|
struct sctp_transport *t = (struct sctp_transport *)ptr;
|
2015-12-30 18:50:46 +03:00
|
|
|
const struct sctp_hash_cmp_arg *x = arg->key;
|
sctp: hold the transport before using it in sctp_hash_cmp
Since commit 4f0087812648 ("sctp: apply rhashtable api to send/recv
path"), sctp uses transport rhashtable with .obj_cmpfn sctp_hash_cmp,
in which it compares the members of the transport with the rhashtable
args to check if it's the right transport.
But sctp uses the transport without holding it in sctp_hash_cmp, it can
cause a use-after-free panic. As after it gets transport from hashtable,
another CPU may close the sk and free the asoc. In sctp_association_free,
it frees all the transports, meanwhile, the assoc's refcnt may be reduced
to 0, assoc can be destroyed by sctp_association_destroy.
So after that, transport->assoc is actually an unavailable memory address
in sctp_hash_cmp. Although sctp_hash_cmp is under rcu_read_lock, it still
can not avoid this, as assoc is not freed by RCU.
This patch is to hold the transport before checking it's members with
sctp_transport_hold, in which it checks the refcnt first, holds it if
it's not 0.
Fixes: 4f0087812648 ("sctp: apply rhashtable api to send/recv path")
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-09-10 18:11:23 +03:00
|
|
|
int err = 1;
|
2015-12-30 18:50:46 +03:00
|
|
|
|
|
|
|
if (!sctp_cmp_addr_exact(&t->ipaddr, x->paddr))
|
sctp: hold the transport before using it in sctp_hash_cmp
Since commit 4f0087812648 ("sctp: apply rhashtable api to send/recv
path"), sctp uses transport rhashtable with .obj_cmpfn sctp_hash_cmp,
in which it compares the members of the transport with the rhashtable
args to check if it's the right transport.
But sctp uses the transport without holding it in sctp_hash_cmp, it can
cause a use-after-free panic. As after it gets transport from hashtable,
another CPU may close the sk and free the asoc. In sctp_association_free,
it frees all the transports, meanwhile, the assoc's refcnt may be reduced
to 0, assoc can be destroyed by sctp_association_destroy.
So after that, transport->assoc is actually an unavailable memory address
in sctp_hash_cmp. Although sctp_hash_cmp is under rcu_read_lock, it still
can not avoid this, as assoc is not freed by RCU.
This patch is to hold the transport before checking it's members with
sctp_transport_hold, in which it checks the refcnt first, holds it if
it's not 0.
Fixes: 4f0087812648 ("sctp: apply rhashtable api to send/recv path")
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-09-10 18:11:23 +03:00
|
|
|
return err;
|
|
|
|
if (!sctp_transport_hold(t))
|
|
|
|
return err;
|
|
|
|
|
2019-11-23 06:56:49 +03:00
|
|
|
if (!net_eq(t->asoc->base.net, x->net))
|
2016-11-15 18:23:11 +03:00
|
|
|
goto out;
|
|
|
|
if (x->lport != htons(t->asoc->base.bind_addr.port))
|
sctp: hold the transport before using it in sctp_hash_cmp
Since commit 4f0087812648 ("sctp: apply rhashtable api to send/recv
path"), sctp uses transport rhashtable with .obj_cmpfn sctp_hash_cmp,
in which it compares the members of the transport with the rhashtable
args to check if it's the right transport.
But sctp uses the transport without holding it in sctp_hash_cmp, it can
cause a use-after-free panic. As after it gets transport from hashtable,
another CPU may close the sk and free the asoc. In sctp_association_free,
it frees all the transports, meanwhile, the assoc's refcnt may be reduced
to 0, assoc can be destroyed by sctp_association_destroy.
So after that, transport->assoc is actually an unavailable memory address
in sctp_hash_cmp. Although sctp_hash_cmp is under rcu_read_lock, it still
can not avoid this, as assoc is not freed by RCU.
This patch is to hold the transport before checking it's members with
sctp_transport_hold, in which it checks the refcnt first, holds it if
it's not 0.
Fixes: 4f0087812648 ("sctp: apply rhashtable api to send/recv path")
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-09-10 18:11:23 +03:00
|
|
|
goto out;
|
2015-12-30 18:50:46 +03:00
|
|
|
|
sctp: hold the transport before using it in sctp_hash_cmp
Since commit 4f0087812648 ("sctp: apply rhashtable api to send/recv
path"), sctp uses transport rhashtable with .obj_cmpfn sctp_hash_cmp,
in which it compares the members of the transport with the rhashtable
args to check if it's the right transport.
But sctp uses the transport without holding it in sctp_hash_cmp, it can
cause a use-after-free panic. As after it gets transport from hashtable,
another CPU may close the sk and free the asoc. In sctp_association_free,
it frees all the transports, meanwhile, the assoc's refcnt may be reduced
to 0, assoc can be destroyed by sctp_association_destroy.
So after that, transport->assoc is actually an unavailable memory address
in sctp_hash_cmp. Although sctp_hash_cmp is under rcu_read_lock, it still
can not avoid this, as assoc is not freed by RCU.
This patch is to hold the transport before checking it's members with
sctp_transport_hold, in which it checks the refcnt first, holds it if
it's not 0.
Fixes: 4f0087812648 ("sctp: apply rhashtable api to send/recv path")
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-09-10 18:11:23 +03:00
|
|
|
err = 0;
|
|
|
|
out:
|
|
|
|
sctp_transport_put(t);
|
|
|
|
return err;
|
2015-12-30 18:50:46 +03:00
|
|
|
}
|
|
|
|
|
2017-10-28 14:43:55 +03:00
|
|
|
static inline __u32 sctp_hash_obj(const void *data, u32 len, u32 seed)
|
2015-12-30 18:50:46 +03:00
|
|
|
{
|
|
|
|
const struct sctp_transport *t = data;
|
|
|
|
|
2019-11-23 06:56:49 +03:00
|
|
|
return sctp_hashfn(t->asoc->base.net,
|
2018-11-12 13:27:15 +03:00
|
|
|
htons(t->asoc->base.bind_addr.port),
|
|
|
|
&t->ipaddr, seed);
|
2015-12-30 18:50:46 +03:00
|
|
|
}
|
|
|
|
|
2017-10-28 14:43:55 +03:00
|
|
|
static inline __u32 sctp_hash_key(const void *data, u32 len, u32 seed)
|
2015-12-30 18:50:46 +03:00
|
|
|
{
|
|
|
|
const struct sctp_hash_cmp_arg *x = data;
|
|
|
|
|
2018-11-12 13:27:15 +03:00
|
|
|
return sctp_hashfn(x->net, x->lport, x->paddr, seed);
|
2015-12-30 18:50:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct rhashtable_params sctp_hash_params = {
|
|
|
|
.head_offset = offsetof(struct sctp_transport, node),
|
|
|
|
.hashfn = sctp_hash_key,
|
|
|
|
.obj_hashfn = sctp_hash_obj,
|
|
|
|
.obj_cmpfn = sctp_hash_cmp,
|
|
|
|
.automatic_shrinking = true,
|
|
|
|
};
|
|
|
|
|
|
|
|
int sctp_transport_hashtable_init(void)
|
|
|
|
{
|
2016-11-15 18:23:11 +03:00
|
|
|
return rhltable_init(&sctp_transport_hashtable, &sctp_hash_params);
|
2015-12-30 18:50:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void sctp_transport_hashtable_destroy(void)
|
|
|
|
{
|
2016-11-15 18:23:11 +03:00
|
|
|
rhltable_destroy(&sctp_transport_hashtable);
|
2015-12-30 18:50:46 +03:00
|
|
|
}
|
|
|
|
|
2016-11-15 18:23:11 +03:00
|
|
|
int sctp_hash_transport(struct sctp_transport *t)
|
2015-12-30 18:50:46 +03:00
|
|
|
{
|
2017-02-17 11:35:24 +03:00
|
|
|
struct sctp_transport *transport;
|
|
|
|
struct rhlist_head *tmp, *list;
|
2015-12-30 18:50:46 +03:00
|
|
|
struct sctp_hash_cmp_arg arg;
|
2016-11-15 18:23:11 +03:00
|
|
|
int err;
|
2015-12-30 18:50:46 +03:00
|
|
|
|
2016-01-16 15:17:17 +03:00
|
|
|
if (t->asoc->temp)
|
2016-11-15 18:23:11 +03:00
|
|
|
return 0;
|
2016-01-16 15:17:17 +03:00
|
|
|
|
2019-12-09 08:45:18 +03:00
|
|
|
arg.net = t->asoc->base.net;
|
2016-11-15 18:23:11 +03:00
|
|
|
arg.paddr = &t->ipaddr;
|
|
|
|
arg.lport = htons(t->asoc->base.bind_addr.port);
|
2015-12-30 18:50:46 +03:00
|
|
|
|
2017-02-28 07:41:29 +03:00
|
|
|
rcu_read_lock();
|
2017-02-17 11:35:24 +03:00
|
|
|
list = rhltable_lookup(&sctp_transport_hashtable, &arg,
|
|
|
|
sctp_hash_params);
|
|
|
|
|
|
|
|
rhl_for_each_entry_rcu(transport, tmp, list, node)
|
|
|
|
if (transport->asoc->ep == t->asoc->ep) {
|
2017-02-28 07:41:29 +03:00
|
|
|
rcu_read_unlock();
|
2018-02-12 13:29:06 +03:00
|
|
|
return -EEXIST;
|
2017-02-17 11:35:24 +03:00
|
|
|
}
|
2017-02-28 07:41:29 +03:00
|
|
|
rcu_read_unlock();
|
2017-02-17 11:35:24 +03:00
|
|
|
|
2016-11-15 18:23:11 +03:00
|
|
|
err = rhltable_insert_key(&sctp_transport_hashtable, &arg,
|
|
|
|
&t->node, sctp_hash_params);
|
|
|
|
if (err)
|
|
|
|
pr_err_once("insert transport fail, errno %d\n", err);
|
|
|
|
|
|
|
|
return err;
|
2015-12-30 18:50:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void sctp_unhash_transport(struct sctp_transport *t)
|
|
|
|
{
|
2016-01-16 15:17:17 +03:00
|
|
|
if (t->asoc->temp)
|
|
|
|
return;
|
|
|
|
|
2016-11-15 18:23:11 +03:00
|
|
|
rhltable_remove(&sctp_transport_hashtable, &t->node,
|
|
|
|
sctp_hash_params);
|
2015-12-30 18:50:46 +03:00
|
|
|
}
|
|
|
|
|
2016-11-15 18:23:11 +03:00
|
|
|
/* return a transport with holding it */
|
2015-12-30 18:50:46 +03:00
|
|
|
struct sctp_transport *sctp_addrs_lookup_transport(
|
|
|
|
struct net *net,
|
|
|
|
const union sctp_addr *laddr,
|
|
|
|
const union sctp_addr *paddr)
|
|
|
|
{
|
2016-11-15 18:23:11 +03:00
|
|
|
struct rhlist_head *tmp, *list;
|
|
|
|
struct sctp_transport *t;
|
2015-12-30 18:50:46 +03:00
|
|
|
struct sctp_hash_cmp_arg arg = {
|
|
|
|
.paddr = paddr,
|
|
|
|
.net = net,
|
2016-11-15 18:23:11 +03:00
|
|
|
.lport = laddr->v4.sin_port,
|
2015-12-30 18:50:46 +03:00
|
|
|
};
|
|
|
|
|
2016-11-15 18:23:11 +03:00
|
|
|
list = rhltable_lookup(&sctp_transport_hashtable, &arg,
|
|
|
|
sctp_hash_params);
|
|
|
|
|
|
|
|
rhl_for_each_entry_rcu(t, tmp, list, node) {
|
|
|
|
if (!sctp_transport_hold(t))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sctp_bind_addr_match(&t->asoc->base.bind_addr,
|
|
|
|
laddr, sctp_sk(t->asoc->base.sk)))
|
|
|
|
return t;
|
|
|
|
sctp_transport_put(t);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
2015-12-30 18:50:46 +03:00
|
|
|
}
|
|
|
|
|
2016-11-15 18:23:11 +03:00
|
|
|
/* return a transport without holding it, as it's only used under sock lock */
|
2015-12-30 18:50:46 +03:00
|
|
|
struct sctp_transport *sctp_epaddr_lookup_transport(
|
|
|
|
const struct sctp_endpoint *ep,
|
|
|
|
const union sctp_addr *paddr)
|
|
|
|
{
|
2016-11-15 18:23:11 +03:00
|
|
|
struct rhlist_head *tmp, *list;
|
|
|
|
struct sctp_transport *t;
|
2016-01-14 08:49:34 +03:00
|
|
|
struct sctp_hash_cmp_arg arg = {
|
|
|
|
.paddr = paddr,
|
2019-12-09 08:45:18 +03:00
|
|
|
.net = ep->base.net,
|
2016-11-15 18:23:11 +03:00
|
|
|
.lport = htons(ep->base.bind_addr.port),
|
2016-01-14 08:49:34 +03:00
|
|
|
};
|
2015-12-30 18:50:46 +03:00
|
|
|
|
2016-11-15 18:23:11 +03:00
|
|
|
list = rhltable_lookup(&sctp_transport_hashtable, &arg,
|
|
|
|
sctp_hash_params);
|
|
|
|
|
|
|
|
rhl_for_each_entry_rcu(t, tmp, list, node)
|
|
|
|
if (ep == t->asoc->ep)
|
|
|
|
return t;
|
|
|
|
|
|
|
|
return NULL;
|
2015-12-30 18:50:46 +03:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* Look up an association. */
|
|
|
|
static struct sctp_association *__sctp_lookup_association(
|
2012-08-06 12:41:13 +04:00
|
|
|
struct net *net,
|
2005-04-17 02:20:36 +04:00
|
|
|
const union sctp_addr *local,
|
|
|
|
const union sctp_addr *peer,
|
|
|
|
struct sctp_transport **pt)
|
|
|
|
{
|
2015-12-30 18:50:47 +03:00
|
|
|
struct sctp_transport *t;
|
2016-01-21 20:49:07 +03:00
|
|
|
struct sctp_association *asoc = NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-12-30 18:50:47 +03:00
|
|
|
t = sctp_addrs_lookup_transport(net, local, peer);
|
2016-11-15 18:23:11 +03:00
|
|
|
if (!t)
|
2016-01-21 20:49:07 +03:00
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-01-21 20:49:07 +03:00
|
|
|
asoc = t->asoc;
|
2015-12-30 18:50:47 +03:00
|
|
|
*pt = t;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-01-21 20:49:07 +03:00
|
|
|
out:
|
|
|
|
return asoc;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2015-12-30 18:50:47 +03:00
|
|
|
/* Look up an association. protected by RCU read lock */
|
2013-06-17 13:40:05 +04:00
|
|
|
static
|
2012-08-06 12:41:13 +04:00
|
|
|
struct sctp_association *sctp_lookup_association(struct net *net,
|
|
|
|
const union sctp_addr *laddr,
|
2005-04-17 02:20:36 +04:00
|
|
|
const union sctp_addr *paddr,
|
2013-06-17 13:40:05 +04:00
|
|
|
struct sctp_transport **transportp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct sctp_association *asoc;
|
|
|
|
|
2016-02-15 09:28:03 +03:00
|
|
|
rcu_read_lock();
|
2012-08-06 12:41:13 +04:00
|
|
|
asoc = __sctp_lookup_association(net, laddr, paddr, transportp);
|
2016-02-15 09:28:03 +03:00
|
|
|
rcu_read_unlock();
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
return asoc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is there an association matching the given local and peer addresses? */
|
2018-03-26 11:55:00 +03:00
|
|
|
bool sctp_has_association(struct net *net,
|
|
|
|
const union sctp_addr *laddr,
|
|
|
|
const union sctp_addr *paddr)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct sctp_transport *transport;
|
|
|
|
|
2018-03-26 11:55:00 +03:00
|
|
|
if (sctp_lookup_association(net, laddr, paddr, &transport)) {
|
sctp: hold transport instead of assoc when lookup assoc in rx path
Prior to this patch, in rx path, before calling lock_sock, it needed to
hold assoc when got it by __sctp_lookup_association, in case other place
would free/put assoc.
But in __sctp_lookup_association, it lookup and hold transport, then got
assoc by transport->assoc, then hold assoc and put transport. It means
it didn't hold transport, yet it was returned and later on directly
assigned to chunk->transport.
Without the protection of sock lock, the transport may be freed/put by
other places, which would cause a use-after-free issue.
This patch is to fix this issue by holding transport instead of assoc.
As holding transport can make sure to access assoc is also safe, and
actually it looks up assoc by searching transport rhashtable, to hold
transport here makes more sense.
Note that the function will be renamed later on on another patch.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-10-31 15:32:33 +03:00
|
|
|
sctp_transport_put(transport);
|
2018-03-26 11:55:00 +03:00
|
|
|
return true;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2018-03-26 11:55:00 +03:00
|
|
|
return false;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 12:41:13 +04:00
|
|
|
static struct sctp_association *__sctp_rcv_init_lookup(struct net *net,
|
|
|
|
struct sk_buff *skb,
|
2005-04-17 02:20:36 +04: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 19:59:32 +03:00
|
|
|
struct sctphdr *sh = sctp_hdr(skb);
|
2005-04-17 02:20:36 +04:00
|
|
|
union sctp_params params;
|
2017-06-30 06:52:22 +03:00
|
|
|
struct sctp_init_chunk *init;
|
2005-04-17 02:20:36 +04:00
|
|
|
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.
|
|
|
|
*/
|
2017-06-30 06:52:22 +03:00
|
|
|
init = (struct sctp_init_chunk *)skb->data;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
2021-06-28 22:13:41 +03:00
|
|
|
if (!af->from_addr_param(paddr, params.addr, sh->source, 0))
|
|
|
|
continue;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-10-31 15:32:32 +03:00
|
|
|
asoc = __sctp_lookup_association(net, laddr, paddr, transportp);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (asoc)
|
|
|
|
return asoc;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-12-21 01:10:38 +03: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 12:41:13 +04:00
|
|
|
struct net *net,
|
2017-06-30 06:52:13 +03:00
|
|
|
struct sctp_chunkhdr *ch,
|
2007-12-21 01:10:38 +03:00
|
|
|
const union sctp_addr *laddr,
|
2008-03-18 08:47:32 +03:00
|
|
|
__be16 peer_port,
|
2007-12-21 01:10:38 +03:00
|
|
|
struct sctp_transport **transportp)
|
|
|
|
{
|
2017-08-03 10:42:20 +03:00
|
|
|
struct sctp_addip_chunk *asconf = (struct sctp_addip_chunk *)ch;
|
2007-12-21 01:10:38 +03:00
|
|
|
struct sctp_af *af;
|
|
|
|
union sctp_addr_param *param;
|
|
|
|
union sctp_addr paddr;
|
|
|
|
|
2021-06-28 22:13:43 +03:00
|
|
|
if (ntohs(ch->length) < sizeof(*asconf) + sizeof(struct sctp_paramhdr))
|
|
|
|
return NULL;
|
|
|
|
|
2007-12-21 01:10:38 +03:00
|
|
|
/* Skip over the ADDIP header and find the Address parameter */
|
|
|
|
param = (union sctp_addr_param *)(asconf + 1);
|
|
|
|
|
2011-04-18 23:11:47 +04:00
|
|
|
af = sctp_get_af_specific(param_type2af(param->p.type));
|
2007-12-21 01:10:38 +03:00
|
|
|
if (unlikely(!af))
|
|
|
|
return NULL;
|
|
|
|
|
2021-07-28 05:40:54 +03:00
|
|
|
if (!af->from_addr_param(&paddr, param, peer_port, 0))
|
2021-06-28 22:13:41 +03:00
|
|
|
return NULL;
|
2007-12-21 01:10:38 +03:00
|
|
|
|
2012-08-06 12:41:13 +04:00
|
|
|
return __sctp_lookup_association(net, laddr, &paddr, transportp);
|
2007-12-21 01:10:38 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-04 04:51:34 +04: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-31 05:57:33 +04:00
|
|
|
* to be looked at to find this association.
|
2007-10-04 04:51:34 +04:00
|
|
|
*/
|
2012-08-06 12:41:13 +04:00
|
|
|
static struct sctp_association *__sctp_rcv_walk_lookup(struct net *net,
|
|
|
|
struct sk_buff *skb,
|
2007-10-04 04:51:34 +04:00
|
|
|
const union sctp_addr *laddr,
|
|
|
|
struct sctp_transport **transportp)
|
|
|
|
{
|
2007-12-21 01:10:38 +03:00
|
|
|
struct sctp_association *asoc = NULL;
|
2017-06-30 06:52:13 +03:00
|
|
|
struct sctp_chunkhdr *ch;
|
2007-12-21 01:10:38 +03:00
|
|
|
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-04 04:51:34 +04:00
|
|
|
*/
|
2017-06-30 06:52:13 +03:00
|
|
|
ch = (struct sctp_chunkhdr *)skb->data;
|
2007-12-21 01:10:38 +03:00
|
|
|
do {
|
|
|
|
/* Break out if chunk length is less then minimal. */
|
2017-06-30 06:52:13 +03:00
|
|
|
if (ntohs(ch->length) < sizeof(*ch))
|
2007-12-21 01:10:38 +03:00
|
|
|
break;
|
|
|
|
|
2016-09-21 14:45:55 +03:00
|
|
|
ch_end = ((__u8 *)ch) + SCTP_PAD4(ntohs(ch->length));
|
2007-12-21 01:10:38 +03:00
|
|
|
if (ch_end > skb_tail_pointer(skb))
|
|
|
|
break;
|
|
|
|
|
2013-12-23 08:16:50 +04:00
|
|
|
switch (ch->type) {
|
2013-12-23 08:16:52 +04:00
|
|
|
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:
|
|
|
|
if (have_auth || net->sctp.addip_noauth)
|
|
|
|
asoc = __sctp_rcv_asconf_lookup(
|
|
|
|
net, ch, laddr,
|
|
|
|
sctp_hdr(skb)->source,
|
|
|
|
transportp);
|
2020-11-20 21:39:41 +03:00
|
|
|
break;
|
2013-12-23 08:16:52 +04:00
|
|
|
default:
|
|
|
|
break;
|
2007-12-21 01:10:38 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (asoc)
|
|
|
|
break;
|
|
|
|
|
2017-06-30 06:52:13 +03:00
|
|
|
ch = (struct sctp_chunkhdr *)ch_end;
|
2007-12-21 01:10:38 +03:00
|
|
|
chunk_num++;
|
2021-06-28 22:13:42 +03:00
|
|
|
} while (ch_end + sizeof(*ch) < skb_tail_pointer(skb));
|
2007-12-21 01:10:38 +03:00
|
|
|
|
|
|
|
return asoc;
|
2007-10-04 04:51:34 +04: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 12:41:13 +04:00
|
|
|
static struct sctp_association *__sctp_rcv_lookup_harder(struct net *net,
|
|
|
|
struct sk_buff *skb,
|
2007-10-04 04:51:34 +04:00
|
|
|
const union sctp_addr *laddr,
|
|
|
|
struct sctp_transport **transportp)
|
|
|
|
{
|
2017-06-30 06:52:13 +03:00
|
|
|
struct sctp_chunkhdr *ch;
|
2007-10-04 04:51:34 +04:00
|
|
|
|
2016-06-02 21:05:43 +03:00
|
|
|
/* We do not allow GSO frames here as we need to linearize and
|
|
|
|
* then cannot guarantee frame boundaries. This shouldn't be an
|
|
|
|
* issue as packets hitting this are mostly INIT or INIT-ACK and
|
|
|
|
* those cannot be on GSO-style anyway.
|
|
|
|
*/
|
2018-03-09 06:06:09 +03:00
|
|
|
if (skb_is_gso(skb) && skb_is_gso_sctp(skb))
|
2016-06-02 21:05:43 +03:00
|
|
|
return NULL;
|
|
|
|
|
2017-06-30 06:52:13 +03:00
|
|
|
ch = (struct sctp_chunkhdr *)skb->data;
|
2007-10-04 04:51:34 +04:00
|
|
|
|
2007-12-21 01:10:38 +03: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.
|
|
|
|
*/
|
2016-09-21 14:45:55 +03:00
|
|
|
if (SCTP_PAD4(ntohs(ch->length)) > skb->len)
|
2007-12-21 01:10:38 +03:00
|
|
|
return NULL;
|
|
|
|
|
2007-10-04 04:51:34 +04:00
|
|
|
/* If this is INIT/INIT-ACK look inside the chunk too. */
|
2013-12-19 06:02:42 +04:00
|
|
|
if (ch->type == SCTP_CID_INIT || ch->type == SCTP_CID_INIT_ACK)
|
2012-08-06 12:41:13 +04:00
|
|
|
return __sctp_rcv_init_lookup(net, skb, laddr, transportp);
|
2007-10-04 04:51:34 +04:00
|
|
|
|
2013-12-19 06:02:42 +04:00
|
|
|
return __sctp_rcv_walk_lookup(net, skb, laddr, transportp);
|
2007-10-04 04:51:34 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* Lookup an association for an inbound skb. */
|
2012-08-06 12:41:13 +04:00
|
|
|
static struct sctp_association *__sctp_rcv_lookup(struct net *net,
|
|
|
|
struct sk_buff *skb,
|
2005-04-17 02:20:36 +04:00
|
|
|
const union sctp_addr *paddr,
|
|
|
|
const union sctp_addr *laddr,
|
|
|
|
struct sctp_transport **transportp)
|
|
|
|
{
|
|
|
|
struct sctp_association *asoc;
|
|
|
|
|
2012-08-06 12:41:13 +04:00
|
|
|
asoc = __sctp_lookup_association(net, laddr, paddr, transportp);
|
2016-12-28 14:51:56 +03:00
|
|
|
if (asoc)
|
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Further lookup for INIT/INIT-ACK packets.
|
|
|
|
* SCTP Implementors Guide, 2.18 Handling of address
|
|
|
|
* parameters within the INIT or INIT-ACK.
|
|
|
|
*/
|
2016-12-28 14:51:56 +03:00
|
|
|
asoc = __sctp_rcv_lookup_harder(net, skb, laddr, transportp);
|
|
|
|
if (asoc)
|
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-12-28 14:51:56 +03:00
|
|
|
if (paddr->sa.sa_family == AF_INET)
|
|
|
|
pr_debug("sctp: asoc not found for src:%pI4:%d dst:%pI4:%d\n",
|
|
|
|
&laddr->v4.sin_addr, ntohs(laddr->v4.sin_port),
|
|
|
|
&paddr->v4.sin_addr, ntohs(paddr->v4.sin_port));
|
|
|
|
else
|
|
|
|
pr_debug("sctp: asoc not found for src:%pI6:%d dst:%pI6:%d\n",
|
|
|
|
&laddr->v6.sin6_addr, ntohs(laddr->v6.sin6_port),
|
|
|
|
&paddr->v6.sin6_addr, ntohs(paddr->v6.sin6_port));
|
|
|
|
|
|
|
|
out:
|
2005-04-17 02:20:36 +04:00
|
|
|
return asoc;
|
|
|
|
}
|