1 /* SCTP kernel Implementation
2 * (C) Copyright IBM Corp. 2001, 2004
3 * Copyright (c) 1999-2000 Cisco, Inc.
4 * Copyright (c) 1999-2001 Motorola, Inc.
5 * Copyright (c) 2001 Intel Corp.
6 * Copyright (c) 2001 Nokia, Inc.
7 *
8 * The SCTP implementation is free software;
9 * you can redistribute it and/or modify it under the terms of
10 * the GNU General Public License as published by
11 * the Free Software Foundation; either version 2, or (at your option)
12 * any later version.
13 *
14 * The SCTP implementation is distributed in the hope that it
15 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16 * ************************
17 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
18 * See the GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with GNU CC; see the file COPYING. If not, write to
22 * the Free Software Foundation, 59 Temple Place - Suite 330,
23 * Boston, MA 02111-1307, USA.
24 *
25 * Please send any bug reports or fixes you make to the
26 * email address(es):
27 * lksctp developers <lksctp-developers@lists.sourceforge.net>
28 *
29 * Or submit a bug report through the following website:
30 * http://www.sf.net/projects/lksctp
31 *
32 * Any bugs reported to us we will try to fix... any fixes shared will
33 * be incorporated into the next SCTP release.
34 *
35 * Written or modified by:
36 * La Monte H.P. Yarroll <piggy@acm.org>
37 * Karl Knutson <karl@athena.chicago.il.us>
38 * Hui Huang <hui.huang@nokia.com>
39 * Jon Grimm <jgrimm@us.ibm.com>
40 * Sridhar Samudrala <samudrala@us.ibm.com>
41 */
42
43 /* This is a functional test to verify the various SCTP level socket
44 * options that can be used to get information about existing SCTP
45 * associations and to configure certain parameters.
46 */
47
48 #include <stdio.h>
49 #include <unistd.h>
50 #include <stdlib.h>
51 #include <string.h>
52 #include <sys/types.h>
53 #include <sys/socket.h>
54 #include <sys/uio.h>
55 #include <sys/errno.h>
56 #include <netinet/in.h>
57 #include <netinet/sctp.h>
58 #include <sctputil.h>
59
60 char *TCID = __FILE__;
61 int TST_TOTAL = 29;
62 int TST_CNT = 0;
63
64 int
main(void)65 main(void)
66 {
67 int udp_svr_sk, udp_clt_sk, tcp_svr_sk, tcp_clt_sk;
68 int accept_sk, peeloff_sk;
69 sockaddr_storage_t udp_svr_loop, udp_clt_loop;
70 sockaddr_storage_t tcp_svr_loop, tcp_clt_loop;
71 struct iovec iov;
72 struct msghdr inmessage;
73 struct msghdr outmessage;
74 char incmsg[CMSG_SPACE(sizeof(sctp_cmsg_data_t))];
75 char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
76 struct cmsghdr *cmsg;
77 struct sctp_sndrcvinfo *sinfo;
78 struct iovec out_iov;
79 char *message = "hello, world!\n";
80 int error;
81 int pf_class;
82 uint32_t ppid;
83 uint32_t stream;
84 sctp_assoc_t udp_svr_associd, udp_clt_associd;
85 struct sctp_assoc_change *sac;
86 char *big_buffer;
87 struct sctp_event_subscribe subscribe;
88 struct sctp_initmsg initmsg;
89 struct sctp_paddrparams paddrparams;
90 struct sctp_sndrcvinfo set_udp_sk_dflt_param, get_udp_sk_dflt_param;
91 struct sctp_sndrcvinfo set_tcp_sk_dflt_param, get_tcp_sk_dflt_param;
92 struct sctp_sndrcvinfo set_udp_assoc_dflt_param;
93 struct sctp_sndrcvinfo get_udp_assoc_dflt_param;
94 struct sctp_sndrcvinfo set_tcp_assoc_dflt_param;
95 struct sctp_sndrcvinfo get_tcp_assoc_dflt_param;
96 struct sctp_sndrcvinfo get_peeloff_assoc_dflt_param;
97 struct sctp_sndrcvinfo get_accept_assoc_dflt_param;
98 struct sctp_paddrinfo pinfo;
99 int dflt_pathmaxrxt;
100 socklen_t optlen, addrlen;
101 struct sctp_status status;
102 struct sctp_assoc_value value;
103
104 /* Rather than fflush() throughout the code, set stdout to
105 * be unbuffered.
106 */
107 setvbuf(stdout, NULL, _IONBF, 0);
108
109 /* Set some basic values which depend on the address family. */
110 #if TEST_V6
111 pf_class = PF_INET6;
112
113 udp_svr_loop.v6.sin6_family = AF_INET6;
114 udp_svr_loop.v6.sin6_addr = in6addr_loopback;
115 udp_svr_loop.v6.sin6_port = htons(SCTP_TESTPORT_1);
116
117 udp_clt_loop.v6.sin6_family = AF_INET6;
118 udp_clt_loop.v6.sin6_addr = in6addr_loopback;
119 udp_clt_loop.v6.sin6_port = htons(SCTP_TESTPORT_1+1);
120
121 tcp_svr_loop.v6.sin6_family = AF_INET6;
122 tcp_svr_loop.v6.sin6_addr = in6addr_loopback;
123 tcp_svr_loop.v6.sin6_port = htons(SCTP_TESTPORT_1+2);
124
125 tcp_clt_loop.v6.sin6_family = AF_INET6;
126 tcp_clt_loop.v6.sin6_addr = in6addr_loopback;
127 tcp_clt_loop.v6.sin6_port = htons(SCTP_TESTPORT_1+3);
128 #else
129 pf_class = PF_INET;
130
131 udp_svr_loop.v4.sin_family = AF_INET;
132 udp_svr_loop.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;
133 udp_svr_loop.v4.sin_port = htons(SCTP_TESTPORT_1);
134
135 udp_clt_loop.v4.sin_family = AF_INET;
136 udp_clt_loop.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;
137 udp_clt_loop.v4.sin_port = htons(SCTP_TESTPORT_1+1);
138
139 tcp_svr_loop.v4.sin_family = AF_INET;
140 tcp_svr_loop.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;
141 tcp_svr_loop.v4.sin_port = htons(SCTP_TESTPORT_1+2);
142
143 tcp_clt_loop.v4.sin_family = AF_INET;
144 tcp_clt_loop.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;
145 tcp_clt_loop.v4.sin_port = htons(SCTP_TESTPORT_2+3);
146 #endif /* TEST_V6 */
147
148 /* Create the two endpoints which will talk to each other. */
149 udp_svr_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
150 udp_clt_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
151
152 /* Enable ASSOC_CHANGE and SNDRCVINFO notifications. */
153 test_enable_assoc_change(udp_svr_sk);
154 test_enable_assoc_change(udp_clt_sk);
155
156 /* Bind these sockets to the test ports. */
157 test_bind(udp_svr_sk, &udp_svr_loop.sa, sizeof(udp_svr_loop));
158 test_bind(udp_clt_sk, &udp_clt_loop.sa, sizeof(udp_clt_loop));
159
160 /* Mark udp_svr_sk as being able to accept new associations. */
161 test_listen(udp_svr_sk, 1);
162
163 /* TEST #1: SCTP_STATUS socket option. */
164 /* Make sure that SCTP_STATUS getsockopt on a socket with no
165 * association fails.
166 */
167 optlen = sizeof(struct sctp_status);
168 memset(&status, 0, optlen);
169 error = getsockopt(udp_svr_sk, SOL_SCTP, SCTP_STATUS, &status,
170 &optlen);
171 if ((error != -1) && (errno != EINVAL))
172 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_STATUS) on a "
173 "socket with no assoc error:%d errno:%d",
174 error, errno);
175
176 tst_resm(TPASS, "getsockopt(SCTP_STATUS) on a socket with no assoc");
177
178 /* Send the first message. This will create the association. */
179 outmessage.msg_name = &udp_svr_loop;
180 outmessage.msg_namelen = sizeof(udp_svr_loop);
181 outmessage.msg_iov = &out_iov;
182 outmessage.msg_iovlen = 1;
183 outmessage.msg_control = outcmsg;
184 outmessage.msg_controllen = sizeof(outcmsg);
185 outmessage.msg_flags = 0;
186 cmsg = CMSG_FIRSTHDR(&outmessage);
187 cmsg->cmsg_level = IPPROTO_SCTP;
188 cmsg->cmsg_type = SCTP_SNDRCV;
189 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
190 outmessage.msg_controllen = cmsg->cmsg_len;
191 sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
192 memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo));
193 ppid = rand(); /* Choose an arbitrary value. */
194 stream = 1;
195 sinfo->sinfo_ppid = ppid;
196 sinfo->sinfo_stream = stream;
197 outmessage.msg_iov->iov_base = message;
198 outmessage.msg_iov->iov_len = strlen(message) + 1;
199 test_sendmsg(udp_clt_sk, &outmessage, 0, strlen(message)+1);
200
201 /* Initialize inmessage for all receives. */
202 big_buffer = test_malloc(REALLY_BIG);
203 memset(&inmessage, 0, sizeof(inmessage));
204 iov.iov_base = big_buffer;
205 iov.iov_len = REALLY_BIG;
206 inmessage.msg_iov = &iov;
207 inmessage.msg_iovlen = 1;
208 inmessage.msg_control = incmsg;
209
210 /* Get the communication up message on udp_svr_sk. */
211 inmessage.msg_controllen = sizeof(incmsg);
212 error = test_recvmsg(udp_svr_sk, &inmessage, MSG_WAITALL);
213 test_check_msg_notification(&inmessage, error,
214 sizeof(struct sctp_assoc_change),
215 SCTP_ASSOC_CHANGE, SCTP_COMM_UP);
216 sac = (struct sctp_assoc_change *)iov.iov_base;
217 udp_svr_associd = sac->sac_assoc_id;
218
219 /* Get the communication up message on udp_clt_sk. */
220 inmessage.msg_controllen = sizeof(incmsg);
221 error = test_recvmsg(udp_clt_sk, &inmessage, MSG_WAITALL);
222 test_check_msg_notification(&inmessage, error,
223 sizeof(struct sctp_assoc_change),
224 SCTP_ASSOC_CHANGE, SCTP_COMM_UP);
225 sac = (struct sctp_assoc_change *)iov.iov_base;
226 udp_clt_associd = sac->sac_assoc_id;
227
228 /* Get the first message which was sent. */
229 inmessage.msg_controllen = sizeof(incmsg);
230 error = test_recvmsg(udp_svr_sk, &inmessage, MSG_WAITALL);
231 test_check_msg_data(&inmessage, error, strlen(message) + 1,
232 MSG_EOR, stream, ppid);
233
234 /* Get SCTP_STATUS for udp_clt_sk's given association. */
235 optlen = sizeof(struct sctp_status);
236 memset(&status, 0, optlen);
237 status.sstat_assoc_id = udp_clt_associd;
238 test_getsockopt(udp_clt_sk, SCTP_STATUS, &status, &optlen);
239
240 tst_resm(TPASS, "getsockopt(SCTP_STATUS)");
241
242 /* Make sure that SCTP_STATUS getsockopt with invalid associd fails. */
243 optlen = sizeof(struct sctp_status);
244 memset(&status, 0, optlen);
245 status.sstat_assoc_id = udp_svr_associd;
246 error = getsockopt(udp_clt_sk, SOL_SCTP, SCTP_STATUS, &status,
247 &optlen);
248 if ((error != -1) && (errno != EINVAL))
249 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_STATUS) with "
250 "associd error: %d errno:%d", error, errno);
251
252 tst_resm(TPASS, "getsockopt(SCTP_STATUS) with invalid associd");
253
254 /* Make sure that SCTP_STATUS getsockopt with NULL associd fails. */
255 optlen = sizeof(struct sctp_status);
256 memset(&status, 0, optlen);
257 status.sstat_assoc_id = 0;
258 error = getsockopt(udp_svr_sk, SOL_SCTP, SCTP_STATUS, &status,
259 &optlen);
260 if ((error != -1) && (errno != EINVAL))
261 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_STATUS) with "
262 "NULL associd error: %d errno:%d", error, errno);
263
264 tst_resm(TPASS, "getsockopt(SCTP_STATUS) with NULL associd");
265
266 /* Shut down the link. */
267 close(udp_clt_sk);
268
269 /* Get the shutdown complete notification. */
270 inmessage.msg_controllen = sizeof(incmsg);
271 error = test_recvmsg(udp_svr_sk, &inmessage, MSG_WAITALL);
272 test_check_msg_notification(&inmessage, error,
273 sizeof(struct sctp_assoc_change),
274 SCTP_ASSOC_CHANGE, SCTP_SHUTDOWN_COMP);
275
276 error = 0;
277 close(udp_svr_sk);
278
279 /* TEST #2: SCTP_EVENTS socket option and SCTP_SHUTDOWN_EVENT
280 * notification.
281 */
282 /* Create the two endpoints which will talk to each other. */
283 udp_svr_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
284 udp_clt_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
285
286 /* Enable ASSOC_CHANGE and SNDRCVINFO notifications. */
287 test_enable_assoc_change(udp_svr_sk);
288 test_enable_assoc_change(udp_clt_sk);
289
290 /* Bind these sockets to the test ports. */
291 test_bind(udp_svr_sk, &udp_svr_loop.sa, sizeof(udp_svr_loop));
292 test_bind(udp_clt_sk, &udp_clt_loop.sa, sizeof(udp_clt_loop));
293
294 /* Mark udp_svr_sk as being able to accept new associations. */
295 test_listen(udp_svr_sk, 1);
296
297 /* Get the default events that are enabled on udp_svr_sk. */
298 optlen = sizeof(subscribe);
299 test_getsockopt(udp_svr_sk, SCTP_EVENTS, &subscribe, &optlen);
300
301 /* Get the default events that are enabled on udp_clt_sk. */
302 optlen = sizeof(subscribe);
303 test_getsockopt(udp_clt_sk, SCTP_EVENTS, &subscribe, &optlen);
304
305 tst_resm(TPASS, "getsockopt(SCTP_EVENTS)");
306
307 /* Disable all the events on udp_svr_sk and udp_clt_sk. */
308 memset(&subscribe, 0, sizeof(struct sctp_event_subscribe));
309 test_setsockopt(udp_svr_sk, SCTP_EVENTS, &subscribe,
310 sizeof(subscribe));
311 test_setsockopt(udp_clt_sk, SCTP_EVENTS, &subscribe,
312 sizeof(subscribe));
313
314 tst_resm(TPASS, "setsockopt(SCTP_EVENTS)");
315
316 /* Get the updated list of enabled events on udp_svr_sk and
317 * udp_clt_sk.
318 */
319 optlen = sizeof(subscribe);
320 test_getsockopt(udp_svr_sk, SCTP_EVENTS, &subscribe, &optlen);
321 optlen = sizeof(subscribe);
322 test_getsockopt(udp_clt_sk, SCTP_EVENTS, &subscribe, &optlen);
323
324 /* Send a message. This will create the association. */
325 outmessage.msg_iov->iov_base = message;
326 outmessage.msg_iov->iov_len = strlen(message) + 1;
327 test_sendmsg(udp_clt_sk, &outmessage, 0, strlen(message)+1);
328
329 /* Get the message which was sent. */
330 inmessage.msg_controllen = sizeof(incmsg);
331 error = test_recvmsg(udp_svr_sk, &inmessage, MSG_WAITALL);
332 test_check_msg_data(&inmessage, error, strlen(message) + 1,
333 MSG_EOR, 0, 0);
334 /* Verify that we received the msg without any ancillary data. */
335 if (inmessage.msg_controllen != 0)
336 tst_brkm(TBROK, tst_exit, "Receive unexpected ancillary"
337 "data");
338
339 /* Enable SCTP_SHUTDOWN_EVENTs on udp_svr_sk. */
340 memset(&subscribe, 0, sizeof(struct sctp_event_subscribe));
341 subscribe.sctp_shutdown_event = 1;
342 test_setsockopt(udp_svr_sk, SCTP_EVENTS, &subscribe,
343 sizeof(subscribe));
344
345 error = 0;
346 /* Shut down the link. */
347 close(udp_clt_sk);
348
349 /* Get the SHUTDOWN_EVENT notification on udp_svr_sk. */
350 inmessage.msg_controllen = sizeof(incmsg);
351 error = test_recvmsg(udp_svr_sk, &inmessage, MSG_WAITALL);
352 test_check_msg_notification(&inmessage, error,
353 sizeof(struct sctp_shutdown_event),
354 SCTP_SHUTDOWN_EVENT, 0);
355
356 tst_resm(TPASS, "setsockopt(SCTP_EVENTS) - SCTP_SHUTDOWN_EVENT");
357
358 close(udp_svr_sk);
359
360 /* TEST #3: whether sctp_opt_info equals */
361 /* Create the two endpoints which will talk to each other. */
362 udp_svr_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
363 udp_clt_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
364
365 /* Enable ASSOC_CHANGE and SNDRCVINFO notifications. */
366 test_enable_assoc_change(udp_svr_sk);
367 test_enable_assoc_change(udp_clt_sk);
368
369 /* Bind these sockets to the test ports. */
370 test_bind(udp_svr_sk, &udp_svr_loop.sa, sizeof(udp_svr_loop));
371 test_bind(udp_clt_sk, &udp_clt_loop.sa, sizeof(udp_clt_loop));
372
373 /* Mark udp_svr_sk as being able to accept new associations. */
374 test_listen(udp_svr_sk, 1);
375
376 /* Send the first message. This will create the association. */
377 outmessage.msg_name = &udp_svr_loop;
378 outmessage.msg_namelen = sizeof(udp_svr_loop);
379 outmessage.msg_iov = &out_iov;
380 outmessage.msg_iovlen = 1;
381 outmessage.msg_control = outcmsg;
382 outmessage.msg_controllen = sizeof(outcmsg);
383 outmessage.msg_flags = 0;
384 cmsg = CMSG_FIRSTHDR(&outmessage);
385 cmsg->cmsg_level = IPPROTO_SCTP;
386 cmsg->cmsg_type = SCTP_SNDRCV;
387 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
388 outmessage.msg_controllen = cmsg->cmsg_len;
389 sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
390 memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo));
391 ppid = rand(); /* Choose an arbitrary value. */
392 stream = 1;
393 sinfo->sinfo_ppid = ppid;
394 sinfo->sinfo_stream = stream;
395 outmessage.msg_iov->iov_base = message;
396 outmessage.msg_iov->iov_len = strlen(message) + 1;
397 test_sendmsg(udp_clt_sk, &outmessage, 0, strlen(message)+1);
398
399 /* Get the communication up message on udp_clt_sk. */
400 inmessage.msg_controllen = sizeof(incmsg);
401 error = test_recvmsg(udp_clt_sk, &inmessage, MSG_WAITALL);
402 test_check_msg_notification(&inmessage, error,
403 sizeof(struct sctp_assoc_change),
404 SCTP_ASSOC_CHANGE, SCTP_COMM_UP);
405 sac = (struct sctp_assoc_change *)iov.iov_base;
406 udp_clt_associd = sac->sac_assoc_id;
407
408 /* Compare the SCTP_STATUS result between sctp_opt_info and
409 * getsockopt
410 */
411 {
412 struct sctp_status status1, status2;
413
414 memset(&status1, 0, sizeof(status1));
415 memset(&status2, 0, sizeof(status2));
416 optlen = sizeof(struct sctp_status);
417
418 /* Test SCTP_STATUS for udp_clt_sk's given association. */
419 error = sctp_opt_info(udp_clt_sk,udp_clt_associd,SCTP_STATUS,
420 (char *)&status1, &optlen);
421 if (error != 0)
422 tst_brkm(TBROK, tst_exit,
423 "sctp_opt_info(SCTP_STATUS): %s",
424 strerror(errno));
425
426 status2.sstat_assoc_id = udp_clt_associd;
427 error = getsockopt(udp_clt_sk, IPPROTO_SCTP, SCTP_STATUS,
428 (char *)&status2, &optlen);
429 if (error != 0)
430 tst_brkm(TBROK, tst_exit,
431 "getsockopt(SCTP_STATUS): %s",
432 strerror(errno));
433 if (strncmp((char *)&status1, (char *)&status2, optlen))
434 tst_brkm(TBROK, tst_exit, "sctp_opt_info(SCTP_STAUS)"
435 "doesn't match getsockopt(SCTP_STATUS)");
436
437 tst_resm(TPASS, "sctp_opt_info(SCTP_STATUS)");
438 }
439 error = 0;
440 /* Shut down the link. */
441 close(udp_svr_sk);
442 close(udp_clt_sk);
443
444 /* TEST #4: SCTP_INITMSG socket option. */
445 /* Create a socket. */
446 udp_svr_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
447
448 /* Bind this socket to the test port. */
449 test_bind(udp_svr_sk, &udp_svr_loop.sa, sizeof(udp_svr_loop));
450
451 /* Enable ASSOC_CHANGE and SNDRCVINFO notifications. */
452 test_enable_assoc_change(udp_svr_sk);
453
454 /* Get the default parameters for association initialization. */
455 optlen = sizeof(initmsg);
456 test_getsockopt(udp_svr_sk, SCTP_INITMSG, &initmsg, &optlen);
457
458 tst_resm(TPASS, "getsockopt(SCTP_INITMSG)");
459
460 /* Change the parameters for association initialization. */
461 initmsg.sinit_num_ostreams = 5;
462 initmsg.sinit_max_instreams = 5;
463 initmsg.sinit_max_attempts = 3;
464 initmsg.sinit_max_init_timeo = 30;
465 test_setsockopt(udp_svr_sk, SCTP_INITMSG, &initmsg, sizeof(initmsg));
466
467 tst_resm(TPASS, "setsockopt(SCTP_INITMSG)");
468
469 /* Get the updated parameters for association initialization. */
470 optlen = sizeof(initmsg);
471 test_getsockopt(udp_svr_sk, SCTP_INITMSG, &initmsg, &optlen);
472
473 close(udp_svr_sk);
474
475 /* TEST #5: SCTP_PEER_ADDR_PARAMS socket option. */
476 /* Create a socket. */
477 udp_svr_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
478
479 /* Get the default parameters for this endpoint */
480 optlen = sizeof(paddrparams);
481 memset(&paddrparams, 0, sizeof(paddrparams));
482 paddrparams.spp_address.ss_family = AF_INET;
483 test_getsockopt(udp_svr_sk, SCTP_PEER_ADDR_PARAMS, &paddrparams,
484 &optlen);
485
486 dflt_pathmaxrxt = paddrparams.spp_pathmaxrxt;
487 tst_resm(TPASS, "getsockopt(SCTP_PEER_ADDR_PARAMS)");
488
489 /* Change the default parameters for this endpoint (socket) */
490 paddrparams.spp_hbinterval = 1000;
491 paddrparams.spp_pathmaxrxt = dflt_pathmaxrxt+1;
492 paddrparams.spp_sackdelay = 100;
493 test_setsockopt(udp_svr_sk, SCTP_PEER_ADDR_PARAMS, &paddrparams,
494 sizeof(paddrparams));
495
496 paddrparams.spp_pathmaxrxt = 0;
497
498 /* Get the updated default parameters for this endpoint. */
499 optlen = sizeof(paddrparams);
500 test_getsockopt(udp_svr_sk, SCTP_PEER_ADDR_PARAMS, &paddrparams,
501 &optlen);
502 if (paddrparams.spp_pathmaxrxt != dflt_pathmaxrxt+1)
503 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
504 "mismatch");
505
506 value.assoc_id = 0;
507 optlen = sizeof(value);
508 test_getsockopt(udp_svr_sk, SCTP_DELAYED_ACK_TIME, &value,
509 &optlen);
510 if (value.assoc_value != 100)
511 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DELAYED_ACK_TIME) "
512 "mismatch");
513
514 value.assoc_id = 0;
515 value.assoc_value = 250;
516 test_setsockopt(udp_svr_sk, SCTP_DELAYED_ACK_TIME, &value,
517 sizeof(value));
518 optlen = sizeof(paddrparams);
519 test_getsockopt(udp_svr_sk, SCTP_PEER_ADDR_PARAMS, &paddrparams,
520 &optlen);
521 if (paddrparams.spp_sackdelay != 250)
522 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_DELAYED_ACK_TIME) "
523 "mismatch");
524
525 tst_resm(TPASS, "setsockopt(SCTP_DELAYED_ACK_TIME)");
526
527
528 /* Ensure that prior defaults are preserved for a new endpoint */
529 udp_clt_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
530 optlen = sizeof(paddrparams);
531 memset(&paddrparams, 0, sizeof(paddrparams));
532 paddrparams.spp_address.ss_family = AF_INET;
533 test_getsockopt(udp_clt_sk, SCTP_PEER_ADDR_PARAMS, &paddrparams,
534 &optlen);
535 if (paddrparams.spp_pathmaxrxt != dflt_pathmaxrxt)
536 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_PEER_ADDR_PARAMS) "
537 "mismatch");
538
539
540 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS)");
541
542 /* Invalid assoc id */
543 paddrparams.spp_assoc_id = 1234;
544 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_PEER_ADDR_PARAMS,
545 &paddrparams,
546 sizeof(paddrparams));
547 if ((-1 != error) || (EINVAL != errno))
548 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
549 "invalid associd error:%d, errno:%d\n",
550 error, errno);
551
552 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
553 "- one-to-many style invalid associd");
554
555 test_bind(udp_svr_sk, &udp_svr_loop.sa, sizeof(udp_svr_loop));
556 test_bind(udp_clt_sk, &udp_clt_loop.sa, sizeof(udp_clt_loop));
557
558 test_listen(udp_svr_sk, 5);
559
560 test_enable_assoc_change(udp_svr_sk);
561 test_enable_assoc_change(udp_clt_sk);
562
563 /* Do a connect on a UDP-style socket and establish an association. */
564 test_connect(udp_clt_sk, &udp_svr_loop.sa, sizeof(udp_svr_loop));
565
566 /* Receive the COMM_UP notifications and get the associd's */
567 inmessage.msg_controllen = sizeof(incmsg);
568 error = test_recvmsg(udp_svr_sk, &inmessage, MSG_WAITALL);
569 test_check_msg_notification(&inmessage, error,
570 sizeof(struct sctp_assoc_change),
571 SCTP_ASSOC_CHANGE, SCTP_COMM_UP);
572 sac = (struct sctp_assoc_change *)iov.iov_base;
573
574 paddrparams.spp_assoc_id = sac->sac_assoc_id;
575 memcpy(&paddrparams.spp_address, &udp_clt_loop, sizeof(udp_clt_loop));
576 paddrparams.spp_hbinterval = 1000;
577 paddrparams.spp_pathmaxrxt = dflt_pathmaxrxt+1;
578 test_setsockopt(udp_svr_sk, SCTP_PEER_ADDR_PARAMS, &paddrparams,
579 sizeof(paddrparams));
580 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS) - "
581 "one-to-many style valid associd valid address");
582
583 paddrparams.spp_assoc_id = sac->sac_assoc_id;
584 memcpy(&paddrparams.spp_address, &udp_svr_loop, sizeof(udp_svr_loop));
585 paddrparams.spp_hbinterval = 1000;
586 paddrparams.spp_pathmaxrxt = dflt_pathmaxrxt+1;
587
588 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_PEER_ADDR_PARAMS,
589 &paddrparams,
590 sizeof(paddrparams));
591 if ((-1 != error) || (EINVAL != errno))
592 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
593 "invalid transport error:%d, errno:%d\n",
594 error, errno);
595
596 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
597 "- one-to-many style invalid transport");
598
599 paddrparams.spp_assoc_id = sac->sac_assoc_id;
600 memcpy(&paddrparams.spp_address, &udp_clt_loop, sizeof(udp_clt_loop));
601 paddrparams.spp_hbinterval = 1000;
602 paddrparams.spp_pathmaxrxt = dflt_pathmaxrxt+1;
603
604 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_PEER_ADDR_PARAMS,
605 &paddrparams,
606 sizeof(paddrparams) - 1);
607 if ((-1 != error) || (EINVAL != errno))
608 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
609 "invalid parameter length error:%d, errno:%d\n",
610 error, errno);
611
612 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
613 "- one-to-many style invalid parameter length");
614
615 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_DELAYED_ACK_TIME,
616 &value,
617 sizeof(value) - 1);
618 if ((-1 != error) || (EINVAL != errno))
619 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_DELAYED_ACK_TIME) "
620 "invalid parameter length error:%d, errno:%d\n",
621 error, errno);
622
623 tst_resm(TPASS, "setsockopt(SCTP_DELAYED_ACK_TIME) "
624 "- one-to-many style invalid parameter length");
625
626 memset(&paddrparams, 0, sizeof(paddrparams));
627 paddrparams.spp_assoc_id = sac->sac_assoc_id;
628 memcpy(&paddrparams.spp_address, &udp_clt_loop, sizeof(udp_clt_loop));
629 paddrparams.spp_sackdelay = 501;
630
631 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_PEER_ADDR_PARAMS,
632 &paddrparams,
633 sizeof(paddrparams));
634 if ((-1 != error) || (EINVAL != errno))
635 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
636 "invalid sack delay error:%d, errno:%d\n",
637 error, errno);
638
639 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
640 "- one-to-many style invalid sack delay");
641
642 value.assoc_id = sac->sac_assoc_id;
643 value.assoc_value = 501;
644
645 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_DELAYED_ACK_TIME,
646 &value,
647 sizeof(value));
648 if ((-1 != error) || (EINVAL != errno))
649 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_DELAYED_ACK_TIME) "
650 "invalid sack delay error:%d, errno:%d\n",
651 error, errno);
652
653 tst_resm(TPASS, "setsockopt(SCTP_DELAYED_ACK_TIME) "
654 "- one-to-many style invalid sack delay");
655
656 memset(&paddrparams, 0, sizeof(paddrparams));
657 paddrparams.spp_assoc_id = sac->sac_assoc_id;
658 memcpy(&paddrparams.spp_address, &udp_clt_loop, sizeof(udp_clt_loop));
659 paddrparams.spp_pathmtu = 511;
660
661 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_PEER_ADDR_PARAMS,
662 &paddrparams,
663 sizeof(paddrparams));
664 if ((-1 != error) || (EINVAL != errno))
665 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
666 "invalid path MTU error:%d, errno:%d\n",
667 error, errno);
668
669 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
670 "- one-to-many style invalid path MTU");
671
672 memset(&paddrparams, 0, sizeof(paddrparams));
673 paddrparams.spp_assoc_id = sac->sac_assoc_id;
674 memcpy(&paddrparams.spp_address, &udp_clt_loop, sizeof(udp_clt_loop));
675 paddrparams.spp_flags = SPP_HB_ENABLE | SPP_HB_DISABLE;
676
677 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_PEER_ADDR_PARAMS,
678 &paddrparams,
679 sizeof(paddrparams));
680 if ((-1 != error) || (EINVAL != errno))
681 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
682 "invalid hb enable flags error:%d, errno:%d\n",
683 error, errno);
684
685 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
686 "- one-to-many style invalid hb enable flags");
687
688 memset(&paddrparams, 0, sizeof(paddrparams));
689 paddrparams.spp_assoc_id = sac->sac_assoc_id;
690 memcpy(&paddrparams.spp_address, &udp_clt_loop, sizeof(udp_clt_loop));
691 paddrparams.spp_flags = SPP_PMTUD_ENABLE | SPP_PMTUD_DISABLE;
692
693 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_PEER_ADDR_PARAMS,
694 &paddrparams,
695 sizeof(paddrparams));
696 if ((-1 != error) || (EINVAL != errno))
697 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
698 "invalid PMTU discovery enable flags error:%d, errno:%d\n",
699 error, errno);
700
701 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
702 "- one-to-many style invalid PMTU discovery enable flags");
703
704 memset(&paddrparams, 0, sizeof(paddrparams));
705 paddrparams.spp_assoc_id = sac->sac_assoc_id;
706 memcpy(&paddrparams.spp_address, &udp_clt_loop, sizeof(udp_clt_loop));
707 paddrparams.spp_flags = SPP_SACKDELAY_ENABLE | SPP_SACKDELAY_DISABLE;
708
709 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_PEER_ADDR_PARAMS,
710 &paddrparams,
711 sizeof(paddrparams));
712 if ((-1 != error) || (EINVAL != errno))
713 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
714 "invalid sack delay enable flags error:%d, errno:%d\n",
715 error, errno);
716
717 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
718 "- one-to-many style invalid sack delay enable flags");
719
720 memset(&paddrparams, 0, sizeof(paddrparams));
721 paddrparams.spp_flags = SPP_HB_DEMAND;
722
723 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_PEER_ADDR_PARAMS,
724 &paddrparams,
725 sizeof(paddrparams));
726 if ((-1 != error) || (EINVAL != errno))
727 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
728 "invalid hb demand error:%d, errno:%d\n",
729 error, errno);
730
731 tst_resm(TPASS, "setsockopt(SCTP_PEER_ADDR_PARAMS) "
732 "- one-to-many style invalid hb demand");
733
734 close(udp_svr_sk);
735 close(udp_clt_sk);
736
737
738 /* TEST #6: SCTP_DEFAULT_SEND_PARAM socket option. */
739 /* Create and bind 2 UDP-style sockets(udp_svr_sk, udp_clt_sk) and
740 * 2 TCP-style sockets. (tcp_svr_sk, tcp_clt_sk)
741 */
742 udp_svr_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
743 udp_clt_sk = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);
744 tcp_svr_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);
745 tcp_clt_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);
746
747 /* Enable ASSOC_CHANGE and SNDRCVINFO notifications. */
748 test_enable_assoc_change(udp_svr_sk);
749 test_enable_assoc_change(udp_clt_sk);
750 test_enable_assoc_change(tcp_svr_sk);
751 test_enable_assoc_change(tcp_clt_sk);
752
753 test_bind(udp_svr_sk, &udp_svr_loop.sa, sizeof(udp_svr_loop));
754 test_bind(udp_clt_sk, &udp_clt_loop.sa, sizeof(udp_clt_loop));
755 test_bind(tcp_svr_sk, &tcp_svr_loop.sa, sizeof(tcp_svr_loop));
756 test_bind(tcp_clt_sk, &tcp_clt_loop.sa, sizeof(tcp_clt_loop));
757
758 /* Mark udp_svr_sk and tcp_svr_sk as being able to accept new
759 * associations.
760 */
761 test_listen(udp_svr_sk, 5);
762 test_listen(tcp_svr_sk, 5);
763
764 /* Set default send parameters on the unconnected UDP-style sockets. */
765 memset(&set_udp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
766 set_udp_sk_dflt_param.sinfo_ppid = 1000;
767 test_setsockopt(udp_svr_sk, SCTP_DEFAULT_SEND_PARAM,
768 &set_udp_sk_dflt_param, sizeof(set_udp_sk_dflt_param));
769 memset(&set_udp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
770 set_udp_sk_dflt_param.sinfo_ppid = 1000;
771 test_setsockopt(udp_clt_sk, SCTP_DEFAULT_SEND_PARAM,
772 &set_udp_sk_dflt_param, sizeof(set_udp_sk_dflt_param));
773
774 tst_resm(TPASS, "setsockopt(SCTP_DEFAULT_SEND_PARAM) - "
775 "one-to-many style socket");
776
777 /* Get default send parameters on the unconnected UDP-style socket. */
778 memset(&get_udp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
779 optlen = sizeof(get_udp_sk_dflt_param);
780 test_getsockopt(udp_svr_sk, SCTP_DEFAULT_SEND_PARAM,
781 &get_udp_sk_dflt_param, &optlen);
782
783 /* Verify that the get param matches set param. */
784 if (set_udp_sk_dflt_param.sinfo_ppid !=
785 get_udp_sk_dflt_param.sinfo_ppid)
786 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
787 "mismatch.");
788
789 /* Get default send parameters on the unconnected UDP-style socket. */
790 memset(&get_udp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
791 optlen = sizeof(get_udp_sk_dflt_param);
792 test_getsockopt(udp_clt_sk, SCTP_DEFAULT_SEND_PARAM,
793 &get_udp_sk_dflt_param, &optlen);
794
795 /* Verify that the get param matches set param. */
796 if (set_udp_sk_dflt_param.sinfo_ppid !=
797 get_udp_sk_dflt_param.sinfo_ppid)
798 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
799 "mismatch.");
800
801 tst_resm(TPASS, "getsockopt(SCTP_DEFAULT_SEND_PARAM) - "
802 "one-to-many style socket");
803
804 /* Verify that trying to set send params with an invalid assoc id
805 * on an UDP-style socket fails.
806 */
807 memset(&set_udp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
808 set_udp_sk_dflt_param.sinfo_ppid = 1000;
809 /* Invalid assoc id */
810 set_udp_sk_dflt_param.sinfo_assoc_id = 1234;
811 error = setsockopt(udp_clt_sk, SOL_SCTP, SCTP_DEFAULT_SEND_PARAM,
812 &set_udp_sk_dflt_param,
813 sizeof(set_udp_sk_dflt_param));
814 if ((-1 != error) || (EINVAL != errno))
815 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_DEFAULT_SEND_PARAM) "
816 "invalid associd error:%d, errno:%d\n",
817 error, errno);
818
819 tst_resm(TPASS, "setsockopt(SCTP_DEFAULT_SEND_PARAM) "
820 "- one-to-many style invalid associd");
821
822 /* Do a connect on a UDP-style socket and establish an association. */
823 test_connect(udp_clt_sk, &udp_svr_loop.sa, sizeof(udp_svr_loop));
824
825 /* Receive the COMM_UP notifications and get the associd's */
826 inmessage.msg_controllen = sizeof(incmsg);
827 error = test_recvmsg(udp_svr_sk, &inmessage, MSG_WAITALL);
828 test_check_msg_notification(&inmessage, error,
829 sizeof(struct sctp_assoc_change),
830 SCTP_ASSOC_CHANGE, SCTP_COMM_UP);
831 sac = (struct sctp_assoc_change *)iov.iov_base;
832 udp_svr_associd = sac->sac_assoc_id;
833
834 inmessage.msg_controllen = sizeof(incmsg);
835 error = test_recvmsg(udp_clt_sk, &inmessage, MSG_WAITALL);
836 test_check_msg_notification(&inmessage, error,
837 sizeof(struct sctp_assoc_change),
838 SCTP_ASSOC_CHANGE, SCTP_COMM_UP);
839 sac = (struct sctp_assoc_change *)iov.iov_base;
840 udp_clt_associd = sac->sac_assoc_id;
841
842 /* Verify that trying to set send params with an assoc id not
843 * belonging to the socket on an UDP-style socket fails.
844 */
845 memset(&set_udp_assoc_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
846 set_udp_assoc_dflt_param.sinfo_ppid = 3000;
847 set_udp_assoc_dflt_param.sinfo_assoc_id = udp_clt_associd;
848 error = setsockopt(udp_svr_sk, SOL_SCTP, SCTP_DEFAULT_SEND_PARAM,
849 &set_udp_assoc_dflt_param,
850 sizeof(set_udp_assoc_dflt_param));
851 if ((-1 != error) || (EINVAL != errno))
852 tst_brkm(TBROK, tst_exit, "setsockopt(SCTP_DEFAULT_SEND_PARAM) "
853 "associd belonging to another socket "
854 "error:%d, errno:%d", error, errno);
855
856 tst_resm(TPASS, "setsockopt(SCTP_DEFAULT_SEND_PARAM) - "
857 "one-to-many style associd belonging to another socket");
858
859 /* Set default send parameters of an association on the listening
860 * UDP-style socket with a valid associd.
861 */
862 memset(&set_udp_assoc_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
863 set_udp_assoc_dflt_param.sinfo_ppid = 3000;
864 set_udp_assoc_dflt_param.sinfo_assoc_id = udp_svr_associd;
865 test_setsockopt(udp_svr_sk, SCTP_DEFAULT_SEND_PARAM,
866 &set_udp_assoc_dflt_param,
867 sizeof(set_udp_assoc_dflt_param));
868
869 tst_resm(TPASS, "setsockopt(SCTP_DEFAULT_SEND_PARAM) - "
870 "one-to-many style valid associd");
871
872 /* Get default send parameters of an association on the listening
873 * UDP-style socket with a valid associd.
874 */
875 memset(&get_udp_assoc_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
876 get_udp_assoc_dflt_param.sinfo_assoc_id = udp_svr_associd ;
877 optlen = sizeof(get_udp_assoc_dflt_param);
878 test_getsockopt(udp_svr_sk, SCTP_DEFAULT_SEND_PARAM,
879 &get_udp_assoc_dflt_param, &optlen);
880
881 /* Verify that the get param matches the set param. */
882 if (get_udp_assoc_dflt_param.sinfo_ppid !=
883 set_udp_assoc_dflt_param.sinfo_ppid)
884 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
885 "mismatch.");
886
887 tst_resm(TPASS, "getsockopt(SCTP_DEFAULT_SEND_PARAM) - "
888 "one-to-many style valid associd");
889
890 /* Get default send parameters of an association on the connected
891 * UDP-style socket with zero associd. This should return the
892 * socket wide default parameters.
893 */
894 memset(&get_udp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
895 get_udp_sk_dflt_param.sinfo_assoc_id = 0 ;
896 optlen = sizeof(get_udp_sk_dflt_param);
897 test_getsockopt(udp_clt_sk, SCTP_DEFAULT_SEND_PARAM,
898 &get_udp_sk_dflt_param, &optlen);
899
900 /* Verify that the get param matches the socket-wide set param. */
901 if (get_udp_sk_dflt_param.sinfo_ppid !=
902 set_udp_sk_dflt_param.sinfo_ppid)
903 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
904 "mismatch.");
905
906 tst_resm(TPASS, "getsockopt(SCTP_DEFAULT_SEND_PARAM) - "
907 "one-to-many style zero associd");
908
909 peeloff_sk = test_sctp_peeloff(udp_svr_sk, udp_svr_associd);
910
911 /* Get default send parameters of an association on the peeled off
912 * UDP-style socket. This should return the association's default
913 * parameters.
914 */
915 memset(&get_peeloff_assoc_dflt_param, 0,
916 sizeof(struct sctp_sndrcvinfo));
917 get_peeloff_assoc_dflt_param.sinfo_assoc_id = 0 ;
918 optlen = sizeof(get_peeloff_assoc_dflt_param);
919 test_getsockopt(peeloff_sk, SCTP_DEFAULT_SEND_PARAM,
920 &get_peeloff_assoc_dflt_param, &optlen);
921
922 /* Verify that the get param matches the association's set param. */
923 if (get_peeloff_assoc_dflt_param.sinfo_ppid !=
924 set_udp_assoc_dflt_param.sinfo_ppid)
925 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
926 "mismatch.");
927
928 tst_resm(TPASS, "getsockopt(SCTP_DEFAULT_SEND_PARAM) - "
929 "one-to-many style peeled off socket");
930
931 /* Set default send parameters on the unconnected TCP-style sockets. */
932 memset(&set_tcp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
933 set_tcp_sk_dflt_param.sinfo_ppid = 2000;
934 /* Invalid assoc id, ignored on a TCP-style socket. */
935 set_tcp_sk_dflt_param.sinfo_assoc_id = 1234;
936 test_setsockopt(tcp_svr_sk, SCTP_DEFAULT_SEND_PARAM,
937 &set_tcp_sk_dflt_param,
938 sizeof(set_tcp_sk_dflt_param));
939
940 /* Set default send parameters on the unconnected TCP-style sockets. */
941 memset(&set_tcp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
942 set_tcp_sk_dflt_param.sinfo_ppid = 2000;
943 /* Invalid assoc id, ignored on a TCP-style socket. */
944 set_tcp_sk_dflt_param.sinfo_assoc_id = 1234;
945 test_setsockopt(tcp_clt_sk, SCTP_DEFAULT_SEND_PARAM,
946 &set_tcp_sk_dflt_param,
947 sizeof(set_tcp_sk_dflt_param));
948
949 tst_resm(TPASS, "setsockopt(SCTP_DEFAULT_SEND_PARAM) - "
950 "one-to-one style socket");
951
952 /* Get default send parameters on the unconnected TCP-style socket. */
953 memset(&get_tcp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
954 optlen = sizeof(get_tcp_sk_dflt_param);
955 test_getsockopt(tcp_svr_sk, SCTP_DEFAULT_SEND_PARAM,
956 &get_tcp_sk_dflt_param, &optlen);
957
958 /* Verify that the get param matches set param. */
959 if (set_tcp_sk_dflt_param.sinfo_ppid !=
960 get_tcp_sk_dflt_param.sinfo_ppid)
961 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
962 "mismatch.");
963
964 /* Get default send parameters on the unconnected TCP-style socket. */
965 memset(&get_tcp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
966 optlen = sizeof(get_tcp_sk_dflt_param);
967 test_getsockopt(tcp_clt_sk, SCTP_DEFAULT_SEND_PARAM,
968 &get_tcp_sk_dflt_param, &optlen);
969
970 /* Verify that the get param matches set param. */
971 if (set_tcp_sk_dflt_param.sinfo_ppid !=
972 get_tcp_sk_dflt_param.sinfo_ppid)
973 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
974 "mismatch.");
975
976 tst_resm(TPASS, "getsockopt(SCTP_DEFAULT_SEND_PARAM) - "
977 "one-to-one style socket");
978
979 /* Do a connect on a TCP-style socket and establish an association. */
980 test_connect(tcp_clt_sk, &tcp_svr_loop.sa, sizeof(tcp_svr_loop));
981
982 /* Set default send parameters of an association on the connected
983 * TCP-style socket.
984 */
985 memset(&set_tcp_assoc_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
986 set_tcp_assoc_dflt_param.sinfo_ppid = 4000;
987 set_tcp_assoc_dflt_param.sinfo_assoc_id = 0;
988 test_setsockopt(tcp_clt_sk, SCTP_DEFAULT_SEND_PARAM,
989 &set_tcp_assoc_dflt_param,
990 sizeof(set_tcp_assoc_dflt_param));
991
992 tst_resm(TPASS, "setsockopt(SCTP_DEFAULT_SEND_PARAM) - "
993 "one-to-one style assoc");
994
995 /* Get default send parameters of an association on the connected
996 * TCP-style socket.
997 */
998 memset(&get_tcp_assoc_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
999 optlen = sizeof(get_tcp_assoc_dflt_param);
1000 test_getsockopt(tcp_clt_sk, SCTP_DEFAULT_SEND_PARAM,
1001 &get_tcp_assoc_dflt_param, &optlen);
1002
1003 if (set_tcp_assoc_dflt_param.sinfo_ppid !=
1004 get_tcp_assoc_dflt_param.sinfo_ppid)
1005 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
1006 "mismatch.");
1007
1008 /* Get default send parameters on the connected TCP-style socket. */
1009 memset(&get_tcp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
1010 optlen = sizeof(get_tcp_sk_dflt_param);
1011 test_getsockopt(tcp_clt_sk, SCTP_DEFAULT_SEND_PARAM,
1012 &get_tcp_sk_dflt_param, &optlen);
1013
1014 /* Verify that the get parameters returned matches the set param
1015 * set for the association, not the socket-wide param.
1016 */
1017 if ((get_tcp_sk_dflt_param.sinfo_ppid ==
1018 set_tcp_sk_dflt_param.sinfo_ppid) ||
1019 (get_tcp_sk_dflt_param.sinfo_ppid !=
1020 set_tcp_assoc_dflt_param.sinfo_ppid))
1021 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
1022 "mismatch.");
1023
1024 /* Get default send parameters on the listening TCP-style socket. */
1025 memset(&get_tcp_sk_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
1026 optlen = sizeof(get_tcp_sk_dflt_param);
1027 test_getsockopt(tcp_svr_sk, SCTP_DEFAULT_SEND_PARAM,
1028 &get_tcp_sk_dflt_param, &optlen);
1029
1030 /* Verify that the get parameters returned matches the socket-wide
1031 * set param.
1032 */
1033 if (get_tcp_sk_dflt_param.sinfo_ppid !=
1034 set_tcp_sk_dflt_param.sinfo_ppid)
1035 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
1036 "mismatch.");
1037
1038 tst_resm(TPASS, "getsockopt(SCTP_DEFAULT_SEND_PARAM) - "
1039 "one-to-one style assoc");
1040
1041 accept_sk = test_accept(tcp_svr_sk, NULL, &addrlen);
1042
1043 /* Get default send parameters of an association on the accepted
1044 * TCP-style socket.
1045 */
1046 memset(&get_accept_assoc_dflt_param, 0, sizeof(struct sctp_sndrcvinfo));
1047 optlen = sizeof(get_accept_assoc_dflt_param);
1048 test_getsockopt(accept_sk, SCTP_DEFAULT_SEND_PARAM,
1049 &get_accept_assoc_dflt_param, &optlen);
1050
1051 error = 0;
1052
1053 /* Verify that the get parameters returned matches the socket-wide
1054 * set param.
1055 */
1056 if (get_tcp_sk_dflt_param.sinfo_ppid !=
1057 set_tcp_sk_dflt_param.sinfo_ppid)
1058 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_DEFAULT_SEND_PARAM) "
1059 "mismatch.");
1060
1061 tst_resm(TPASS, "getsockopt(SCTP_DEFAULT_SEND_PARAM) - "
1062 "one-to-one style accepted socket");
1063
1064 /* TEST #7: SCTP_GET_PEER_ADDR_INFO socket option. */
1065 /* Try 0 associd and 0 addr */
1066 memset(&pinfo, 0, sizeof(pinfo));
1067 optlen = sizeof(pinfo);
1068 error = getsockopt(udp_clt_sk, SOL_SCTP, SCTP_GET_PEER_ADDR_INFO,
1069 &pinfo, &optlen);
1070 if ((-1 != error) || (EINVAL != errno))
1071 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_GET_PEER_ADDR_INFO) "
1072 "null associd, null addr error:%d, errno:%d\n",
1073 error, errno);
1074
1075 tst_resm(TPASS, "getsockopt(SCTP_GET_PEER_ADDR_INFO) - "
1076 "null associd and null addr");
1077
1078 /* Try valid associd, but 0 addr */
1079 memset(&pinfo, 0, sizeof(pinfo));
1080 optlen = sizeof(pinfo);
1081 pinfo.spinfo_assoc_id = udp_clt_associd;
1082 error = getsockopt(udp_clt_sk, SOL_SCTP, SCTP_GET_PEER_ADDR_INFO,
1083 &pinfo, &optlen);
1084 if ((-1 != error) || (EINVAL != errno))
1085 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_GET_PEER_ADDR_INFO) "
1086 "valid associd, null addr error:%d, errno:%d\n",
1087 error, errno);
1088
1089 tst_resm(TPASS, "getsockopt(SCTP_GET_PEER_ADDR_INFO) - "
1090 "valid associd and null addr");
1091
1092 /* Try valid associd, invalid addr */
1093 memset(&pinfo, 0, sizeof(pinfo));
1094 optlen = sizeof(pinfo);
1095 pinfo.spinfo_assoc_id = udp_clt_associd;
1096 memcpy(&pinfo.spinfo_address, &udp_clt_loop, sizeof(udp_clt_loop));
1097 error = getsockopt(udp_clt_sk, SOL_SCTP, SCTP_GET_PEER_ADDR_INFO,
1098 &pinfo, &optlen);
1099 if ((-1 != error) || (EINVAL != errno))
1100 tst_brkm(TBROK, tst_exit, "getsockopt(SCTP_GET_PEER_ADDR_INFO) "
1101 "valid associd, invalid addr error:%d, errno:%d\n",
1102 error, errno);
1103
1104 tst_resm(TPASS, "getsockopt(SCTP_GET_PEER_ADDR_INFO) - "
1105 "valid associd and invalid addr");
1106
1107 /* Try valid associd, valid addr */
1108 memset(&pinfo, 0, sizeof(pinfo));
1109 optlen = sizeof(pinfo);
1110 pinfo.spinfo_assoc_id = udp_clt_associd;
1111 memcpy(&pinfo.spinfo_address, &udp_svr_loop, sizeof(udp_svr_loop));
1112 test_getsockopt(udp_clt_sk, SCTP_GET_PEER_ADDR_INFO, &pinfo, &optlen);
1113
1114 tst_resm(TPASS, "getsockopt(SCTP_GET_PEER_ADDR_INFO) - "
1115 "valid associd and valid addr");
1116
1117 /* Try valid addr, peeled off socket */
1118 memset(&pinfo, 0, sizeof(pinfo));
1119 optlen = sizeof(pinfo);
1120 pinfo.spinfo_assoc_id = 0;
1121 memcpy(&pinfo.spinfo_address, &udp_clt_loop, sizeof(udp_clt_loop));
1122 test_getsockopt(peeloff_sk, SCTP_GET_PEER_ADDR_INFO, &pinfo, &optlen);
1123
1124 tst_resm(TPASS, "getsockopt(SCTP_GET_PEER_ADDR_INFO) - "
1125 "valid associd and valid addr peeled off socket");
1126
1127 /* Try valid addr, TCP-style accept socket */
1128 memset(&pinfo, 0, sizeof(pinfo));
1129 optlen = sizeof(pinfo);
1130 pinfo.spinfo_assoc_id = 0;
1131 memcpy(&pinfo.spinfo_address, &tcp_clt_loop, sizeof(tcp_clt_loop));
1132 error = test_getsockopt(accept_sk, SCTP_GET_PEER_ADDR_INFO, &pinfo,
1133 &optlen);
1134
1135 tst_resm(TPASS, "getsockopt(SCTP_GET_PEER_ADDR_INFO) - "
1136 "valid associd and valid addr accepted socket");
1137
1138 close(udp_svr_sk);
1139 close(udp_clt_sk);
1140 close(tcp_svr_sk);
1141 close(tcp_clt_sk);
1142 close(accept_sk);
1143 close(peeloff_sk);
1144
1145 /* Indicate successful completion. */
1146 return 0;
1147 }
1148