| // 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; | |
| } |