1 /* SCTP kernel Implementation 2 * (C) Copyright IBM Corp. 2001, 2003 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 * Copyright (c) 2001 La Monte H.P. Yarroll 8 * 9 * The SCTP implementation is free software; 10 * you can redistribute it and/or modify it under the terms of 11 * the GNU General Public License as published by 12 * the Free Software Foundation; either version 2, or (at your option) 13 * any later version. 14 * 15 * The SCTP implementation is distributed in the hope that it 16 * will be useful, but WITHOUT ANY WARRANTY; without even the implied 17 * ************************ 18 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 19 * See the GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with GNU CC; see the file COPYING. If not, write to 23 * the Free Software Foundation, 59 Temple Place - Suite 330, 24 * Boston, MA 02111-1307, USA. 25 * 26 * Please send any bug reports or fixes you make to the 27 * email address(es): 28 * lksctp developers <lksctp-developers (at) lists.sourceforge.net> 29 * 30 * Or submit a bug report through the following website: 31 * http://www.sf.net/projects/lksctp 32 * 33 * Any bugs reported to us we will try to fix... any fixes shared will 34 * be incorporated into the next SCTP release. 35 * 36 * Written or modified by: 37 * La Monte H.P. Yarroll <piggy (at) acm.org> 38 * Karl Knutson <karl (at) athena.chicago.il.us> 39 * Randall Stewart <randall (at) stewart.chicago.il.us> 40 * Ken Morneau <kmorneau (at) cisco.com> 41 * Qiaobing Xie <qxie1 (at) motorola.com> 42 * Daisy Chang <daisyc (at) us.ibm.com> 43 * Jon Grimm <jgrimm (at) us.ibm.com> 44 * Sridhar Samudrala <samudrala (at) us.ibm.com> 45 * Hui Huang <hui.huang (at) nokia.com> 46 */ 47 48 #ifndef __sctputil_h__ 49 #define __sctputil_h__ 50 51 #ifdef LTP 52 #include <test.h> 53 #include <usctest.h> 54 #endif 55 56 #include <string.h> 57 58 typedef union { 59 struct sockaddr_in v4; 60 struct sockaddr_in6 v6; 61 struct sockaddr sa; 62 } sockaddr_storage_t; 63 64 65 #define REALLY_BIG 65536 66 67 /* Literal defines. */ 68 #ifdef PROT_SOCK 69 #define SCTP_TESTPORT_1 PROT_SOCK 70 #else 71 #define SCTP_TESTPORT_1 1024 72 #endif 73 #define SCTP_TESTPORT_2 (SCTP_TESTPORT_1+1) 74 75 #define SCTP_IP_BCAST htonl(0xffffffff) 76 #define SCTP_IP_LOOPBACK htonl(0x7f000001) 77 78 /* These are stolen from <netinet/in.h>. */ 79 #define SCTP_IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } } 80 #define SCTP_IN6ADDR_LOOPBACK_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } } 81 82 /* Display an IPv4 address in readable format. */ 83 #define NIPQUAD(addr) \ 84 ((unsigned char *)&addr)[0], \ 85 ((unsigned char *)&addr)[1], \ 86 ((unsigned char *)&addr)[2], \ 87 ((unsigned char *)&addr)[3] 88 89 /* Display an IPv6 address in readable format. */ 90 #define NIP6(addr) \ 91 ntohs((addr).s6_addr16[0]), \ 92 ntohs((addr).s6_addr16[1]), \ 93 ntohs((addr).s6_addr16[2]), \ 94 ntohs((addr).s6_addr16[3]), \ 95 ntohs((addr).s6_addr16[4]), \ 96 ntohs((addr).s6_addr16[5]), \ 97 ntohs((addr).s6_addr16[6]), \ 98 ntohs((addr).s6_addr16[7]) 99 100 #define DUMP_CORE { \ 101 char *diediedie = 0; \ 102 printf("DUMP_CORE %s: %d\n", __FILE__, __LINE__);\ 103 *diediedie = 0; \ 104 } 105 106 #ifndef LTP 107 enum { 108 TPASS, 109 TINFO, 110 }; 111 112 extern char *TCID; 113 extern int TST_TOTAL; 114 extern int TST_CNT; 115 116 #define tst_brkm(a1, a2, whatever...) \ 117 { \ 118 printf("%s %2d BROK : ", TCID, ++TST_CNT); \ 119 printf(whatever); \ 120 printf("\n"); \ 121 DUMP_CORE \ 122 } 123 #define tst_resm(a1, whatever...) \ 124 { \ 125 printf("%s %2d %s : ", TCID, \ 126 (a1 == TPASS)?++TST_CNT:0, \ 127 (a1 == TPASS)?"PASS":"INFO"); \ 128 printf(whatever); \ 129 printf("\n"); \ 130 } 131 #endif 132 133 static inline int test_socket(int domain, int type, int protocol) 134 { 135 int sk = socket(domain, type, protocol); 136 if (-1 == sk) 137 tst_brkm(TBROK, tst_exit, "socket: %s", strerror(errno)); 138 return sk; 139 } 140 141 static inline int test_bind(int sk, struct sockaddr *addr, socklen_t addrlen) 142 { 143 int error = bind(sk, addr, addrlen); 144 if (-1 == error) 145 tst_brkm(TBROK, tst_exit, "bind: %s", strerror(errno)); 146 return error; 147 } 148 149 static inline int test_bindx_add(int sk, struct sockaddr *addr, int count) 150 { 151 int error = sctp_bindx(sk, addr, count, SCTP_BINDX_ADD_ADDR); 152 if (-1 == error) 153 tst_brkm(TBROK, tst_exit, "bindx (add): %s", strerror(errno)); 154 return error; 155 } 156 157 static inline int test_listen(int sk, int backlog) 158 { 159 int error = listen(sk, backlog); 160 if (-1 == error) 161 tst_brkm(TBROK, tst_exit, "listen: %s", strerror(errno)); 162 return error; 163 } 164 165 static inline int test_connect(int sk, struct sockaddr *addr, socklen_t addrlen) 166 { 167 int error = connect(sk, addr, addrlen); 168 if (-1 == error) 169 tst_brkm(TBROK, tst_exit, "connect: %s", strerror(errno)); 170 return error; 171 } 172 173 static inline int test_connectx(int sk, struct sockaddr *addr, int count) 174 { 175 int error = sctp_connectx(sk, addr, count, NULL); 176 if (-1 == error) 177 tst_brkm(TBROK, tst_exit, "connectx: %s", strerror(errno)); 178 return error; 179 } 180 181 static inline int test_accept(int sk, struct sockaddr *addr, socklen_t *addrlen) 182 { 183 int error = accept(sk, addr, addrlen); 184 if (-1 == error) 185 tst_brkm(TBROK, tst_exit, "accept: %s", strerror(errno)); 186 return error; 187 } 188 189 static inline int test_send(int sk, const void *msg, size_t len, int flags) 190 { 191 int error = send(sk, msg, len, flags); 192 if (len != error) 193 tst_brkm(TBROK, tst_exit, "send: error:%d errno:%d", 194 error, errno); 195 return error; 196 } 197 198 static inline int test_sendto(int sk, const void *msg, size_t len, int flags, 199 const struct sockaddr *to, socklen_t tolen) 200 { 201 int error = sendto(sk, msg, len, flags, to, tolen); 202 if (len != error) 203 tst_brkm(TBROK, tst_exit, "sendto: error:%d errno:%d", 204 error, errno); 205 return error; 206 } 207 208 static inline int test_sendmsg(int sk, const struct msghdr *msg, int flags, 209 int msglen) 210 { 211 int error = sendmsg(sk, msg, flags); 212 if (msglen != error) 213 tst_brkm(TBROK, tst_exit, "sendmsg: error:%d errno:%d", 214 error, errno); 215 return error; 216 } 217 218 static inline int test_recv(int sk, void *buf, size_t len, int flags) 219 { 220 int error = recv(sk, buf, len, flags); 221 if (-1 == error) 222 tst_brkm(TBROK, tst_exit, "recv: %s", strerror(errno)); 223 return error; 224 } 225 226 static inline int test_recvmsg(int sk, struct msghdr *msg, int flags) 227 { 228 int error = recvmsg(sk, msg, flags); 229 if (-1 == error) 230 tst_brkm(TBROK, tst_exit, "recvmsg: %s", strerror(errno)); 231 return error; 232 } 233 234 static inline int test_shutdown(int sk, int how) 235 { 236 int error = shutdown(sk, how); 237 if (-1 == error) 238 tst_brkm(TBROK, tst_exit, "shutdown: %s", strerror(errno)); 239 return error; 240 } 241 242 static inline int test_getsockopt(int sk, int optname, void *optval, 243 socklen_t *optlen) 244 { 245 int error = getsockopt(sk, SOL_SCTP, optname, optval, optlen); 246 if (error) 247 tst_brkm(TBROK, tst_exit, "getsockopt(%d): %s", optname, 248 strerror(errno)); 249 return error; 250 } 251 252 static inline int test_setsockopt(int sk, int optname, const void *optval, 253 socklen_t optlen) 254 { 255 int error = setsockopt(sk, SOL_SCTP, optname, optval, optlen); 256 if (error) 257 tst_brkm(TBROK, tst_exit, "setsockopt(%d): %s", optname, 258 strerror(errno)); 259 return error; 260 } 261 262 static inline int test_sctp_peeloff(int sk, sctp_assoc_t assoc_id) 263 { 264 int error = sctp_peeloff(sk, assoc_id); 265 if (-1 == error) 266 tst_brkm(TBROK, tst_exit, "sctp_peeloff: %s", strerror(errno)); 267 return error; 268 } 269 270 static inline int test_sctp_sendmsg(int s, const void *msg, size_t len, 271 struct sockaddr *to, socklen_t tolen, 272 uint32_t ppid, uint32_t flags, 273 uint16_t stream_no, uint32_t timetolive, 274 uint32_t context) 275 { 276 int error = sctp_sendmsg(s, msg, len, to, tolen, ppid, flags, stream_no, 277 timetolive, context); 278 if (len != error) 279 tst_brkm(TBROK, tst_exit, "sctp_sendmsg: error:%d errno:%d", 280 error, errno); 281 return error; 282 } 283 284 static inline int test_sctp_send(int s, const void *msg, size_t len, 285 const struct sctp_sndrcvinfo *sinfo, 286 int flags) 287 { 288 int error = sctp_send(s, msg, len, sinfo, flags); 289 if (len != error) 290 tst_brkm(TBROK, tst_exit, "sctp_send: error:%d errno:%d", 291 error, errno); 292 return error; 293 } 294 295 static inline int test_sctp_recvmsg(int sk, void *msg, size_t len, 296 struct sockaddr *from, socklen_t *fromlen, 297 struct sctp_sndrcvinfo *sinfo, 298 int *msg_flags) 299 { 300 int error = sctp_recvmsg(sk, msg, len, from, fromlen, sinfo, msg_flags); 301 if (-1 == error) 302 tst_brkm(TBROK, tst_exit, "sctp_recvmsg: %s", strerror(errno)); 303 return error; 304 } 305 306 static inline void *test_malloc(size_t size) 307 { 308 void *buf = malloc(size); 309 if (NULL == buf) 310 tst_brkm(TBROK, tst_exit, "malloc failed"); 311 return buf; 312 } 313 314 void test_check_msg_notification(struct msghdr *, int, int, uint16_t, uint32_t); 315 void test_check_buf_notification(void *, int, int, int, uint16_t, uint32_t); 316 void test_check_msg_data(struct msghdr *, int, int, int, uint16_t, uint32_t); 317 void test_check_buf_data(void *, int, int, struct sctp_sndrcvinfo *, int, int, 318 uint16_t, uint32_t); 319 void *test_build_msg(int); 320 void test_enable_assoc_change(int); 321 void test_print_message(int sk, struct msghdr *msg, size_t msg_len); 322 int test_peer_addr(int sk, sctp_assoc_t asoc, sockaddr_storage_t *peers, int count); 323 324 #endif /* __sctputil_h__ */ 325
