Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 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@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))]; |
Simon Xu | 8c1e85d | 2013-12-16 13:20:28 +0800 | [diff] [blame] | 89 | int fd, err_no = 0; |
| 90 | char filename[21]; |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 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*/ |
Simon Xu | 8c1e85d | 2013-12-16 13:20:28 +0800 | [diff] [blame] | 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) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 167 | tst_brkm(TBROK, tst_exit, "sendmsg with invalid socket " |
Simon Xu | 8c1e85d | 2013-12-16 13:20:28 +0800 | [diff] [blame] | 168 | "count:%d, errno:%d", count, err_no); |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 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 | } |