1 /* SCTP kernel Implementation
2 * (C) Copyright IBM Corp. 2003
3 * Copyright (c) 1999-2001 Motorola, Inc.
4 *
5 * This file is part of the SCTP kernel Implementation
6 *
7 * The SCTP implementation is free software;
8 * you can redistribute it and/or modify it under the terms of
9 * the GNU General Public License as published by
10 * the Free Software Foundation; either version 2, or (at your option)
11 * any later version.
12 *
13 * The SCTP implementation is distributed in the hope that it
14 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15 * ************************
16 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
17 * See the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with GNU CC; see the file COPYING. If not, write to
21 * the Free Software Foundation, 59 Temple Place - Suite 330,
22 * Boston, MA 02111-1307, USA.
23 *
24 * Please send any bug reports or fixes you make to the
25 * email address(es):
26 * lksctp developers <lksctp-developers@lists.sourceforge.net>
27 *
28 * Or submit a bug report through the following website:
29 * http://www.sf.net/projects/lksctp
30 *
31 * Any bugs reported to us we will try to fix... any fixes shared will
32 * be incorporated into the next SCTP release.
33 *
34 * Written or modified by:
35 * Sridhar Samudrala <sri@us.ibm.com>
36 */
37
38 /* This is a kernel test to verify the TCP-style socket interfaces. */
39
40 #include <stdio.h>
41 #include <unistd.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <fcntl.h>
45 #include <sys/types.h>
46 #include <sys/socket.h>
47 #include <sys/uio.h>
48 #include <sys/poll.h>
49 #include <netinet/in.h>
50 #include <errno.h>
51 #include <netinet/sctp.h>
52 #include <sctputil.h>
53
54 char *TCID = __FILE__;
55 int TST_TOTAL = 22;
56 int TST_CNT = 0;
57
58 #define MAX_CLIENTS 10
59
60 int
main(int argc,char * argv[])61 main(int argc, char *argv[])
62 {
63 int clt_sk[MAX_CLIENTS], accept_sk[MAX_CLIENTS];
64 int listen_sk, clt2_sk, accept2_sk;
65 sockaddr_storage_t clt_loop[MAX_CLIENTS];
66 sockaddr_storage_t svr_loop, accept_loop, clt2_loop;
67 socklen_t addrlen;
68 int error, i;
69 char *message = "hello, world!\n";
70 char msgbuf[100];
71 int pf_class;
72 struct pollfd poll_fd;
73 fd_set set;
74 struct msghdr outmessage;
75 char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
76 struct iovec out_iov;
77 struct cmsghdr *cmsg;
78 struct sctp_sndrcvinfo *sinfo;
79 struct msghdr inmessage;
80 char incmsg[CMSG_SPACE(sizeof(sctp_cmsg_data_t))];
81 char *big_buffer;
82 struct iovec iov;
83
84 /* Rather than fflush() throughout the code, set stdout to
85 * be unbuffered.
86 */
87 setvbuf(stdout, NULL, _IONBF, 0);
88
89 /* Initialize the server and client addresses. */
90 #if TEST_V6
91 pf_class = PF_INET6;
92 svr_loop.v6.sin6_family = AF_INET6;
93 svr_loop.v6.sin6_addr = in6addr_loopback;
94 svr_loop.v6.sin6_port = htons(SCTP_TESTPORT_1);
95 for (i = 0; i < MAX_CLIENTS; i++) {
96 clt_loop[i].v6.sin6_family = AF_INET6;
97 clt_loop[i].v6.sin6_addr = in6addr_loopback;
98 clt_loop[i].v6.sin6_port = htons(SCTP_TESTPORT_2 + i);
99 }
100 clt2_loop.v6.sin6_family = AF_INET6;
101 clt2_loop.v6.sin6_addr = in6addr_loopback;
102 clt2_loop.v6.sin6_port = htons(SCTP_TESTPORT_2 + i);
103 #else
104 pf_class = PF_INET;
105 svr_loop.v4.sin_family = AF_INET;
106 svr_loop.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;
107 svr_loop.v4.sin_port = htons(SCTP_TESTPORT_1);
108 for (i = 0; i < MAX_CLIENTS; i++) {
109 clt_loop[i].v4.sin_family = AF_INET;
110 clt_loop[i].v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;
111 clt_loop[i].v4.sin_port = htons(SCTP_TESTPORT_2 + i);
112 }
113 clt2_loop.v4.sin_family = AF_INET;
114 clt2_loop.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;
115 clt2_loop.v4.sin_port = htons(SCTP_TESTPORT_2 + i);
116 #endif
117
118 /* Create and bind the listening server socket. */
119 listen_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);
120 test_bind(listen_sk, &svr_loop.sa, sizeof(svr_loop));
121
122 /* Mark listen_sk as being able to accept new associations. */
123 test_listen(listen_sk, MAX_CLIENTS-1);
124
125 /* Create and bind the client sockets. */
126 for (i = 0; i < MAX_CLIENTS; i++) {
127 clt_sk[i] = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);
128 test_bind(clt_sk[i], &clt_loop[i].sa, sizeof(clt_loop[i]));
129 }
130 clt2_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);
131 test_bind(clt2_sk, &clt2_loop.sa, sizeof(clt2_loop));
132
133 addrlen = sizeof(accept_loop);
134 /* Try to do accept on a non-listening socket. It should fail. */
135 error = accept(clt_sk[0], &accept_loop.sa, &addrlen);
136 if ((-1 != error) && (EINVAL != errno))
137 tst_brkm(TBROK, tst_exit, "accept on non-listening socket "
138 "error:%d, errno:%d", error, errno);
139
140 tst_resm(TPASS, "accept on non-listening socket");
141
142 /* Try to do a connect from a listening socket. It should fail. */
143 error = connect(listen_sk, (struct sockaddr *)&clt_loop[0],
144 sizeof(clt_loop[0]));
145 if ((-1 != error) && (EISCONN != errno))
146 tst_brkm(TBROK, tst_exit, "connect to non-listening socket "
147 "error:%d, errno:%d", error, errno);
148
149 tst_resm(TPASS, "connect to non-listening socket");
150
151 /* Do a blocking connect from clt_sk's to listen_sk */
152 for (i = 0; i < MAX_CLIENTS; i++)
153 test_connect(clt_sk[i], &svr_loop.sa, sizeof(svr_loop));
154
155 tst_resm(TPASS, "connect to listening socket");
156
157 /* Verify that no more connect's can be done after the acceptq
158 * backlog has reached the max value.
159 */
160 error = connect(clt2_sk, &svr_loop.sa, sizeof(svr_loop));
161 if ((-1 != error) && (ECONNREFUSED != errno))
162 tst_brkm(TBROK, tst_exit, "connect after max backlog "
163 "error:%d, errno:%d", error, errno);
164
165 tst_resm(TPASS, "connect after max backlog");
166
167 /* Extract the associations on the listening socket as new sockets. */
168 for (i = 0; i < MAX_CLIENTS; i++) {
169 poll_fd.fd = listen_sk;
170 poll_fd.events = POLLIN;
171 poll_fd.revents = 0;
172 error = poll(&poll_fd, 1, -1);
173 if ((1 != error) && (1 != poll_fd.revents))
174 tst_brkm(TBROK, tst_exit, "Unexpected return value "
175 "with poll, error:%d errno:%d, revents:%d",
176 error, errno, poll_fd.revents);
177
178 addrlen = sizeof(accept_loop);
179 accept_sk[i] = test_accept(listen_sk, &accept_loop.sa,
180 &addrlen);
181 }
182
183 tst_resm(TPASS, "accept from listening socket");
184
185 /* Try to do a connect on an established socket. It should fail. */
186 error = connect(accept_sk[0], &clt_loop[0].sa, sizeof(clt_loop[0]));
187 if ((-1 != error) || (EISCONN != errno))
188 tst_brkm(TBROK, tst_exit, "connect on an established socket "
189 "error:%d errno:%d", error, errno);
190
191 tst_resm(TPASS, "connect on an established socket");
192
193 /* Try to do accept on an established socket. It should fail. */
194 error = accept(accept_sk[0], &accept_loop.sa, &addrlen);
195 if ((-1 != error) && (EINVAL != errno))
196 tst_brkm(TBROK, tst_exit, "accept on an established socket "
197 "error:%d errno:%d", error, errno);
198
199 error = accept(clt_sk[0], &accept_loop.sa, &addrlen);
200 if ((-1 != error) && (EINVAL != errno))
201 tst_brkm(TBROK, tst_exit, "accept on an established socket "
202 "failure: error:%d errno:%d", error, errno);
203
204 tst_resm(TPASS, "accept on an established socket");
205
206 /* Send and receive a message from the client sockets to the accepted
207 * sockets.
208 */
209 for (i = 0; i < MAX_CLIENTS; i++) {
210 test_send(clt_sk[i], message, strlen(message), 0);
211 test_recv(accept_sk[i], msgbuf, 100, 0);
212 }
213
214 tst_resm(TPASS, "client sockets -> accepted sockets");
215
216 /* Send and receive a message from the accepted sockets to the client
217 * sockets.
218 */
219 for (i = 0; i < MAX_CLIENTS; i++) {
220 test_send(accept_sk[i], message, strlen(message), 0);
221 test_recv(clt_sk[i], msgbuf, 100, 0);
222 }
223
224 tst_resm(TPASS, "accepted sockets -> client sockets");
225
226 /* Sending a message on a listening socket should fail. */
227 error = send(listen_sk, message, strlen(message), MSG_NOSIGNAL);
228 if ((-1 != error) || (EPIPE != errno))
229 tst_brkm(TBROK, tst_exit, "send on a listening socket "
230 "error:%d, errno:%d", error, errno);
231
232 tst_resm(TPASS, "send on a listening socket");
233
234 /* Trying to receive a message on a listening socket should fail. */
235 error = recv(listen_sk, msgbuf, 100, 0);
236 if ((-1 != error) || (ENOTCONN != errno))
237 tst_brkm(TBROK, tst_exit, "recv on a listening socket "
238 "error:%d, errno:%d", error, errno);
239
240 tst_resm(TPASS, "recv on a listening socket");
241
242 /* TESTCASES for shutdown() */
243 errno = 0;
244 test_send(accept_sk[0], message, strlen(message), 0);
245
246 /* Enable ASSOC_CHANGE and SNDRCVINFO notifications. */
247 test_enable_assoc_change(clt_sk[0]);
248
249 /* Do a SHUT_WR on clt_sk[0] to disable any new sends. */
250 test_shutdown(clt_sk[0], SHUT_WR);
251
252 /* Reading on a socket that has received SHUTDOWN should return 0
253 * indicating EOF.
254 */
255 error = recv(accept_sk[0], msgbuf, 100, 0);
256 if ((0 != error) || (0 != errno))
257 tst_brkm(TBROK, tst_exit, "recv on a SHUTDOWN received socket "
258 "error:%d errno:%d", error, errno);
259
260 tst_resm(TPASS, "recv on a SHUTDOWN received socket");
261
262 /* Read the pending message on clt_sk[0] that was received before
263 * SHUTDOWN call.
264 */
265 test_recv(clt_sk[0], msgbuf, 100, 0);
266
267 /* Initialize inmessage for all receives. */
268 big_buffer = test_malloc(REALLY_BIG);
269 memset(&inmessage, 0, sizeof(inmessage));
270 iov.iov_base = big_buffer;
271 iov.iov_len = REALLY_BIG;
272 inmessage.msg_iov = &iov;
273 inmessage.msg_iovlen = 1;
274 inmessage.msg_control = incmsg;
275 inmessage.msg_controllen = sizeof(incmsg);
276
277 /* Receive the SHUTDOWN_COMP notification as they are enabled. */
278 error = test_recvmsg(clt_sk[0], &inmessage, MSG_WAITALL);
279 test_check_msg_notification(&inmessage, error,
280 sizeof(struct sctp_assoc_change),
281 SCTP_ASSOC_CHANGE, SCTP_SHUTDOWN_COMP);
282
283 tst_resm(TPASS, "recv SHUTDOWN_COMP notification on a SHUT_WR socket");
284
285 /* No more messages and the association is SHUTDOWN, should fail. */
286 error = recv(clt_sk[0], msgbuf, 100, 0);
287 if ((-1 != error) || (ENOTCONN != errno))
288 tst_brkm(TBROK, tst_exit, "recv on a SHUTDOWN sent socket "
289 "error:%d, errno:%d", error, errno);
290
291 tst_resm(TPASS, "recv on a SHUTDOWN sent socket");
292
293 errno = 0;
294
295 /* Do a SHUT_RD on clt_sk[1] to disable any new receives. */
296 test_shutdown(clt_sk[1], SHUT_RD);
297
298 error = recv(clt_sk[1], msgbuf, 100, 0);
299 if ((0 != error) || (0 != errno))
300 tst_brkm(TBROK, tst_exit, "recv on a SHUT_RD socket "
301 "error:%d, errno:%d", error, errno);
302
303 /* Sending a message on SHUT_RD socket. */
304 test_send(clt_sk[1], message, strlen(message), 0);
305
306 /* Receive the message sent on SHUT_RD socket. */
307 test_recv(accept_sk[1], msgbuf, 100, 0);
308
309 /* Send a message to the SHUT_RD socket. */
310 test_send(accept_sk[1], message, strlen(message), 0);
311
312 /* We should not receive the message as the socket is SHUT_RD */
313 error = recv(clt_sk[1], msgbuf, 100, 0);
314 if ((0 != error) || (0 != errno))
315 tst_brkm(TBROK, tst_exit, "recv on a SHUT_RD socket "
316 "error:%d, errno:%d", error, errno);
317
318 tst_resm(TPASS, "recv on a SHUT_RD socket");
319
320 /* Do a SHUT_RDWR on clt_sk[2] to disable any new sends/receives. */
321 test_shutdown(clt_sk[2], SHUT_RDWR);
322
323 error = recv(accept_sk[2], msgbuf, 100, 0);
324 if ((0 != error) || (0 != errno))
325 tst_brkm(TBROK, tst_exit, "recv on a SHUT_RDWR socket "
326 "error:%d, errno:%d", error, errno);
327
328 error = recv(clt_sk[2], msgbuf, 100, 0);
329 if ((0 != error) || (0 != errno))
330 tst_brkm(TBROK, tst_exit, "recv on a SHUT_RDWR socket "
331 "error:%d, errno:%d", error, errno);
332
333 tst_resm(TPASS, "recv on a SHUT_RDWR socket");
334
335 error = 0;
336
337 for (i = 0; i < MAX_CLIENTS; i++)
338 close(clt_sk[i]);
339 for (i = 0; i < MAX_CLIENTS; i++)
340 close(accept_sk[i]);
341
342 /* Test case to verify accept of a CLOSED association. */
343 /* Do a connect, send and a close to ESTABLISH and CLOSE an
344 * association on the listening socket.
345 */
346 test_connect(clt2_sk, &svr_loop.sa, sizeof(svr_loop));
347
348 test_send(clt2_sk, message, strlen(message), 0);
349
350 close(clt2_sk);
351
352 FD_ZERO(&set);
353 FD_SET(listen_sk, &set);
354
355 error = select(listen_sk + 1, &set, NULL, NULL, NULL);
356 if (1 != error)
357 tst_brkm(TBROK, tst_exit, "select error:%d, "
358 "errno: %d", error, errno);
359
360 /* Now accept the CLOSED association waiting on the listening
361 * socket.
362 */
363 accept2_sk = test_accept(listen_sk, &accept_loop.sa, &addrlen);
364
365 /* Receive the message sent before doing a close. */
366 test_recv(accept2_sk, msgbuf, 100, 0);
367
368 /* Receive EOF indication as there are no more messages and the
369 * socket is SHUTDOWN.
370 */
371 error = recv(accept2_sk, msgbuf, 100, 0);
372 if ((0 != error) || (0 != errno))
373 tst_brkm(TBROK, tst_exit, "Unexpected error return on "
374 "recv(error:%d, errno:%d)", error, errno);
375
376 tst_resm(TPASS, "accept of a CLOSED association");
377
378 /* Trying to send a message over the CLOSED association should
379 * generate EPIPE.
380 */
381 error = send(accept2_sk, message, strlen(message), MSG_NOSIGNAL);
382 if ((-1 != error) || (EPIPE != errno))
383 tst_brkm(TBROK, tst_exit, "send to a CLOSED association "
384 "error:%d, errno:%d", error, errno);
385
386 tst_resm(TPASS, "send to a CLOSED association");
387
388 error = 0;
389 close(accept2_sk);
390
391 /* Verify that auto-connect can be done on a TCP-style socket using
392 * sendto/sendmsg.
393 */
394 clt2_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);
395 test_bind(clt2_sk, &clt2_loop.sa, sizeof(clt2_loop));
396
397 /* Do a sendto() without a connect() */
398 test_sendto(clt2_sk, message, strlen(message), 0, &svr_loop.sa,
399 sizeof(svr_loop));
400
401 accept2_sk = test_accept(listen_sk, &accept_loop.sa, &addrlen);
402
403 test_recv(accept2_sk, msgbuf, 100, 0);
404
405 tst_resm(TPASS, "auto-connect using sendto");
406
407 outmessage.msg_name = &svr_loop;
408 outmessage.msg_namelen = sizeof(svr_loop);
409 outmessage.msg_iov = NULL;
410 outmessage.msg_iovlen = 0;
411 outmessage.msg_control = outcmsg;
412 outmessage.msg_controllen = sizeof(outcmsg);
413 outmessage.msg_flags = 0;
414
415 cmsg = CMSG_FIRSTHDR(&outmessage);
416 cmsg->cmsg_level = IPPROTO_SCTP;
417 cmsg->cmsg_type = SCTP_SNDRCV;
418 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
419 outmessage.msg_controllen = cmsg->cmsg_len;
420 sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
421 memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo));
422
423 /* Verify that SCTP_EOF cannot be used to shutdown an association
424 * on a TCP-style socket.
425 */
426 sinfo->sinfo_flags |= SCTP_EOF;
427 error = sendmsg(clt2_sk, &outmessage, 0);
428 if ((-1 != error) || (EINVAL != errno))
429 tst_brkm(TBROK, tst_exit, "sendmsg with SCTP_EOF flag "
430 "error:%d, errno:%d", error, errno);
431
432 tst_resm(TPASS, "sendmsg with SCTP_EOF flag");
433
434 /* Verify that SCTP_ABORT cannot be used to abort an association
435 * on a TCP-style socket.
436 */
437 sinfo->sinfo_flags |= SCTP_ABORT;
438 error = sendmsg(clt2_sk, &outmessage, 0);
439 if ((-1 != error) || (EINVAL != errno))
440 tst_brkm(TBROK, tst_exit, "sendmsg with SCTP_ABORT flag "
441 "error:%d, errno:%d", error, errno);
442
443 tst_resm(TPASS, "sendmsg with SCTP_ABORT flag");
444
445 /* Verify that a normal message can be sent using sendmsg. */
446 outmessage.msg_iov = &out_iov;
447 outmessage.msg_iovlen = 1;
448 out_iov.iov_base = message;
449 out_iov.iov_len = strlen(message) + 1;
450 sinfo->sinfo_flags = 0;
451 test_sendmsg(clt2_sk, &outmessage, 0, strlen(message)+1);
452
453 test_recv(accept2_sk, msgbuf, 100, 0);
454
455 tst_resm(TPASS, "sendmsg with no flags");
456
457 close(clt2_sk);
458 close(accept2_sk);
459 close(listen_sk);
460
461 /* Indicate successful completion. */
462 return 0;
463 }
464