Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 1 | /* SCTP kernel Implementation |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 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 negative scenarios for getsockopt () |
| 6 | * setsockopt () call for 1-1 style sockets |
| 7 | * |
| 8 | * setsockopt () Tests: |
| 9 | * ------------------- |
| 10 | * TEST1: setsockopt: Bad socket descriptor |
| 11 | * TEST2: setsockopt: Invalid socket |
| 12 | * TEST3: setsockopt: Invalid level |
| 13 | * TEST4: setsockopt: Invalid option buffer |
| 14 | * TEST5: setsockopt: Invalid option name |
| 15 | * TEST6: getsockopt: Bad socket descriptor |
| 16 | * TEST7: getsockopt: Invalid socket |
| 17 | * TEST8: getsockopt: Invalid option buffer |
| 18 | * TEST9: getsockopt: Invalid option name |
| 19 | * |
| 20 | * TEST10: getsockopt: SCTP_INITMSG |
| 21 | * TEST11: setsockopt: SCTP_INITMSG |
| 22 | * TEST12: setsockopt: SO_LINGER |
| 23 | * TEST13: getsockopt: SO_LINGER |
| 24 | * TEST14: getsockopt: SO_RCVBUF |
| 25 | * TEST15: getsockopt: SCTP_STATUS |
| 26 | * TEST16: setsockopt: SO_RCVBUF |
| 27 | * TEST17: setsockopt: SO_SNDBUF |
| 28 | * TEST18: getsockopt: SO_SNDBUF |
| 29 | * TEST19: getsockopt: SCTP_PRIMARY_ADDR |
| 30 | * TEST20: setsockopt: SCTP_PRIMARY_ADDR |
mridge | 64a341f | 2006-01-03 19:16:46 +0000 | [diff] [blame] | 31 | * TEST21: getsockopt: SCTP_ASSOCINFO |
| 32 | * TEST22: setsockopt: SCTP_ASSOCINFO |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 33 | * |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 34 | * The SCTP implementation is free software; |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 35 | * you can redistribute it and/or modify it under the terms of |
| 36 | * the GNU General Public License as published by |
| 37 | * the Free Software Foundation; either version 2, or (at your option) |
| 38 | * any later version. |
| 39 | * |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 40 | * The SCTP implementation is distributed in the hope that it |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 41 | * will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| 42 | * ************************ |
| 43 | * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| 44 | * See the GNU General Public License for more details. |
| 45 | * |
| 46 | * You should have received a copy of the GNU General Public License |
| 47 | * along with GNU CC; see the file COPYING. If not, write to |
| 48 | * the Free Software Foundation, 59 Temple Place - Suite 330, |
| 49 | * Boston, MA 02111-1307, USA. |
| 50 | * |
| 51 | * Please send any bug reports or fixes you make to the |
| 52 | * email address(es): |
| 53 | * lksctp developers <lksctp-developers@lists.sourceforge.net> |
| 54 | * |
| 55 | * Or submit a bug report through the following website: |
| 56 | * http://www.sf.net/projects/lksctp |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 57 | * |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 58 | * Any bugs reported given to us we will try to fix... any fixes shared will |
| 59 | * be incorporated into the next SCTP release. |
| 60 | * |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 61 | */ |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 62 | |
| 63 | #include <stdio.h> |
| 64 | #include <unistd.h> |
| 65 | #include <fcntl.h> |
| 66 | #include <stdlib.h> |
| 67 | #include <string.h> |
| 68 | #include <sys/types.h> |
| 69 | #include <sys/socket.h> |
robbiew | 4ede73c | 2005-08-02 18:19:34 +0000 | [diff] [blame] | 70 | #include <netinet/in.h> |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 71 | #include <errno.h> |
| 72 | #include <netinet/sctp.h> |
| 73 | #include <sys/uio.h> |
| 74 | #include <sctputil.h> |
| 75 | |
| 76 | char *TCID = __FILE__; |
mridge | 64a341f | 2006-01-03 19:16:46 +0000 | [diff] [blame] | 77 | int TST_TOTAL = 22; |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 78 | int TST_CNT = 0; |
| 79 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 80 | int |
| 81 | main(void) |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 82 | { |
mridge | 64a341f | 2006-01-03 19:16:46 +0000 | [diff] [blame] | 83 | int error; |
| 84 | socklen_t len; |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 85 | int sk, sk1, sk2, acpt_sk, pf_class; |
| 86 | struct sctp_rtoinfo grtinfo; |
| 87 | struct sockaddr_in lstn_addr, conn_addr; |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 88 | struct sctp_initmsg ginmsg; /*get the value for SCTP_INITMSG*/ |
| 89 | struct sctp_initmsg sinmsg; /*set the value for SCTP_INITMSG*/ |
| 90 | struct linger slinger; /*SO_LINGER structure*/ |
| 91 | struct linger glinger; /*SO_LINGER structure*/ |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 92 | struct sockaddr_in addr; |
| 93 | struct sockaddr_in *gaddr; |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 94 | struct sctp_status gstatus; /*SCTP_STATUS option*/ |
| 95 | int rcvbuf_val_get, rcvbuf_val_set; /*get and set var for SO_RCVBUF*/ |
| 96 | int sndbuf_val_get, sndbuf_val_set;/*get and set var for SO_SNDBUF*/ |
| 97 | struct sctp_prim gprimaddr;/*SCTP_PRIMARY_ADDR get*/ |
| 98 | struct sctp_prim sprimaddr;/*SCTP_PRIMARY_ADDR set*/ |
| 99 | struct sctp_assocparams sassocparams; /* SCTP_ASSOCPARAMS set */ |
| 100 | struct sctp_assocparams gassocparams; /* SCTP_ASSOCPARAMS get */ |
Simon Xu | 8c1e85d | 2013-12-16 13:20:28 +0800 | [diff] [blame] | 101 | int fd, err_no = 0; |
| 102 | char filename[21]; |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 103 | |
| 104 | /* Rather than fflush() throughout the code, set stdout to |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 105 | * be unbuffered. |
| 106 | */ |
| 107 | setvbuf(stdout, NULL, _IONBF, 0); |
| 108 | setvbuf(stderr, NULL, _IONBF, 0); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 109 | |
| 110 | pf_class = PF_INET; |
| 111 | |
| 112 | sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); |
| 113 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 114 | /*setsockopt() TEST1: Bad socket descriptor EBADF, Expected error*/ |
| 115 | error = setsockopt(-1, IPPROTO_SCTP, 0, 0, 0); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 116 | if (error != -1 || errno != EBADF) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 117 | tst_brkm(TBROK, tst_exit, "setsockopt with a bad socket " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 118 | "descriptor error:%d, errno:%d", error, errno); |
| 119 | |
| 120 | tst_resm(TPASS, "setsockopt() with a bad socket descriptor - EBADF"); |
| 121 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 122 | /*setsockopt() TEST2: Invalid socket ENOTSOCK, Expected error*/ |
Simon Xu | 8c1e85d | 2013-12-16 13:20:28 +0800 | [diff] [blame] | 123 | strcpy(filename, "/tmp/sctptest.XXXXXX"); |
| 124 | fd = mkstemp(filename); |
| 125 | if (fd == -1) |
| 126 | tst_brkm(TBROK, tst_exit, "Failed to mkstemp %s: %s", |
| 127 | filename, strerror(errno)); |
| 128 | error = setsockopt(fd, IPPROTO_SCTP, 0, 0, 0); |
| 129 | if (error == -1) |
| 130 | err_no = errno; |
| 131 | close(fd); |
| 132 | unlink(filename); |
| 133 | if (error != -1 || err_no != ENOTSOCK) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 134 | tst_brkm(TBROK, tst_exit, "setsockopt with an invalid socket " |
Simon Xu | 8c1e85d | 2013-12-16 13:20:28 +0800 | [diff] [blame] | 135 | "error:%d, errno:%d", error, err_no); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 136 | |
| 137 | tst_resm(TPASS, "setsockopt() with an invalid socket - ENOTSOCK"); |
| 138 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 139 | /*setsockopt() TEST3: Invalid level ENOPROTOOPT, Expected error*/ |
| 140 | error = setsockopt(sk, -1, SCTP_RTOINFO, 0, 0); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 141 | if (error != -1 || errno != ENOPROTOOPT) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 142 | tst_brkm(TBROK, tst_exit, "setsockopt with invalid level " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 143 | "error:%d, errno:%d", error, errno); |
| 144 | |
| 145 | tst_resm(TPASS, "setsockopt() with an invalid level - ENOPROTOOPT"); |
| 146 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 147 | /*setsockopt() TEST4: Invalid option buffer EFAULT, Expected error*/ |
| 148 | error = setsockopt(sk, IPPROTO_SCTP, SCTP_RTOINFO, |
| 149 | (const struct sctp_rtoinfo *)-1, sizeof(struct sctp_rtoinfo)); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 150 | if (error != -1 || errno != EFAULT) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 151 | tst_brkm(TBROK, tst_exit, "setsockopt with invalid option " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 152 | "buffer error:%d, errno:%d", error, errno); |
| 153 | |
| 154 | tst_resm(TPASS, "setsockopt() with invalid option buffer - EFAULT"); |
| 155 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 156 | /*setsockopt() TEST5: Invalid option Name EOPNOTSUPP, Expected error*/ |
| 157 | error = setsockopt(sk, IPPROTO_SCTP, SCTP_AUTOCLOSE, 0, 0); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 158 | if (error != -1 || errno != EOPNOTSUPP) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 159 | tst_brkm(TBROK, tst_exit, "setsockopt with invalid option " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 160 | "name error:%d, errno:%d", error, errno); |
| 161 | |
| 162 | tst_resm(TPASS, "setsockopt() with invalid option name - EOPNOTSUPP"); |
| 163 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 164 | /*getsockopt() TEST6: Bad socket descriptor EBADF, Expected error*/ |
| 165 | error = getsockopt(-1, IPPROTO_SCTP, 0, 0, 0); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 166 | if (error != -1 || errno != EBADF) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 167 | tst_brkm(TBROK, tst_exit, "getsockopt with a bad socket " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 168 | "descriptor error:%d, errno:%d", error, errno); |
| 169 | |
| 170 | tst_resm(TPASS, "getsockopt() with a bad socket descriptor - EBADF"); |
| 171 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 172 | /*getsockopt() TEST7: Invalid socket ENOTSOCK, Expected error*/ |
Simon Xu | 8c1e85d | 2013-12-16 13:20:28 +0800 | [diff] [blame] | 173 | strcpy(filename, "/tmp/sctptest.XXXXXX"); |
| 174 | fd = mkstemp(filename); |
| 175 | if (fd == -1) |
| 176 | tst_brkm(TBROK, tst_exit, "Failed to mkstemp %s: %s", |
| 177 | filename, strerror(errno)); |
| 178 | error = getsockopt(fd, IPPROTO_SCTP, 0, 0, 0); |
| 179 | if (error == -1) |
| 180 | err_no = errno; |
| 181 | close(fd); |
| 182 | unlink(filename); |
| 183 | if (error != -1 || err_no != ENOTSOCK) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 184 | tst_brkm(TBROK, tst_exit, "getsockopt with an invalid socket " |
Simon Xu | 8c1e85d | 2013-12-16 13:20:28 +0800 | [diff] [blame] | 185 | "error:%d, errno:%d", error, err_no); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 186 | |
| 187 | tst_resm(TPASS, "getsockopt() with an invalid socket - ENOTSOCK"); |
| 188 | #if 0 |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 189 | /*getsockopt() TEST3: Invalid level ENOPROTOOPT, Expected error*/ |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 190 | /*I have commented this test case because it is returning EOPNOTSUPP. |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 191 | When I checked the code there also it is returning EOPNOTSUPP. As this |
| 192 | is not specific to TCP style, I do not want to do the code change*/ |
| 193 | |
| 194 | error = getsockopt(sk, -1, SCTP_RTOINFO, 0, 0); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 195 | if (error != -1 || errno != ENOPROTOOPT) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 196 | tst_brkm(TBROK, tst_exit, "getsockopt with invalid level " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 197 | "error:%d, errno:%d", error, errno); |
| 198 | |
| 199 | tst_resm(TPASS, "getsockopt() with an invalid level - ENOPROTOOPT"); |
| 200 | #endif |
| 201 | len = sizeof(struct sctp_rtoinfo); |
| 202 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 203 | /*getsockopt() TEST8: Invalid option buffer EFAULT, Expected error*/ |
| 204 | error = getsockopt(sk, IPPROTO_SCTP, SCTP_RTOINFO, |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 205 | (struct sctp_rtoinfo *)-1, &len); |
| 206 | if (error != -1 || errno != EFAULT) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 207 | tst_brkm(TBROK, tst_exit, "getsockopt with invalid option " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 208 | "buffer error:%d, errno:%d", error, errno); |
| 209 | |
| 210 | tst_resm(TPASS, "getsockopt() with invalid option buffer - EFAULT"); |
| 211 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 212 | /*getsockopt() TEST9: Invalid option Name EOPNOTSUPP, Expected error*/ |
| 213 | error = getsockopt(sk, IPPROTO_SCTP, SCTP_AUTOCLOSE, &grtinfo, &len); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 214 | if (error != -1 || errno != EOPNOTSUPP) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 215 | tst_brkm(TBROK, tst_exit, "getsockopt with invalid option " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 216 | "name error:%d, errno:%d", error, errno); |
| 217 | |
| 218 | tst_resm(TPASS, "getsockopt() with invalid option name - EOPNOTSUPP"); |
| 219 | |
| 220 | close(sk); |
| 221 | |
| 222 | sk1 = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); |
| 223 | sk2 = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); |
| 224 | |
| 225 | lstn_addr.sin_family = AF_INET; |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 226 | lstn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; |
| 227 | lstn_addr.sin_port = htons(SCTP_TESTPORT_1); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 228 | |
| 229 | conn_addr.sin_family = AF_INET; |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 230 | conn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; |
| 231 | conn_addr.sin_port = htons(SCTP_TESTPORT_1); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 232 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 233 | len = sizeof(struct sctp_initmsg); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 234 | |
| 235 | /* TEST10: Test cases for getsockopt SCTP_INITMSG */ |
| 236 | test_getsockopt(sk1, SCTP_INITMSG, &ginmsg, &len); |
| 237 | |
| 238 | tst_resm(TPASS, "getsockopt() SCTP_INITMSG - SUCCESS"); |
| 239 | |
| 240 | sinmsg.sinit_num_ostreams = 5; |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 241 | sinmsg.sinit_max_instreams = 5; |
| 242 | sinmsg.sinit_max_attempts = 3; |
| 243 | sinmsg.sinit_max_init_timeo = 30; |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 244 | /* TEST11: Test case for setsockopt SCTP_INITMSG */ |
| 245 | test_setsockopt(sk1, SCTP_INITMSG, &sinmsg, sizeof(sinmsg)); |
| 246 | |
| 247 | test_getsockopt(sk1, SCTP_INITMSG, &ginmsg, &len); |
| 248 | |
| 249 | if (sinmsg.sinit_num_ostreams != ginmsg.sinit_num_ostreams && |
| 250 | sinmsg.sinit_max_instreams != ginmsg.sinit_max_instreams && |
| 251 | sinmsg.sinit_max_attempts != ginmsg.sinit_max_attempts && |
| 252 | sinmsg.sinit_max_init_timeo != ginmsg.sinit_max_init_timeo) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 253 | tst_brkm(TBROK, tst_exit, "setsockopt/getsockopt SCTP_INITMSG " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 254 | "compare failed"); |
| 255 | |
| 256 | tst_resm(TPASS, "setsockopt() SCTP_INITMSG - SUCCESS"); |
| 257 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 258 | /*Now get the values on different endpoint*/ |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 259 | test_getsockopt(sk2, SCTP_INITMSG, &ginmsg, &len); |
| 260 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 261 | /*Comparison should not succeed here*/ |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 262 | if (sinmsg.sinit_num_ostreams == ginmsg.sinit_num_ostreams && |
| 263 | sinmsg.sinit_max_instreams == ginmsg.sinit_max_instreams && |
| 264 | sinmsg.sinit_max_attempts == ginmsg.sinit_max_attempts && |
| 265 | sinmsg.sinit_max_init_timeo == ginmsg.sinit_max_init_timeo) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 266 | tst_brkm(TBROK, tst_exit, "setsockopt/getsockopt SCTP_INITMSG " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 267 | "unexpected compare success"); |
| 268 | |
| 269 | /* SO_LINGER Test with l_onff = 0 and l_linger = 0 */ |
| 270 | slinger.l_onoff = 0; |
| 271 | slinger.l_linger = 0; |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 272 | test_bind(sk1, (struct sockaddr *) &lstn_addr, sizeof(lstn_addr)); |
| 273 | test_listen(sk1, 10 ); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 274 | len = sizeof(struct sockaddr_in); |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 275 | test_connect(sk2, (struct sockaddr *) &conn_addr, len); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 276 | |
| 277 | acpt_sk = test_accept(sk1, (struct sockaddr *)&addr, &len); |
| 278 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 279 | len = sizeof(struct linger); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 280 | /* TEST12: Test case for setsockopt SO_LINGER */ |
| 281 | error = setsockopt(sk2, SOL_SOCKET, SO_LINGER, &slinger, len); |
| 282 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 283 | tst_brkm(TBROK, tst_exit, "setsockopt SO_LINGER " |
| 284 | "error:%d, errno:%d", error, errno); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 285 | |
| 286 | tst_resm(TPASS, "setsockopt() SO_LINGER - SUCCESS"); |
| 287 | |
| 288 | /* TEST13: Test case for getsockopt SO_LINGER */ |
| 289 | error = getsockopt(sk2, SOL_SOCKET, SO_LINGER, &glinger, &len); |
| 290 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 291 | tst_brkm(TBROK, tst_exit, "getsockopt SO_LINGER " |
| 292 | "error:%d, errno:%d", error, errno); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 293 | |
| 294 | tst_resm(TPASS, "getsockopt() SO_LINGER - SUCCESS"); |
| 295 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 296 | if (slinger.l_onoff != glinger.l_onoff || |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 297 | slinger.l_linger != glinger.l_linger) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 298 | tst_brkm(TBROK, tst_exit, "setsockopt/getsockopt SO_LINGER " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 299 | "compare failed"); |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 300 | |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 301 | /*First gets the default SO_RCVBUF value and comapres with the |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 302 | value obtained from SCTP_STATUS*/ |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 303 | len = sizeof(int); |
| 304 | /* TEST14: Test case for getsockopt SO_RCVBUF */ |
| 305 | error = getsockopt(sk2, SOL_SOCKET, SO_RCVBUF, &rcvbuf_val_get, &len); |
| 306 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 307 | tst_brkm(TBROK, tst_exit, "getsockopt SO_RCVBUF " |
| 308 | "error:%d, errno:%d", error, errno); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 309 | |
| 310 | tst_resm(TPASS, "getsockopt() SO_RCVBUF - SUCCESS"); |
| 311 | |
| 312 | len = sizeof(struct sctp_status); |
| 313 | /* TEST15: Test case for getsockopt SCTP_STATUS */ |
| 314 | error = getsockopt(sk2, IPPROTO_SCTP, SCTP_STATUS, &gstatus, &len); |
| 315 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 316 | tst_brkm(TBROK, tst_exit, "getsockopt SCTP_STATUS " |
| 317 | "error:%d, errno:%d", error, errno); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 318 | |
| 319 | tst_resm(TPASS, "getsockopt() SCTP_STATUS - SUCCESS"); |
| 320 | |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 321 | /* Reducing the SO_RCVBUF value using setsockopt() */ |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 322 | /* Upstream has changed the MIN_RCVBUF (2048 + sizeof(struct sk_buff)) */ |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 323 | len = sizeof(int); |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 324 | rcvbuf_val_set = 2048; |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 325 | /* TEST16: Test case for setsockopt SO_RCVBUF */ |
| 326 | error = setsockopt(sk2, SOL_SOCKET, SO_RCVBUF, &rcvbuf_val_set, len); |
| 327 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 328 | tst_brkm(TBROK, tst_exit, "setsockopt SO_RCVBUF " |
| 329 | "error:%d, errno:%d", error, errno); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 330 | |
| 331 | tst_resm(TPASS, "setsockopt() SO_RCVBUF - SUCCESS"); |
| 332 | |
| 333 | error = getsockopt(sk2, SOL_SOCKET, SO_RCVBUF, &rcvbuf_val_get, &len); |
| 334 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 335 | tst_brkm(TBROK, tst_exit, "getsockopt SO_RCVBUF " |
| 336 | "error:%d, errno:%d", error, errno); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 337 | |
| 338 | if ((2 * rcvbuf_val_set) != rcvbuf_val_get) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 339 | tst_brkm(TBROK, tst_exit, "Comparison failed:Set value and " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 340 | "got value differs Set Value=%d Get Value=%d", |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 341 | (2*rcvbuf_val_set), rcvbuf_val_get); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 342 | |
Alexey Kodanev | d7ef041 | 2015-03-10 13:46:56 +0300 | [diff] [blame] | 343 | sndbuf_val_set = 5000; |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 344 | /* TEST17: Test case for setsockopt SO_SNDBUF */ |
| 345 | error = setsockopt(sk2, SOL_SOCKET, SO_SNDBUF, &sndbuf_val_set, len); |
| 346 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 347 | tst_brkm(TBROK, tst_exit, "setsockopt SO_SNDBUF " |
| 348 | "error:%d, errno:%d", error, errno); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 349 | |
| 350 | tst_resm(TPASS, "setsockopt() SO_SNDBUF - SUCCESS"); |
| 351 | |
| 352 | /* TEST18: Test case for getsockopt SO_SNDBUF */ |
| 353 | error = getsockopt(sk2, SOL_SOCKET, SO_SNDBUF, &sndbuf_val_get, &len); |
| 354 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 355 | tst_brkm(TBROK, tst_exit, "getsockopt SO_SNDBUF " |
| 356 | "error:%d, errno:%d", error, errno); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 357 | |
| 358 | tst_resm(TPASS, "getsockopt() SO_SNDBUF - SUCCESS"); |
| 359 | |
| 360 | if ((2 * sndbuf_val_set) != sndbuf_val_get) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 361 | tst_brkm(TBROK, tst_exit, "Comparison failed:Set value and " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 362 | "got value differs Set Value=%d Get Value=%d\n", |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 363 | (2*sndbuf_val_set), sndbuf_val_get); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 364 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 365 | |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 366 | /* Getting the primary address using SCTP_PRIMARY_ADDR */ |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 367 | len = sizeof(struct sctp_prim); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 368 | /* TEST19: Test case for getsockopt SCTP_PRIMARY_ADDR */ |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 369 | error = getsockopt(sk2,IPPROTO_SCTP, SCTP_PRIMARY_ADDR, &gprimaddr, |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 370 | &len); |
| 371 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 372 | tst_brkm(TBROK, tst_exit, "getsockopt SCTP_PRIMARY_ADDR " |
| 373 | "error:%d, errno:%d", error, errno); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 374 | |
| 375 | tst_resm(TPASS, "getsockopt() SCTP_PRIMARY_ADDR - SUCCESS"); |
| 376 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 377 | gaddr = (struct sockaddr_in *) &gprimaddr.ssp_addr; |
| 378 | if(htons(gaddr->sin_port) != lstn_addr.sin_port && |
| 379 | gaddr->sin_family != lstn_addr.sin_family && |
| 380 | gaddr->sin_addr.s_addr != lstn_addr.sin_addr.s_addr) |
| 381 | tst_brkm(TBROK, tst_exit, "getsockopt SCTP_PRIMARY_ADDR value " |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 382 | "mismatch"); |
| 383 | |
| 384 | memcpy(&sprimaddr, &gprimaddr, sizeof(struct sctp_prim)); |
| 385 | |
| 386 | /* TEST20: Test case for setsockopt SCTP_PRIMARY_ADDR */ |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 387 | error = setsockopt(sk2,IPPROTO_SCTP, SCTP_PRIMARY_ADDR, &sprimaddr, |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 388 | len); |
| 389 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 390 | tst_brkm(TBROK, tst_exit, "setsockopt SCTP_PRIMARY_ADDR " |
| 391 | "error:%d, errno:%d", error, errno); |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 392 | |
| 393 | tst_resm(TPASS, "setsockopt() SCTP_PRIMARY_ADDR - SUCCESS"); |
| 394 | |
mridge | 64a341f | 2006-01-03 19:16:46 +0000 | [diff] [blame] | 395 | /* TEST21: Test case for getsockopt SCTP_PRIMARY_ADDR */ |
| 396 | /* Getting the association info using SCTP_ASSOCINFO */ |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 397 | len = sizeof(struct sctp_assocparams); |
mridge | 64a341f | 2006-01-03 19:16:46 +0000 | [diff] [blame] | 398 | error = getsockopt(sk2, IPPROTO_SCTP, SCTP_ASSOCINFO, &gassocparams, |
| 399 | &len); |
| 400 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 401 | tst_brkm(TBROK, tst_exit, "getsockopt SCTP_ASSOCINFO " |
| 402 | "error:%d, errno:%d", error, errno); |
mridge | 64a341f | 2006-01-03 19:16:46 +0000 | [diff] [blame] | 403 | |
| 404 | tst_resm(TPASS, "getsockopt() SCTP_ASSOCINFO - SUCCESS"); |
| 405 | |
| 406 | /* TEST21: Test case for setsockopt SCTP_ASSOCINFO */ |
| 407 | memcpy(&sassocparams, &gassocparams, sizeof(struct sctp_assocparams)); |
| 408 | sassocparams.sasoc_asocmaxrxt += 5; |
| 409 | sassocparams.sasoc_cookie_life += 10; |
| 410 | |
| 411 | error = setsockopt(sk2, IPPROTO_SCTP, SCTP_ASSOCINFO, &sassocparams, |
| 412 | len); |
| 413 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 414 | tst_brkm(TBROK, tst_exit, "setsockopt SCTP_ASSOCINFO " |
| 415 | "error:%d, errno:%d", error, errno); |
mridge | 64a341f | 2006-01-03 19:16:46 +0000 | [diff] [blame] | 416 | |
| 417 | error = getsockopt(sk2, IPPROTO_SCTP, SCTP_ASSOCINFO, &gassocparams, |
| 418 | &len); |
| 419 | if (error < 0) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 420 | tst_brkm(TBROK, tst_exit, "getsockopt SCTP_ASSOCINFO " |
| 421 | "error:%d, errno:%d", error, errno); |
mridge | 64a341f | 2006-01-03 19:16:46 +0000 | [diff] [blame] | 422 | |
| 423 | if (sassocparams.sasoc_asocmaxrxt != gassocparams.sasoc_asocmaxrxt || |
| 424 | sassocparams.sasoc_cookie_life != gassocparams.sasoc_cookie_life) |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 425 | tst_brkm(TBROK, tst_exit, "getsockopt SCTP_ASSOCINFO value " |
mridge | 64a341f | 2006-01-03 19:16:46 +0000 | [diff] [blame] | 426 | "mismatch"); |
| 427 | tst_resm(TPASS, "setsockopt() SCTP_ASSOCINFO - SUCCESS"); |
| 428 | |
mridge | 5ba96af | 2004-02-23 16:17:34 +0000 | [diff] [blame] | 429 | close(sk2); |
| 430 | close(sk1); |
| 431 | close(acpt_sk); |
| 432 | |
Simon Xu | 6f22494 | 2013-12-06 11:51:16 +0800 | [diff] [blame] | 433 | return 0; |
Chris Dearman | ec6edca | 2012-10-17 19:54:01 -0700 | [diff] [blame] | 434 | } |