blob: 23ae508d8523cbf22aca8eacdf667e9bd7dc2a0c [file] [edit]
// SPDX-License-Identifier: GPL-2.0
/*
* Helper for sctp_ifwdtsn.sh: I-FORWARD-TSN handling with SCTP user message
* interleaving (RFC 8260) and partial reliability (RFC 3758).
*
* Runs both endpoints of one association: the server socket is created in
* the current network namespace, the client socket in the namespace given
* on the command line. The caller sets up the link and any nft rule that
* drops chunks. Messages sent by the client:
*
* big: 64KB on stream 0, reliable, fragmented into ~66 I-DATA chunks
* small: on stream 1, PR-SCTP "RTX" policy allowing one retransmission;
* the nft rule drops (part of) it, so it gets abandoned
* marker: short ordered message on stream 0
*
* The reset_pending tests instead leave a partly received PR-SCTP message
* on each stream, the one on stream 1 in partial delivery, before the
* reset; the pdapi tests abandon two messages on stream 1, the first one
* in partial delivery.
*
* Usage: sctp_ifwdtsn <client netns> <test>
* Exit status: 0 pass, 1 fail, 4 skip.
*/
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <sched.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <linux/sctp.h>
#include "kselftest.h"
#ifndef SOL_SCTP
#define SOL_SCTP 132
#endif
#define SRV_ADDR "10.0.0.1"
#define CLI_ADDR "10.0.0.2"
#define SRV_PORT 5000
#define BIG_LEN (64 * 1024)
#define BUF_LEN (BIG_LEN + 1024)
#define MAXSEG 1000
#define TIMEOUT_MS 5000
#define MARKER "marker"
#define UO_MARKER "uo-marker"
#define PD_LEN 20000 /* message in partial delivery on stream 1 */
struct test {
const char *name;
bool big_uo; /* send big unordered */
int small_len; /* 0: don't send the small message */
bool small_uo; /* send small unordered */
int pd_point; /* server SCTP_PARTIAL_DELIVERY_POINT */
bool expect_pd_abort; /* PD on stream 1 must be aborted */
bool uo_marker; /* then send an unordered marker on 1 */
bool reset; /* SSN/TSN association reset after big */
int reset_pending; /* reset with data pending, requested by
* 1: the server, 2: the client
*/
bool pdapi; /* two messages skipped on stream 1 */
};
static const struct test tests[] = {
{ .name = "ordered", .small_len = 3000 },
{ .name = "unordered", .big_uo = true, .small_len = 3000 },
{ .name = "leading_edge", .small_len = 1000, .pd_point = 2000 },
{ .name = "leading_edge_nopd", .small_len = 1000 },
{ .name = "uo_pd", .small_len = 20000, .small_uo = true,
.pd_point = 2000, .expect_pd_abort = true, .uo_marker = true },
{ .name = "reset", .reset = true },
{ .name = "reset_pending_srv", .reset = true, .reset_pending = 1,
.pd_point = 3000, .expect_pd_abort = true },
{ .name = "reset_pending_cli", .reset = true, .reset_pending = 2,
.pd_point = 3000, .expect_pd_abort = true },
{ .name = "pdapi", .pdapi = true, .pd_point = 2000,
.expect_pd_abort = true },
{ .name = "pdapi_uo", .pdapi = true, .small_uo = true, .pd_point = 2000,
.expect_pd_abort = true },
};
static const struct test *t;
static void die(const char *what)
{
fprintf(stderr, "%s: %s\n", what, strerror(errno));
exit(KSFT_FAIL);
}
static void setopt(int fd, int opt, const void *val, socklen_t len,
const char *name)
{
if (setsockopt(fd, SOL_SCTP, opt, val, len) < 0) {
fprintf(stderr, "setsockopt(%s): %s\n", name, strerror(errno));
/* Interleaving disabled, or option not supported. */
exit(errno == EPERM || errno == ENOPROTOOPT ?
KSFT_SKIP : KSFT_FAIL);
}
}
static void set_assoc_opt(int fd, int opt, unsigned int val, const char *name)
{
struct sctp_assoc_value av = {
.assoc_id = SCTP_FUTURE_ASSOC,
.assoc_value = val,
};
setopt(fd, opt, &av, sizeof(av), name);
}
static void subscribe(int fd, int type)
{
struct sctp_event ev = {
.se_assoc_id = SCTP_FUTURE_ASSOC,
.se_type = type,
.se_on = 1,
};
setopt(fd, SCTP_EVENT, &ev, sizeof(ev), "SCTP_EVENT");
}
static int sctp_socket(void)
{
struct sctp_initmsg im = {
.sinit_num_ostreams = 2,
.sinit_max_instreams = 2,
};
struct sctp_paddrparams pp = {
.spp_assoc_id = SCTP_FUTURE_ASSOC,
.spp_flags = SPP_HB_DISABLE,
};
struct sctp_rtoinfo rto = {
.srto_assoc_id = SCTP_FUTURE_ASSOC,
.srto_initial = 300,
.srto_min = 300,
.srto_max = 1000,
};
int fd, val;
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP);
if (fd < 0) {
perror("socket");
exit(errno == EPROTONOSUPPORT ? KSFT_SKIP : KSFT_FAIL);
}
val = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
setopt(fd, SCTP_INITMSG, &im, sizeof(im), "SCTP_INITMSG");
setopt(fd, SCTP_RTOINFO, &rto, sizeof(rto), "SCTP_RTOINFO");
/* No HEARTBEATs: the nft rules only look at the first chunk of a
* packet, and a HEARTBEAT bundled in front of DATA would bypass them.
*/
setopt(fd, SCTP_PEER_ADDR_PARAMS, &pp, sizeof(pp),
"SCTP_PEER_ADDR_PARAMS");
set_assoc_opt(fd, SCTP_PR_SUPPORTED, 1, "SCTP_PR_SUPPORTED");
val = 2;
setopt(fd, SCTP_FRAGMENT_INTERLEAVE, &val, sizeof(val),
"SCTP_FRAGMENT_INTERLEAVE");
set_assoc_opt(fd, SCTP_INTERLEAVING_SUPPORTED, 1,
"SCTP_INTERLEAVING_SUPPORTED");
if (t->reset) {
set_assoc_opt(fd, SCTP_RECONFIG_SUPPORTED, 1,
"SCTP_RECONFIG_SUPPORTED");
set_assoc_opt(fd, SCTP_ENABLE_STREAM_RESET,
SCTP_ENABLE_RESET_ASSOC_REQ,
"SCTP_ENABLE_STREAM_RESET");
subscribe(fd, SCTP_ASSOC_RESET_EVENT);
}
val = 1;
setopt(fd, SCTP_RECVRCVINFO, &val, sizeof(val), "SCTP_RECVRCVINFO");
return fd;
}
static void send_msg(int fd, int sid, bool uo, const void *buf, size_t len,
bool pr)
{
union {
char buf[CMSG_SPACE(sizeof(struct sctp_sndinfo)) +
CMSG_SPACE(sizeof(struct sctp_prinfo))];
struct cmsghdr align;
} cbuf = {};
struct iovec iov = { .iov_base = (void *)buf, .iov_len = len };
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cbuf.buf,
.msg_controllen = CMSG_SPACE(sizeof(struct sctp_sndinfo)),
};
struct sctp_sndinfo *si;
struct sctp_prinfo *pi;
struct cmsghdr *cm;
cm = CMSG_FIRSTHDR(&msg);
cm->cmsg_level = IPPROTO_SCTP;
cm->cmsg_type = SCTP_SNDINFO;
cm->cmsg_len = CMSG_LEN(sizeof(*si));
si = (struct sctp_sndinfo *)CMSG_DATA(cm);
si->snd_sid = sid;
si->snd_flags = uo ? SCTP_UNORDERED : 0;
if (pr) {
/* Abandon once the chunk would need a second retransmission:
* only a chunk that is lost again after being retransmitted
* qualifies, so abandonment does not depend on timing.
*/
msg.msg_controllen += CMSG_SPACE(sizeof(*pi));
cm = CMSG_NXTHDR(&msg, cm);
cm->cmsg_level = IPPROTO_SCTP;
cm->cmsg_type = SCTP_PRINFO;
cm->cmsg_len = CMSG_LEN(sizeof(*pi));
pi = (struct sctp_prinfo *)CMSG_DATA(cm);
pi->pr_policy = SCTP_PR_SCTP_RTX;
pi->pr_value = 1;
}
if (sendmsg(fd, &msg, 0) != (ssize_t)len)
die("sendmsg");
}
static unsigned char pattern(size_t i)
{
return (i * 7 + (i >> 8)) & 0xff;
}
static long long now_ms(void)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return ts.tv_sec * 1000LL + ts.tv_nsec / 1000000;
}
/* Wait until the client has abandoned @n sent messages. */
static bool wait_abandoned(int fd, unsigned int n)
{
long long end = now_ms() + TIMEOUT_MS;
struct sctp_prstatus ps;
socklen_t len;
while (now_ms() < end) {
memset(&ps, 0, sizeof(ps));
ps.sprstat_policy = SCTP_PR_SCTP_RTX;
len = sizeof(ps);
if (getsockopt(fd, SOL_SCTP, SCTP_PR_ASSOC_STATUS, &ps,
&len) < 0)
die("SCTP_PR_ASSOC_STATUS");
if (ps.sprstat_abandoned_sent >= n)
return true;
usleep(10000);
}
return false;
}
/* Wait for a notification of @type on @fd, discarding anything else. */
static bool wait_event(int fd, int type)
{
long long end = now_ms() + TIMEOUT_MS;
union {
char data[256];
union sctp_notification sn;
} buf;
for (;;) {
struct pollfd pfd = { .fd = fd, .events = POLLIN };
struct iovec iov = { buf.data, sizeof(buf.data) };
struct msghdr msg = { .msg_iov = &iov, .msg_iovlen = 1 };
union sctp_notification *sn = &buf.sn;
long long left = end - now_ms();
if (left <= 0 || poll(&pfd, 1, left) <= 0)
break;
if (recvmsg(fd, &msg, 0) <= 0)
break;
if (!(msg.msg_flags & MSG_NOTIFICATION) ||
sn->sn_header.sn_type != type)
continue;
if (type == SCTP_ASSOC_RESET_EVENT &&
sn->sn_assocreset_event.assocreset_flags &
(SCTP_ASSOC_RESET_DENIED | SCTP_ASSOC_RESET_FAILED)) {
printf("association reset denied or failed\n");
return false;
}
return true;
}
return false;
}
/* Request an SSN/TSN association reset. The sender refuses while it still
* has data queued or in flight, so retry until that has been acked.
*/
static void reset_assoc(int fd)
{
long long end = now_ms() + TIMEOUT_MS;
sctp_assoc_t id = 0;
while (setsockopt(fd, SOL_SCTP, SCTP_RESET_ASSOC, &id, sizeof(id))) {
if (errno != EAGAIN || now_ms() >= end)
die("SCTP_RESET_ASSOC");
usleep(10000);
}
}
/* Wait until all data sent on @fd has been acked. The receiver's
* cumulative TSN only moves past an abandoned message once it has
* processed the I-FORWARD-TSN for it.
*/
static bool wait_acked(int fd)
{
long long end = now_ms() + TIMEOUT_MS;
struct sctp_status st;
socklen_t len;
while (now_ms() < end) {
memset(&st, 0, sizeof(st));
len = sizeof(st);
/* Fails once the association has been aborted. */
if (getsockopt(fd, SOL_SCTP, SCTP_STATUS, &st, &len) < 0)
return false;
if (!st.sstat_unackdata)
return true;
usleep(10000);
}
return false;
}
/* Bytes held by the server association (/proc/net/sctp/assocs RX_QUEUE). */
static long assoc_rx_queue(void)
{
/* 7 columns, TX_QUEUE, RX_QUEUE, UID, INODE, LPORT */
const char *fmt = "%*s %*s %*s %*s %*s %*s %*s %*u %lu %*s %*s %d";
unsigned long rxq;
char line[512];
long ret = -1;
FILE *f;
int lport;
f = fopen("/proc/net/sctp/assocs", "r");
if (!f)
return -1;
while (fgets(line, sizeof(line), f)) {
if (sscanf(line, fmt, &rxq, &lport) == 2 && lport == SRV_PORT)
ret = rxq;
}
fclose(f);
return ret;
}
struct server_state {
unsigned char *buf[2]; /* message being received, per stream */
size_t len[2];
bool big, marker, uo_marker, reset_event;
int pd_aborts[2];
unsigned int pd_seq[2]; /* pdapi_seq of the last abort */
int errors;
};
static void check_msg(struct server_state *s, int sid)
{
unsigned char *m = s->buf[sid];
size_t len = s->len[sid];
size_t i;
s->len[sid] = 0;
if (sid == 0 && len == sizeof(MARKER) && !memcmp(m, MARKER, len)) {
s->marker = true;
return;
}
if (sid == 1 && len == sizeof(UO_MARKER) &&
!memcmp(m, UO_MARKER, len)) {
s->uo_marker = true;
return;
}
if (sid == 0 && len == BIG_LEN) {
for (i = 0; i < BIG_LEN && m[i] == pattern(i); i++)
;
if (i == BIG_LEN) {
s->big = true;
return;
}
printf("big message corrupted at offset %zu\n", i);
} else if (sid == 1 && len > sizeof(UO_MARKER) &&
!memcmp(m + len - sizeof(UO_MARKER), UO_MARKER,
sizeof(UO_MARKER))) {
printf("unordered marker appended to the abandoned message\n");
} else if (sid == 1 && t->small_len) {
printf("abandoned message delivered (%zu bytes)\n", len);
} else {
printf("unexpected %zu byte message on stream %d\n", len, sid);
}
s->errors++;
}
/* Receive until @done(s) is true or the timeout expires. */
static bool server_recv(int fd, struct server_state *s,
bool (*done)(const struct server_state *s))
{
long long end = now_ms() + TIMEOUT_MS;
static union {
char buf[CMSG_SPACE(sizeof(struct sctp_rcvinfo))];
struct cmsghdr align;
} cbuf;
static union {
unsigned char data[BUF_LEN];
union sctp_notification sn;
} buf;
while (!done(s)) {
struct pollfd pfd = { .fd = fd, .events = POLLIN };
struct iovec iov = { buf.data, sizeof(buf.data) };
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cbuf.buf,
.msg_controllen = sizeof(cbuf.buf),
};
union sctp_notification *sn = &buf.sn;
struct sctp_rcvinfo *ri = NULL;
struct cmsghdr *cm;
long long left;
ssize_t n;
int sid;
left = end - now_ms();
if (left <= 0 || poll(&pfd, 1, left) <= 0) {
printf("timeout waiting for data\n");
return false;
}
n = recvmsg(fd, &msg, 0);
if (n <= 0) {
printf("recvmsg: %s\n", n ? strerror(errno) : "EOF");
return false;
}
if (msg.msg_flags & MSG_NOTIFICATION) {
int type = sn->sn_header.sn_type;
if (type == SCTP_PARTIAL_DELIVERY_EVENT) {
struct sctp_pdapi_event *pe = &sn->sn_pdapi_event;
sid = pe->pdapi_stream;
if (sid > 1 || pe->pdapi_indication !=
SCTP_PARTIAL_DELIVERY_ABORTED) {
printf("unexpected pdapi event %u on stream %d\n",
pe->pdapi_indication, sid);
return false;
}
s->pd_aborts[sid]++;
s->pd_seq[sid] = pe->pdapi_seq;
s->len[sid] = 0;
} else if (type == SCTP_ASSOC_RESET_EVENT) {
s->reset_event = true;
}
continue;
}
for (cm = CMSG_FIRSTHDR(&msg); cm; cm = CMSG_NXTHDR(&msg, cm))
if (cm->cmsg_level == IPPROTO_SCTP &&
cm->cmsg_type == SCTP_RCVINFO)
ri = (struct sctp_rcvinfo *)CMSG_DATA(cm);
sid = ri ? ri->rcv_sid : 0;
if (sid > 1 || s->len[sid] + n > BUF_LEN) {
printf("unexpected data on stream %d\n", sid);
return false;
}
memcpy(s->buf[sid] + s->len[sid], buf.data, n);
s->len[sid] += n;
if (msg.msg_flags & MSG_EOR)
check_msg(s, sid);
}
return true;
}
static bool got_reset(const struct server_state *s)
{
return s->reset_event || s->errors;
}
static bool got_big(const struct server_state *s)
{
return s->big || s->errors;
}
static bool got_all(const struct server_state *s)
{
return ((s->big || t->pdapi) && s->marker &&
(!t->uo_marker || s->uo_marker) &&
(!t->expect_pd_abort || s->pd_aborts[1])) || s->errors;
}
/* Let the nft rules that match the client address in set "hold" pass. */
static bool release_hold(void)
{
if (system("nft delete element ip sctp_test hold { " CLI_ADDR " }")) {
printf("failed to release the nft hold\n");
return false;
}
return true;
}
static int client_socket(const char *netns)
{
int self, other, fd;
char path[256];
snprintf(path, sizeof(path), "/run/netns/%s", netns);
self = open("/proc/self/ns/net", O_RDONLY);
other = open(path, O_RDONLY);
if (self < 0 || other < 0)
die("open netns");
if (setns(other, CLONE_NEWNET))
die("setns");
fd = sctp_socket();
if (setns(self, CLONE_NEWNET))
die("setns");
close(other);
close(self);
return fd;
}
int main(int argc, char **argv)
{
struct sockaddr_in sa = {
.sin_family = AF_INET,
.sin_port = htons(SRV_PORT),
};
struct server_state s = {};
unsigned char *big, *small;
int lfd, sfd, cfd, i;
bool ok;
long rxq;
if (argc != 3) {
fprintf(stderr, "usage: %s <client netns> <test>\n", argv[0]);
return KSFT_FAIL;
}
for (i = 0; i < (int)ARRAY_SIZE(tests); i++)
if (!strcmp(argv[2], tests[i].name))
t = &tests[i];
if (!t) {
fprintf(stderr, "unknown test %s\n", argv[2]);
return KSFT_FAIL;
}
inet_pton(AF_INET, SRV_ADDR, &sa.sin_addr);
lfd = sctp_socket();
if (t->pd_point) {
setopt(lfd, SCTP_PARTIAL_DELIVERY_POINT, &t->pd_point,
sizeof(t->pd_point), "SCTP_PARTIAL_DELIVERY_POINT");
subscribe(lfd, SCTP_PARTIAL_DELIVERY_EVENT);
}
if (bind(lfd, (struct sockaddr *)&sa, sizeof(sa)) || listen(lfd, 1))
die("bind/listen");
cfd = client_socket(argv[1]);
set_assoc_opt(cfd, SCTP_MAXSEG, MAXSEG, "SCTP_MAXSEG");
/* Round robin, so that the small message is sent between fragments
* of the big one.
*/
set_assoc_opt(cfd, SCTP_STREAM_SCHEDULER, SCTP_SS_RR,
"SCTP_STREAM_SCHEDULER");
if (t->pdapi) {
/* Send the marker right away. Held back by Nagle, it could
* go out bundled behind an I-FORWARD-TSN, and nft would
* drop both.
*/
i = 1;
setopt(cfd, SCTP_NODELAY, &i, sizeof(i), "SCTP_NODELAY");
}
if (connect(cfd, (struct sockaddr *)&sa, sizeof(sa)))
die("connect");
sfd = accept(lfd, NULL, NULL);
if (sfd < 0)
die("accept");
big = malloc(BIG_LEN);
small = malloc(PD_LEN);
s.buf[0] = malloc(BUF_LEN);
s.buf[1] = malloc(BUF_LEN);
if (!big || !small || !s.buf[0] || !s.buf[1])
die("malloc");
for (i = 0; i < BIG_LEN; i++)
big[i] = pattern(i);
memset(small, 's', PD_LEN);
if (t->reset_pending) {
/* A message partly received on stream 0, not in partial
* delivery, and one in partial delivery on stream 1. Until
* the hold is released, nft drops a fragment of each and
* every I-FORWARD-TSN, so both are still pending on the
* server when the reset is done.
*/
send_msg(cfd, 0, false, small, 2500, true);
send_msg(cfd, 1, false, small, PD_LEN, true);
if (!wait_abandoned(cfd, 2)) {
printf("client: messages were not abandoned\n");
return KSFT_FAIL;
}
reset_assoc(t->reset_pending == 1 ? sfd : cfd);
if (!wait_event(cfd, SCTP_ASSOC_RESET_EVENT)) {
printf("client: no association reset event\n");
return KSFT_FAIL;
}
/* Once the server has seen the reset too, every packet the
* client sent before it has arrived.
*/
if (!server_recv(sfd, &s, got_reset) || s.errors ||
!release_hold())
return KSFT_FAIL;
/* MIDs start again from 0, so big reuses the MID of the
* message left on stream 0 and must not be mixed with it.
*/
send_msg(cfd, 0, false, big, BIG_LEN, false);
} else if (t->pdapi) {
/* Two messages on stream 1, the first one in partial
* delivery. nft drops a fragment of each and holds back
* I-FORWARD-TSNs until the marker, sent once both are
* abandoned, arrives. The client then sends one
* I-FORWARD-TSN naming both messages, below the marker's
* TSN.
*/
send_msg(cfd, 1, t->small_uo, small, PD_LEN, true);
send_msg(cfd, 1, t->small_uo, small, 3000, true);
if (!wait_abandoned(cfd, 2)) {
printf("client: messages were not abandoned\n");
return KSFT_FAIL;
}
} else {
send_msg(cfd, 0, t->big_uo, big, BIG_LEN, false);
if (t->small_len)
send_msg(cfd, 1, t->small_uo, small, t->small_len,
true);
}
if (t->reset && !t->reset_pending) {
ok = server_recv(sfd, &s, got_big);
if (ok)
reset_assoc(sfd);
/* Only send the marker once the reset is done. */
if (ok && !wait_event(cfd, SCTP_ASSOC_RESET_EVENT)) {
printf("client: no association reset event\n");
return KSFT_FAIL;
}
}
send_msg(cfd, 0, false, MARKER, sizeof(MARKER), false);
if (t->small_len && !wait_abandoned(cfd, 1)) {
printf("client: small message was not abandoned\n");
return KSFT_FAIL;
}
if (t->uo_marker)
send_msg(cfd, 1, true, UO_MARKER, sizeof(UO_MARKER), false);
ok = server_recv(sfd, &s, got_all);
if (!wait_acked(cfd)) {
printf("client: data not acked\n");
ok = false;
}
rxq = assoc_rx_queue();
if (!s.big && !t->pdapi)
printf("big message not delivered intact\n");
if (!s.marker)
printf("marker not delivered\n");
if (t->uo_marker && !s.uo_marker)
printf("unordered marker not delivered as its own message\n");
if (s.pd_aborts[0] || (s.pd_aborts[1] && !t->expect_pd_abort)) {
printf("unexpected partial delivery abort\n");
ok = false;
}
if (t->expect_pd_abort && !s.pd_aborts[1]) {
printf("partial delivery on stream 1 not aborted\n");
ok = false;
} else if (t->expect_pd_abort && (s.pd_aborts[1] > 1 || s.pd_seq[1])) {
printf("%d partial delivery aborts, last for MID %u, expected one for MID 0\n",
s.pd_aborts[1], s.pd_seq[1]);
ok = false;
}
if (t->reset && !s.reset_event) {
printf("server: no association reset event\n");
ok = false;
}
if (rxq < 0) {
printf("association is gone\n");
ok = false;
} else if (rxq > 0) {
printf("%ld bytes left queued on the association\n", rxq);
ok = false;
}
return ok && !s.errors ? KSFT_PASS : KSFT_FAIL;
}