1 /* SCTP kernel Implementation 2 * Copyright (c) 2003 Hewlett-Packard Development Company, L.P 3 * (C) Copyright IBM Corp. 2004 4 * 5 * This file has test cases to test the sendmsg() call for 1-1 style sockets 6 * 7 * TEST1: Bad socket descriptor 8 * TEST2: Invalid socket 9 * TEST3: On a listening socket 10 * TEST4: Invalid iovec pointer 11 * TEST5: Invalid iovec length 12 * TEST6: Invalid msghdr pointer 13 * TEST7: Invalid sinfo flags 14 * TEST8: SCTP_EOF flag set 15 * TEST9: SCTP_ABORT flag set 16 * TEST10: On a closed association 17 * 18 * TEST11: Sending data from server socket to client socket 19 * TEST12: Sending data from client socket to server socket 20 * TEST13: Sending data from unconnected client to server 21 * TEST14: Sending a message on SHUT_RD socket 22 * 23 * The SCTP implementation is free software; 24 * you can redistribute it and/or modify it under the terms of 25 * the GNU General Public License as published by 26 * the Free Software Foundation; either version 2, or (at your option) 27 * any later version. 28 * 29 * The SCTP implementation is distributed in the hope that it 30 * will be useful, but WITHOUT ANY WARRANTY; without even the implied 31 * ************************ 32 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 33 * See the GNU General Public License for more details. 34 * 35 * You should have received a copy of the GNU General Public License 36 * along with GNU CC; see the file COPYING. If not, write to 37 * the Free Software Foundation, 59 Temple Place - Suite 330, 38 * Boston, MA 02111-1307, USA. 39 * 40 * Please send any bug reports or fixes you make to the 41 * email address(es): 42 * lksctp developers <lksctp-developers (at) lists.sourceforge.net> 43 * 44 * Or submit a bug report through the following website: 45 * http://www.sf.net/projects/lksctp 46 * 47 * Any bugs reported given to us we will try to fix... any fixes shared will 48 * be incorporated into the next SCTP release 49 * 50 */ 51 52 #include <stdio.h> 53 #include <unistd.h> 54 #include <fcntl.h> 55 #include <stdlib.h> 56 #include <string.h> 57 #include <sys/types.h> 58 #include <sys/socket.h> 59 #include <netinet/in.h> /* for sockaddr_in */ 60 #include <arpa/inet.h> 61 #include <errno.h> 62 #include <netinet/sctp.h> 63 #include <sys/uio.h> 64 #include <linux/socket.h> 65 #include <sctputil.h> 66 67 char *TCID = __FILE__; 68 int TST_TOTAL = 14; 69 int TST_CNT = 0; 70 71 int 72 main(int argc, char *argv[]) 73 { 74 socklen_t len; 75 int msg_count; 76 int sk,sk1,pf_class,lstn_sk,acpt_sk,acpt1_sk, flag; 77 struct msghdr outmessage; 78 char *message = "hello, world!\n"; 79 struct sctp_sndrcvinfo *sinfo; 80 int count; 81 char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))]; 82 struct cmsghdr *cmsg; 83 struct iovec out_iov; 84 struct msghdr inmessage; 85 char * buffer_rcv; 86 struct sockaddr_in conn_addr,lstn_addr,svr_addr; 87 struct iovec iov_rcv; 88 char incmsg[CMSG_SPACE(sizeof(sctp_cmsg_data_t))]; 89 int fd, err_no = 0; 90 char filename[21]; 91 92 /* Rather than fflush() throughout the code, set stdout to 93 * be unbuffered. 94 */ 95 setvbuf(stdout, NULL, _IONBF, 0); 96 setvbuf(stderr, NULL, _IONBF, 0); 97 98 pf_class = PF_INET; 99 100 sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); 101 102 sk1 = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); 103 104 lstn_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); 105 106 conn_addr.sin_family = AF_INET; 107 conn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; 108 conn_addr.sin_port = htons(SCTP_TESTPORT_1); 109 110 lstn_addr.sin_family = AF_INET; 111 lstn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; 112 lstn_addr.sin_port = htons(SCTP_TESTPORT_1); 113 114 /*Binding the listen socket*/ 115 test_bind(lstn_sk, (struct sockaddr *) &lstn_addr, sizeof(lstn_addr)); 116 117 /*Listening the socket*/ 118 test_listen(lstn_sk, 10); 119 120 len = sizeof(struct sockaddr_in); 121 122 test_connect(sk, (struct sockaddr *) &conn_addr, len); 123 124 acpt_sk = test_accept(lstn_sk, (struct sockaddr *)&svr_addr, &len); 125 126 memset(&outmessage, 0, sizeof(outmessage)); 127 outmessage.msg_name = &conn_addr; 128 outmessage.msg_namelen = sizeof(conn_addr); 129 outmessage.msg_iov = &out_iov; 130 outmessage.msg_iovlen = 1; 131 outmessage.msg_control = outcmsg; 132 outmessage.msg_controllen = sizeof(outcmsg); 133 outmessage.msg_flags = 0; 134 135 cmsg = CMSG_FIRSTHDR(&outmessage); 136 cmsg->cmsg_level = IPPROTO_SCTP; 137 cmsg->cmsg_type = SCTP_SNDRCV; 138 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo)); 139 outmessage.msg_controllen = cmsg->cmsg_len; 140 sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg); 141 memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo)); 142 143 outmessage.msg_iov->iov_base = message; 144 outmessage.msg_iov->iov_len = strlen(message) + 1; 145 146 flag = MSG_NOSIGNAL; 147 /*sendmsg () TEST1: Bad socket descriptor, EBADF Expected error*/ 148 count = sendmsg(-1, &outmessage, flag); 149 if (count != -1 || errno != EBADF) 150 tst_brkm(TBROK, tst_exit, "sendmsg with a bad socket " 151 "descriptor count:%d, errno:%d", count, errno); 152 153 tst_resm(TPASS, "sendmsg() with a bad socket descriptor - EBADF"); 154 155 /*sendmsg () TEST2: Invalid socket, ENOTSOCK Expected error*/ 156 strcpy(filename, "/tmp/sctptest.XXXXXX"); 157 fd = mkstemp(filename); 158 if (fd == -1) 159 tst_brkm(TBROK, tst_exit, "Failed to mkstemp %s: %s", 160 filename, strerror(errno)); 161 count = sendmsg(fd, &outmessage, flag); 162 if (count == -1) 163 err_no = errno; 164 close(fd); 165 unlink(filename); 166 if (count != -1 || err_no != ENOTSOCK) 167 tst_brkm(TBROK, tst_exit, "sendmsg with invalid socket " 168 "count:%d, errno:%d", count, err_no); 169 170 tst_resm(TPASS, "sendmsg() with invalid socket - ENOTSOCK"); 171 172 /*sendmsg () TEST3: sendmsg on listening socket, EPIPE Expected error*/ 173 count = sendmsg(lstn_sk, &outmessage, flag); 174 if (count != -1 || errno != EPIPE) 175 tst_brkm(TBROK, tst_exit, "sendmsg on a listening socket " 176 "count:%d, errno:%d", count, errno); 177 178 tst_resm(TPASS, "sendmsg() on a listening socket - EPIPE"); 179 180 /*sendmsg () TEST4: Invalid iovec pointer EFAULT, Expected error*/ 181 outmessage.msg_iov = (struct iovec *)-1; 182 count = sendmsg(sk, &outmessage, flag); 183 if (count != -1 || errno != EFAULT) 184 tst_brkm(TBROK, tst_exit, "sendmsg with invalid iovec " 185 "pointer count:%d, errno:%d", count, errno); 186 187 tst_resm(TPASS, "sendmsg() with invalid iovec ptr - EFAULT"); 188 189 outmessage.msg_iov = &out_iov; 190 191 /*sendmsg () TEST5: Invalid iovec count EINVAL, Expected error*/ 192 outmessage.msg_iovlen = 0; 193 count = sendmsg(sk, &outmessage, flag); 194 if (count != -1 || errno != EINVAL) 195 tst_brkm(TBROK, tst_exit, "sendmsg with invalid iovec " 196 "length count:%d, errno:%d", count, errno); 197 198 tst_resm(TPASS, "sendmsg() with invalid iovec length - EINVAL"); 199 200 outmessage.msg_iovlen = 1; 201 202 /*sendmsg () TEST6: Invalid msghdr pointer EFAULT, Expected error*/ 203 count = sendmsg(sk, (struct msghdr *)-1, flag); 204 if (count != -1 || errno != EFAULT) 205 tst_brkm(TBROK, tst_exit, "sendmsg with invalid msghdr " 206 "pointer count:%d, errno:%d", count, errno); 207 208 tst_resm(TPASS, "sendmsg() with invalid msghdr ptr - EFAULT"); 209 210 /*sendmsg () TEST7: Invalid sinfo flag EINVAL, Expected error*/ 211 sinfo->sinfo_flags = 999; 212 count = sendmsg(sk, &outmessage, -1); 213 if (count != -1 || errno != EINVAL) 214 tst_brkm(TBROK, tst_exit, "sendmsg with invalid sinfo " 215 "flags count:%d, errno:%d", count, errno); 216 217 tst_resm(TPASS, "sendmsg() with invalid sinfo flags - EINVAL"); 218 219 /*sendmsg () TEST8: SCTP_EOF flag EINVAL, Expected error*/ 220 sinfo->sinfo_flags = SCTP_EOF; 221 count = sendmsg(sk, &outmessage, flag); 222 if (count != -1 || errno != EINVAL) 223 tst_brkm(TBROK, tst_exit, "sendmsg with SCTP_EOF flag " 224 "count:%d, errno:%d", count, errno); 225 226 tst_resm(TPASS, "sendmsg() with SCTP_EOF flag - EINVAL"); 227 228 /*sendmsg () TEST9: SCTP_ABORT flag EINVAL, Expected error*/ 229 sinfo->sinfo_flags = SCTP_ABORT; 230 count = sendmsg(sk, &outmessage, flag); 231 if (count != -1 || errno != EINVAL) 232 tst_brkm(TBROK, tst_exit, "sendmsg with SCTP_ABORT flag " 233 "count:%d, errno:%d", count, errno); 234 235 tst_resm(TPASS, "sendmsg() with SCTP_ABORT flag - EINVAL"); 236 237 sinfo->sinfo_flags = 0; 238 239 test_connect(sk1, (struct sockaddr *) &lstn_addr, len); 240 241 test_sendmsg(sk1, &outmessage, flag, strlen(message)+1); 242 243 close(sk1); 244 acpt1_sk = test_accept(lstn_sk, (struct sockaddr *)&conn_addr, &len); 245 246 /*sendmsg () TEST10:sendmsg on closed association, EPIPE Expected error*/ 247 count = sendmsg(acpt1_sk, &outmessage, flag); 248 if (count != -1 || errno != EPIPE) 249 tst_brkm(TBROK, tst_exit, "sendmsg on a closed association " 250 "count:%d, errno:%d", count, errno); 251 252 tst_resm(TPASS, "sendmsg() on a closed association - EPIPE"); 253 254 close(acpt1_sk); 255 close(sk); 256 close(lstn_sk); 257 close(acpt_sk); 258 259 sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); 260 261 lstn_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); 262 263 conn_addr.sin_family = AF_INET; 264 conn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; 265 conn_addr.sin_port = htons(SCTP_TESTPORT_1); 266 267 lstn_addr.sin_family = AF_INET; 268 lstn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; 269 lstn_addr.sin_port = htons(SCTP_TESTPORT_1); 270 271 /*Binding the listen socket*/ 272 test_bind(lstn_sk, (struct sockaddr *) &lstn_addr, sizeof(lstn_addr)); 273 274 /*Listening the socket*/ 275 test_listen(lstn_sk, 10); 276 277 len = sizeof(struct sockaddr_in); 278 flag = MSG_NOSIGNAL; 279 280 test_connect(sk, (struct sockaddr *) &conn_addr, len); 281 282 acpt_sk = test_accept(lstn_sk, (struct sockaddr *)&svr_addr, &len); 283 284 memset(&outmessage, 0, sizeof(outmessage)); 285 outmessage.msg_name = &svr_addr; 286 outmessage.msg_namelen = sizeof(svr_addr); 287 outmessage.msg_iov = &out_iov; 288 outmessage.msg_iovlen = 1; 289 outmessage.msg_control = outcmsg; 290 outmessage.msg_controllen = sizeof(outcmsg); 291 outmessage.msg_flags = 0; 292 293 cmsg = CMSG_FIRSTHDR(&outmessage); 294 cmsg->cmsg_level = IPPROTO_SCTP; 295 cmsg->cmsg_type = SCTP_SNDRCV; 296 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo)); 297 outmessage.msg_controllen = cmsg->cmsg_len; 298 sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg); 299 memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo)); 300 301 outmessage.msg_iov->iov_base = message; 302 outmessage.msg_iov->iov_len = strlen(message) + 1; 303 304 memset(&inmessage, 0, sizeof(inmessage)); 305 buffer_rcv = malloc(REALLY_BIG); 306 307 iov_rcv.iov_base = buffer_rcv; 308 iov_rcv.iov_len = REALLY_BIG; 309 inmessage.msg_iov = &iov_rcv; 310 inmessage.msg_iovlen = 1; 311 inmessage.msg_control = incmsg; 312 inmessage.msg_controllen = sizeof(incmsg); 313 314 msg_count = strlen(message) + 1; 315 316 /*sendmsg() TEST11: Sending data from server socket to client socket*/ 317 count = sendmsg(acpt_sk, &outmessage, flag); 318 if (count != msg_count) 319 tst_brkm(TBROK, tst_exit, "sendmsg from accept socket to " 320 "client count:%d, errno:%d", count, errno); 321 322 tst_resm(TPASS, "sendmsg() from accept socket to client - SUCCESS"); 323 324 count = test_recvmsg(sk, &inmessage, flag); 325 test_check_msg_data(&inmessage, count, msg_count, MSG_EOR, 0, 0); 326 327 outmessage.msg_name = &conn_addr; 328 outmessage.msg_namelen = sizeof(conn_addr); 329 /*sendmsg() TEST12: Sending data from client socket to server socket*/ 330 count = sendmsg(sk, &outmessage, flag); 331 if (count != msg_count) 332 tst_brkm(TBROK, tst_exit, "sendmsg from client to server " 333 "count:%d, errno:%d", count, errno); 334 335 tst_resm(TPASS, "sendmsg() from client to server - SUCCESS"); 336 337 count = test_recvmsg(acpt_sk, &inmessage, flag); 338 test_check_msg_data(&inmessage, count, msg_count, MSG_EOR, 0, 0); 339 340 outmessage.msg_name = &conn_addr; 341 outmessage.msg_namelen = sizeof(conn_addr); 342 close(sk); 343 close(acpt_sk); 344 sk1 = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); 345 346 /*sendmsg() TEST13: Sending data from unconnected client socket to 347 server socket*/ 348 count = sendmsg(sk1, &outmessage, flag); 349 if (count != msg_count) 350 tst_brkm(TBROK, tst_exit, "sendmsg from unconnected client to " 351 "server count:%d, errno:%d", count, errno); 352 353 tst_resm(TPASS, "sendmsg() from unconnected clt to server - SUCCESS"); 354 355 acpt_sk = test_accept(lstn_sk, (struct sockaddr *)&svr_addr, &len); 356 357 count = test_recvmsg(acpt_sk, &inmessage, flag); 358 test_check_msg_data(&inmessage, count, msg_count, MSG_EOR, 0, 0); 359 360 test_shutdown(sk1, SHUT_RD); 361 362 /*sendmsg() TEST14: Sending a message on SHUT_RD socket*/ 363 count = sendmsg(sk1, &outmessage, flag); 364 if (count != msg_count) 365 tst_brkm(TBROK, tst_exit, "sendmsg on a SHUT_RD socket " 366 "count:%d, errno:%d", count, errno); 367 368 tst_resm(TPASS, "sendmsg() on a SHUT_RD socket - SUCCESS"); 369 370 count = test_recvmsg(acpt_sk, &inmessage, flag); 371 test_check_msg_data(&inmessage, count, msg_count, MSG_EOR, 0, 0); 372 373 close(sk1); 374 close(lstn_sk); 375 close(acpt_sk); 376 return 0; 377 } 378
