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
|
|
|
* (C) Copyright IBM Corp. 2003, 2004
|
|
|
|
*
|
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
|
|
|
*
|
2007-05-09 10:57:56 +04:00
|
|
|
* This file contains the code relating the chunk abstraction.
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
|
|
|
* 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:
|
|
|
|
* Jon Grimm <jgrimm@us.ibm.com>
|
|
|
|
* Sridhar Samudrala <sri@us.ibm.com>
|
|
|
|
*/
|
|
|
|
|
2010-08-24 17:21:08 +04:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/net.h>
|
|
|
|
#include <linux/inet.h>
|
|
|
|
#include <linux/skbuff.h>
|
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/sock.h>
|
|
|
|
#include <net/sctp/sctp.h>
|
|
|
|
#include <net/sctp/sm.h>
|
|
|
|
|
|
|
|
/* This file is mostly in anticipation of future work, but initially
|
|
|
|
* populate with fragment tracking for an outbound message.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Initialize datamsg from memory. */
|
|
|
|
static void sctp_datamsg_init(struct sctp_datamsg *msg)
|
|
|
|
{
|
2017-07-04 15:53:25 +03:00
|
|
|
refcount_set(&msg->refcnt, 1);
|
2005-04-17 02:20:36 +04:00
|
|
|
msg->send_failed = 0;
|
|
|
|
msg->send_error = 0;
|
2010-05-01 06:41:10 +04:00
|
|
|
msg->can_delay = 1;
|
2017-11-25 16:18:35 +03:00
|
|
|
msg->abandoned = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
msg->expires_at = 0;
|
|
|
|
INIT_LIST_HEAD(&msg->chunks);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate and initialize datamsg. */
|
2013-06-17 13:40:05 +04:00
|
|
|
static struct sctp_datamsg *sctp_datamsg_new(gfp_t gfp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct sctp_datamsg *msg;
|
|
|
|
msg = kmalloc(sizeof(struct sctp_datamsg), gfp);
|
2008-04-10 12:57:24 +04:00
|
|
|
if (msg) {
|
2005-04-17 02:20:36 +04:00
|
|
|
sctp_datamsg_init(msg);
|
2008-04-10 12:57:24 +04:00
|
|
|
SCTP_DBG_OBJCNT_INC(datamsg);
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
2016-09-13 21:04:20 +03:00
|
|
|
void sctp_datamsg_free(struct sctp_datamsg *msg)
|
|
|
|
{
|
|
|
|
struct sctp_chunk *chunk;
|
|
|
|
|
|
|
|
/* This doesn't have to be a _safe vairant because
|
|
|
|
* sctp_chunk_free() only drops the refs.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(chunk, &msg->chunks, frag_list)
|
|
|
|
sctp_chunk_free(chunk);
|
|
|
|
|
|
|
|
sctp_datamsg_put(msg);
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* Final destructruction of datamsg memory. */
|
|
|
|
static void sctp_datamsg_destroy(struct sctp_datamsg *msg)
|
|
|
|
{
|
2018-11-18 11:08:52 +03:00
|
|
|
struct sctp_association *asoc = NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct list_head *pos, *temp;
|
|
|
|
struct sctp_chunk *chunk;
|
|
|
|
struct sctp_ulpevent *ev;
|
2019-10-08 14:27:36 +03:00
|
|
|
int error, sent;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Release all references. */
|
|
|
|
list_for_each_safe(pos, temp, &msg->chunks) {
|
|
|
|
list_del_init(pos);
|
|
|
|
chunk = list_entry(pos, struct sctp_chunk, frag_list);
|
2019-10-08 14:27:36 +03:00
|
|
|
|
|
|
|
if (!msg->send_failed) {
|
|
|
|
sctp_chunk_put(chunk);
|
|
|
|
continue;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2019-10-08 14:27:36 +03:00
|
|
|
asoc = chunk->asoc;
|
|
|
|
error = msg->send_error ?: asoc->outqueue.error;
|
|
|
|
sent = chunk->has_tsn ? SCTP_DATA_SENT : SCTP_DATA_UNSENT;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2019-10-08 14:27:36 +03:00
|
|
|
if (sctp_ulpevent_type_enabled(asoc->subscribe,
|
|
|
|
SCTP_SEND_FAILED)) {
|
2005-04-17 02:20:36 +04:00
|
|
|
ev = sctp_ulpevent_make_send_failed(asoc, chunk, sent,
|
|
|
|
error, GFP_ATOMIC);
|
|
|
|
if (ev)
|
2017-12-08 16:04:05 +03:00
|
|
|
asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2019-10-08 14:27:36 +03:00
|
|
|
if (sctp_ulpevent_type_enabled(asoc->subscribe,
|
|
|
|
SCTP_SEND_FAILED_EVENT)) {
|
|
|
|
ev = sctp_ulpevent_make_send_failed_event(asoc, chunk,
|
|
|
|
sent, error,
|
|
|
|
GFP_ATOMIC);
|
|
|
|
if (ev)
|
|
|
|
asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
sctp_chunk_put(chunk);
|
|
|
|
}
|
|
|
|
|
|
|
|
SCTP_DBG_OBJCNT_DEC(datamsg);
|
|
|
|
kfree(msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Hold a reference. */
|
|
|
|
static void sctp_datamsg_hold(struct sctp_datamsg *msg)
|
|
|
|
{
|
2017-07-04 15:53:25 +03:00
|
|
|
refcount_inc(&msg->refcnt);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Release a reference. */
|
|
|
|
void sctp_datamsg_put(struct sctp_datamsg *msg)
|
|
|
|
{
|
2017-07-04 15:53:25 +03:00
|
|
|
if (refcount_dec_and_test(&msg->refcnt))
|
2005-04-17 02:20:36 +04:00
|
|
|
sctp_datamsg_destroy(msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Assign a chunk to this datamsg. */
|
|
|
|
static void sctp_datamsg_assign(struct sctp_datamsg *msg, struct sctp_chunk *chunk)
|
|
|
|
{
|
|
|
|
sctp_datamsg_hold(msg);
|
|
|
|
chunk->msg = msg;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* A data chunk can have a maximum payload of (2^16 - 20). Break
|
|
|
|
* down any such message into smaller chunks. Opportunistically, fragment
|
|
|
|
* the chunks down to the current MTU constraints. We may get refragmented
|
|
|
|
* later if the PMTU changes, but it is _much better_ to fragment immediately
|
|
|
|
* with a reasonable guess than always doing our fragmentation on the
|
|
|
|
* soft-interrupt.
|
|
|
|
*/
|
|
|
|
struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *asoc,
|
|
|
|
struct sctp_sndrcvinfo *sinfo,
|
2014-11-15 09:11:23 +03:00
|
|
|
struct iov_iter *from)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2016-12-29 20:53:28 +03:00
|
|
|
size_t len, first_len, max_data, remaining;
|
|
|
|
size_t msg_len = iov_iter_count(from);
|
2018-03-14 14:05:30 +03:00
|
|
|
struct sctp_shared_key *shkey = NULL;
|
2016-12-29 20:53:28 +03:00
|
|
|
struct list_head *pos, *temp;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct sctp_chunk *chunk;
|
|
|
|
struct sctp_datamsg *msg;
|
2016-12-29 20:53:28 +03:00
|
|
|
int err;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
msg = sctp_datamsg_new(GFP_KERNEL);
|
|
|
|
if (!msg)
|
sctp: fix -ENOMEM result with invalid user space pointer in sendto() syscall
Consider the following program, that sets the second argument to the
sendto() syscall incorrectly:
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(void)
{
int fd;
struct sockaddr_in sa;
fd = socket(AF_INET, SOCK_STREAM, 132 /*IPPROTO_SCTP*/);
if (fd < 0)
return 1;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = inet_addr("127.0.0.1");
sa.sin_port = htons(11111);
sendto(fd, NULL, 1, 0, (struct sockaddr *)&sa, sizeof(sa));
return 0;
}
We get -ENOMEM:
$ strace -e sendto ./demo
sendto(3, NULL, 1, 0, {sa_family=AF_INET, sin_port=htons(11111), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 ENOMEM (Cannot allocate memory)
Propagate the error code from sctp_user_addto_chunk(), so that we will
tell user space what actually went wrong:
$ strace -e sendto ./demo
sendto(3, NULL, 1, 0, {sa_family=AF_INET, sin_port=htons(11111), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 EFAULT (Bad address)
Noticed while running Trinity (the syscall fuzzer).
Signed-off-by: Tommi Rantala <tt.rantala@gmail.com>
Acked-by: Vlad Yasevich <vyasevich@gmail.com>
Acked-by: Neil Horman <nhorman@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-11-22 07:23:16 +04:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Note: Calculate this outside of the loop, so that all fragments
|
|
|
|
* have the same expiration.
|
|
|
|
*/
|
2016-10-08 06:40:16 +03:00
|
|
|
if (asoc->peer.prsctp_capable && sinfo->sinfo_timetolive &&
|
|
|
|
(SCTP_PR_TTL_ENABLED(sinfo->sinfo_flags) ||
|
|
|
|
!SCTP_PR_POLICY(sinfo->sinfo_flags)))
|
2005-04-17 02:20:36 +04:00
|
|
|
msg->expires_at = jiffies +
|
2016-12-29 20:53:28 +03:00
|
|
|
msecs_to_jiffies(sinfo->sinfo_timetolive);
|
2016-09-28 21:37:27 +03:00
|
|
|
|
2009-09-05 02:20:56 +04:00
|
|
|
/* This is the biggest possible DATA chunk that can fit into
|
|
|
|
* the packet
|
|
|
|
*/
|
2018-04-26 22:58:55 +03:00
|
|
|
max_data = asoc->frag_point;
|
2018-12-04 22:27:41 +03:00
|
|
|
if (unlikely(!max_data)) {
|
|
|
|
max_data = sctp_min_frag_point(sctp_sk(asoc->base.sk),
|
|
|
|
sctp_datachk_len(&asoc->stream));
|
2019-02-28 14:36:52 +03:00
|
|
|
pr_warn_ratelimited("%s: asoc:%p frag_point is zero, forcing max_data to default minimum (%zu)",
|
2018-12-04 22:27:41 +03:00
|
|
|
__func__, asoc, max_data);
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-09-17 06:32:45 +04:00
|
|
|
/* If the the peer requested that we authenticate DATA chunks
|
2013-10-26 12:06:30 +04:00
|
|
|
* we need to account for bundling of the AUTH chunks along with
|
2007-09-17 06:32:45 +04:00
|
|
|
* DATA.
|
|
|
|
*/
|
|
|
|
if (sctp_auth_send_cid(SCTP_CID_DATA, asoc)) {
|
|
|
|
struct sctp_hmac *hmac_desc = sctp_auth_asoc_get_hmac(asoc);
|
|
|
|
|
|
|
|
if (hmac_desc)
|
2017-08-03 10:42:22 +03:00
|
|
|
max_data -= SCTP_PAD4(sizeof(struct sctp_auth_chunk) +
|
2016-09-21 14:45:55 +03:00
|
|
|
hmac_desc->hmac_len);
|
2018-03-14 14:05:30 +03:00
|
|
|
|
2018-03-14 14:05:31 +03:00
|
|
|
if (sinfo->sinfo_tsn &&
|
|
|
|
sinfo->sinfo_ssn != asoc->active_key_id) {
|
|
|
|
shkey = sctp_auth_get_shkey(asoc, sinfo->sinfo_ssn);
|
|
|
|
if (!shkey) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
shkey = asoc->shkey;
|
|
|
|
}
|
2007-09-17 06:32:45 +04:00
|
|
|
}
|
|
|
|
|
2016-12-29 20:53:28 +03:00
|
|
|
/* Set first_len and then account for possible bundles on first frag */
|
|
|
|
first_len = max_data;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2009-08-07 21:23:28 +04:00
|
|
|
/* Check to see if we have a pending SACK and try to let it be bundled
|
|
|
|
* with this message. Do this if we don't have any data queued already.
|
|
|
|
* To check that, look at out_qlen and retransmit list.
|
|
|
|
* NOTE: we will not reduce to account for SACK, if the message would
|
|
|
|
* not have been fragmented.
|
|
|
|
*/
|
|
|
|
if (timer_pending(&asoc->timers[SCTP_EVENT_TIMEOUT_SACK]) &&
|
|
|
|
asoc->outqueue.out_qlen == 0 &&
|
|
|
|
list_empty(&asoc->outqueue.retransmit) &&
|
2016-12-29 20:53:28 +03:00
|
|
|
msg_len > max_data)
|
2017-07-23 04:34:33 +03:00
|
|
|
first_len -= SCTP_PAD4(sizeof(struct sctp_sack_chunk));
|
2009-08-07 21:23:28 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* Encourage Cookie-ECHO bundling. */
|
2009-08-07 21:23:28 +04:00
|
|
|
if (asoc->state < SCTP_STATE_COOKIE_ECHOED)
|
2016-12-29 20:53:28 +03:00
|
|
|
first_len -= SCTP_ARBITRARY_COOKIE_ECHO_LEN;
|
2009-09-05 02:20:56 +04:00
|
|
|
|
|
|
|
/* Account for a different sized first fragment */
|
|
|
|
if (msg_len >= first_len) {
|
2010-05-01 06:41:10 +04:00
|
|
|
msg->can_delay = 0;
|
2018-06-20 18:47:52 +03:00
|
|
|
if (msg_len > first_len)
|
2019-12-09 08:45:18 +03:00
|
|
|
SCTP_INC_STATS(asoc->base.net,
|
2018-06-20 18:47:52 +03:00
|
|
|
SCTP_MIB_FRAGUSRMSGS);
|
2016-12-29 20:53:28 +03:00
|
|
|
} else {
|
|
|
|
/* Which may be the only one... */
|
|
|
|
first_len = msg_len;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-12-29 20:53:28 +03:00
|
|
|
/* Create chunks for all DATA chunks. */
|
|
|
|
for (remaining = msg_len; remaining; remaining -= len) {
|
|
|
|
u8 frag = SCTP_DATA_MIDDLE_FRAG;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-12-29 20:53:28 +03:00
|
|
|
if (remaining == msg_len) {
|
|
|
|
/* First frag, which may also be the last */
|
2005-04-17 02:20:36 +04:00
|
|
|
frag |= SCTP_DATA_FIRST_FRAG;
|
2016-12-29 20:53:28 +03:00
|
|
|
len = first_len;
|
|
|
|
} else {
|
|
|
|
/* Middle frags */
|
|
|
|
len = max_data;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-12-29 20:53:28 +03:00
|
|
|
if (len >= remaining) {
|
|
|
|
/* Last frag, which may also be the first */
|
|
|
|
len = remaining;
|
2005-04-17 02:20:36 +04:00
|
|
|
frag |= SCTP_DATA_LAST_FRAG;
|
|
|
|
|
2009-11-23 23:53:56 +03:00
|
|
|
/* The application requests to set the I-bit of the
|
|
|
|
* last DATA chunk of a user message when providing
|
|
|
|
* the user message to the SCTP implementation.
|
|
|
|
*/
|
|
|
|
if ((sinfo->sinfo_flags & SCTP_EOF) ||
|
|
|
|
(sinfo->sinfo_flags & SCTP_SACK_IMMEDIATELY))
|
|
|
|
frag |= SCTP_DATA_SACK_IMM;
|
|
|
|
}
|
|
|
|
|
2017-12-08 16:04:01 +03:00
|
|
|
chunk = asoc->stream.si->make_datafrag(asoc, sinfo, len, frag,
|
|
|
|
GFP_KERNEL);
|
sctp: fix -ENOMEM result with invalid user space pointer in sendto() syscall
Consider the following program, that sets the second argument to the
sendto() syscall incorrectly:
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(void)
{
int fd;
struct sockaddr_in sa;
fd = socket(AF_INET, SOCK_STREAM, 132 /*IPPROTO_SCTP*/);
if (fd < 0)
return 1;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = inet_addr("127.0.0.1");
sa.sin_port = htons(11111);
sendto(fd, NULL, 1, 0, (struct sockaddr *)&sa, sizeof(sa));
return 0;
}
We get -ENOMEM:
$ strace -e sendto ./demo
sendto(3, NULL, 1, 0, {sa_family=AF_INET, sin_port=htons(11111), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 ENOMEM (Cannot allocate memory)
Propagate the error code from sctp_user_addto_chunk(), so that we will
tell user space what actually went wrong:
$ strace -e sendto ./demo
sendto(3, NULL, 1, 0, {sa_family=AF_INET, sin_port=htons(11111), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 EFAULT (Bad address)
Noticed while running Trinity (the syscall fuzzer).
Signed-off-by: Tommi Rantala <tt.rantala@gmail.com>
Acked-by: Vlad Yasevich <vyasevich@gmail.com>
Acked-by: Neil Horman <nhorman@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-11-22 07:23:16 +04:00
|
|
|
if (!chunk) {
|
|
|
|
err = -ENOMEM;
|
2005-04-17 02:20:36 +04:00
|
|
|
goto errout;
|
sctp: fix -ENOMEM result with invalid user space pointer in sendto() syscall
Consider the following program, that sets the second argument to the
sendto() syscall incorrectly:
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(void)
{
int fd;
struct sockaddr_in sa;
fd = socket(AF_INET, SOCK_STREAM, 132 /*IPPROTO_SCTP*/);
if (fd < 0)
return 1;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = inet_addr("127.0.0.1");
sa.sin_port = htons(11111);
sendto(fd, NULL, 1, 0, (struct sockaddr *)&sa, sizeof(sa));
return 0;
}
We get -ENOMEM:
$ strace -e sendto ./demo
sendto(3, NULL, 1, 0, {sa_family=AF_INET, sin_port=htons(11111), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 ENOMEM (Cannot allocate memory)
Propagate the error code from sctp_user_addto_chunk(), so that we will
tell user space what actually went wrong:
$ strace -e sendto ./demo
sendto(3, NULL, 1, 0, {sa_family=AF_INET, sin_port=htons(11111), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 EFAULT (Bad address)
Noticed while running Trinity (the syscall fuzzer).
Signed-off-by: Tommi Rantala <tt.rantala@gmail.com>
Acked-by: Vlad Yasevich <vyasevich@gmail.com>
Acked-by: Neil Horman <nhorman@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-11-22 07:23:16 +04:00
|
|
|
}
|
|
|
|
|
2014-11-15 09:11:23 +03:00
|
|
|
err = sctp_user_addto_chunk(chunk, len, from);
|
2005-04-17 02:20:36 +04:00
|
|
|
if (err < 0)
|
sctp: fix memory leak in sctp_datamsg_from_user() when copy from user space fails
Trinity (the syscall fuzzer) discovered a memory leak in SCTP,
reproducible e.g. with the sendto() syscall by passing invalid
user space pointer in the second argument:
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(void)
{
int fd;
struct sockaddr_in sa;
fd = socket(AF_INET, SOCK_STREAM, 132 /*IPPROTO_SCTP*/);
if (fd < 0)
return 1;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = inet_addr("127.0.0.1");
sa.sin_port = htons(11111);
sendto(fd, NULL, 1, 0, (struct sockaddr *)&sa, sizeof(sa));
return 0;
}
As far as I can tell, the leak has been around since ~2003.
Signed-off-by: Tommi Rantala <tt.rantala@gmail.com>
Acked-by: Vlad Yasevich <vyasevich@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-11-27 08:01:46 +04:00
|
|
|
goto errout_chunk_free;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-03-14 14:05:30 +03:00
|
|
|
chunk->shkey = shkey;
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* Put the chunk->skb back into the form expected by send. */
|
2016-12-29 20:53:28 +03:00
|
|
|
__skb_pull(chunk->skb, (__u8 *)chunk->chunk_hdr -
|
|
|
|
chunk->skb->data);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
sctp_datamsg_assign(msg, chunk);
|
|
|
|
list_add_tail(&chunk->frag_list, &msg->chunks);
|
|
|
|
}
|
|
|
|
|
|
|
|
return msg;
|
|
|
|
|
sctp: fix memory leak in sctp_datamsg_from_user() when copy from user space fails
Trinity (the syscall fuzzer) discovered a memory leak in SCTP,
reproducible e.g. with the sendto() syscall by passing invalid
user space pointer in the second argument:
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(void)
{
int fd;
struct sockaddr_in sa;
fd = socket(AF_INET, SOCK_STREAM, 132 /*IPPROTO_SCTP*/);
if (fd < 0)
return 1;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = inet_addr("127.0.0.1");
sa.sin_port = htons(11111);
sendto(fd, NULL, 1, 0, (struct sockaddr *)&sa, sizeof(sa));
return 0;
}
As far as I can tell, the leak has been around since ~2003.
Signed-off-by: Tommi Rantala <tt.rantala@gmail.com>
Acked-by: Vlad Yasevich <vyasevich@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-11-27 08:01:46 +04:00
|
|
|
errout_chunk_free:
|
|
|
|
sctp_chunk_free(chunk);
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
errout:
|
|
|
|
list_for_each_safe(pos, temp, &msg->chunks) {
|
|
|
|
list_del_init(pos);
|
|
|
|
chunk = list_entry(pos, struct sctp_chunk, frag_list);
|
|
|
|
sctp_chunk_free(chunk);
|
|
|
|
}
|
2008-03-24 08:47:08 +03:00
|
|
|
sctp_datamsg_put(msg);
|
2016-12-29 20:53:28 +03:00
|
|
|
|
sctp: fix -ENOMEM result with invalid user space pointer in sendto() syscall
Consider the following program, that sets the second argument to the
sendto() syscall incorrectly:
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
int main(void)
{
int fd;
struct sockaddr_in sa;
fd = socket(AF_INET, SOCK_STREAM, 132 /*IPPROTO_SCTP*/);
if (fd < 0)
return 1;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = inet_addr("127.0.0.1");
sa.sin_port = htons(11111);
sendto(fd, NULL, 1, 0, (struct sockaddr *)&sa, sizeof(sa));
return 0;
}
We get -ENOMEM:
$ strace -e sendto ./demo
sendto(3, NULL, 1, 0, {sa_family=AF_INET, sin_port=htons(11111), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 ENOMEM (Cannot allocate memory)
Propagate the error code from sctp_user_addto_chunk(), so that we will
tell user space what actually went wrong:
$ strace -e sendto ./demo
sendto(3, NULL, 1, 0, {sa_family=AF_INET, sin_port=htons(11111), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 EFAULT (Bad address)
Noticed while running Trinity (the syscall fuzzer).
Signed-off-by: Tommi Rantala <tt.rantala@gmail.com>
Acked-by: Vlad Yasevich <vyasevich@gmail.com>
Acked-by: Neil Horman <nhorman@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-11-22 07:23:16 +04:00
|
|
|
return ERR_PTR(err);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check whether this message has expired. */
|
|
|
|
int sctp_chunk_abandoned(struct sctp_chunk *chunk)
|
|
|
|
{
|
2016-10-08 06:40:16 +03:00
|
|
|
if (!chunk->asoc->peer.prsctp_capable)
|
2005-04-17 02:20:36 +04:00
|
|
|
return 0;
|
|
|
|
|
2017-11-25 16:18:35 +03:00
|
|
|
if (chunk->msg->abandoned)
|
|
|
|
return 1;
|
|
|
|
|
2017-11-25 16:18:36 +03:00
|
|
|
if (!chunk->has_tsn &&
|
|
|
|
!(chunk->chunk_hdr->flags & SCTP_DATA_FIRST_FRAG))
|
|
|
|
return 0;
|
|
|
|
|
2016-07-09 14:47:43 +03:00
|
|
|
if (SCTP_PR_TTL_ENABLED(chunk->sinfo.sinfo_flags) &&
|
2016-09-28 21:37:27 +03:00
|
|
|
time_after(jiffies, chunk->msg->expires_at)) {
|
2017-04-01 12:07:46 +03:00
|
|
|
struct sctp_stream_out *streamout =
|
2018-08-10 20:11:42 +03:00
|
|
|
SCTP_SO(&chunk->asoc->stream,
|
|
|
|
chunk->sinfo.sinfo_stream);
|
2017-04-01 12:07:46 +03:00
|
|
|
|
|
|
|
if (chunk->sent_count) {
|
2016-07-09 14:47:43 +03:00
|
|
|
chunk->asoc->abandoned_sent[SCTP_PR_INDEX(TTL)]++;
|
2017-10-04 01:20:11 +03:00
|
|
|
streamout->ext->abandoned_sent[SCTP_PR_INDEX(TTL)]++;
|
2017-04-01 12:07:46 +03:00
|
|
|
} else {
|
2016-07-09 14:47:43 +03:00
|
|
|
chunk->asoc->abandoned_unsent[SCTP_PR_INDEX(TTL)]++;
|
2017-10-04 01:20:11 +03:00
|
|
|
streamout->ext->abandoned_unsent[SCTP_PR_INDEX(TTL)]++;
|
2017-04-01 12:07:46 +03:00
|
|
|
}
|
2017-11-25 16:18:35 +03:00
|
|
|
chunk->msg->abandoned = 1;
|
2005-04-17 02:20:36 +04:00
|
|
|
return 1;
|
2016-07-09 14:47:44 +03:00
|
|
|
} else if (SCTP_PR_RTX_ENABLED(chunk->sinfo.sinfo_flags) &&
|
2016-09-28 21:37:27 +03:00
|
|
|
chunk->sent_count > chunk->sinfo.sinfo_timetolive) {
|
2017-04-01 12:07:46 +03:00
|
|
|
struct sctp_stream_out *streamout =
|
2018-08-10 20:11:42 +03:00
|
|
|
SCTP_SO(&chunk->asoc->stream,
|
|
|
|
chunk->sinfo.sinfo_stream);
|
2017-04-01 12:07:46 +03:00
|
|
|
|
2016-07-09 14:47:44 +03:00
|
|
|
chunk->asoc->abandoned_sent[SCTP_PR_INDEX(RTX)]++;
|
2017-10-04 01:20:11 +03:00
|
|
|
streamout->ext->abandoned_sent[SCTP_PR_INDEX(RTX)]++;
|
2017-11-25 16:18:35 +03:00
|
|
|
chunk->msg->abandoned = 1;
|
2016-07-09 14:47:44 +03:00
|
|
|
return 1;
|
2016-10-08 06:40:16 +03:00
|
|
|
} else if (!SCTP_PR_POLICY(chunk->sinfo.sinfo_flags) &&
|
|
|
|
chunk->msg->expires_at &&
|
|
|
|
time_after(jiffies, chunk->msg->expires_at)) {
|
2017-11-25 16:18:35 +03:00
|
|
|
chunk->msg->abandoned = 1;
|
2016-10-08 06:40:16 +03:00
|
|
|
return 1;
|
2016-07-09 14:47:43 +03:00
|
|
|
}
|
sctp: implement prsctp PRIO policy
prsctp PRIO policy is a policy to abandon lower priority chunks when
asoc doesn't have enough snd buffer, so that the current chunk with
higher priority can be queued successfully.
Similar to TTL/RTX policy, we will set the priority of the chunk to
prsctp_param with sinfo->sinfo_timetolive in sctp_set_prsctp_policy().
So if PRIO policy is enabled, msg->expire_at won't work.
asoc->sent_cnt_removable will record how many chunks can be checked to
remove. If priority policy is enabled, when the chunk is queued into
the out_queue, we will increase sent_cnt_removable. When the chunk is
moved to abandon_queue or dequeue and free, we will decrease
sent_cnt_removable.
In sctp_sendmsg, we will check if there is enough snd buffer for current
msg and if sent_cnt_removable is not 0. Then try to abandon chunks in
sctp_prune_prsctp when sendmsg from the retransmit/transmited queue, and
free chunks from out_queue in right order until the abandon+free size >
msg_len - sctp_wfree. For the abandon size, we have to wait until it
sends FORWARD TSN, receives the sack and the chunks are really freed.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-07-09 14:47:45 +03:00
|
|
|
/* PRIO policy is processed by sendmsg, not here */
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This chunk (and consequently entire message) has failed in its sending. */
|
|
|
|
void sctp_chunk_fail(struct sctp_chunk *chunk, int error)
|
|
|
|
{
|
|
|
|
chunk->msg->send_failed = 1;
|
|
|
|
chunk->msg->send_error = error;
|
|
|
|
}
|