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