Annotation of embedaddon/iperf/src/iperf_sctp.c, revision 1.1
1.1 ! misho 1: /*
! 2: * iperf, Copyright (c) 2014, 2015, The Regents of the University of
! 3: * California, through Lawrence Berkeley National Laboratory (subject
! 4: * to receipt of any required approvals from the U.S. Dept. of
! 5: * Energy). All rights reserved.
! 6: *
! 7: * If you have questions about your rights to use or distribute this
! 8: * software, please contact Berkeley Lab's Technology Transfer
! 9: * Department at TTD@lbl.gov.
! 10: *
! 11: * NOTICE. This software is owned by the U.S. Department of Energy.
! 12: * As such, the U.S. Government has been granted for itself and others
! 13: * acting on its behalf a paid-up, nonexclusive, irrevocable,
! 14: * worldwide license in the Software to reproduce, prepare derivative
! 15: * works, and perform publicly and display publicly. Beginning five
! 16: * (5) years after the date permission to assert copyright is obtained
! 17: * from the U.S. Department of Energy, and subject to any subsequent
! 18: * five (5) year renewals, the U.S. Government is granted for itself
! 19: * and others acting on its behalf a paid-up, nonexclusive,
! 20: * irrevocable, worldwide license in the Software to reproduce,
! 21: * prepare derivative works, distribute copies to the public, perform
! 22: * publicly and display publicly, and to permit others to do so.
! 23: *
! 24: * This code is distributed under a BSD style license, see the LICENSE
! 25: * file for complete information.
! 26: */
! 27: #include "iperf_config.h"
! 28:
! 29: #include <stdio.h>
! 30: #include <stdlib.h>
! 31: #include <string.h>
! 32: #include <errno.h>
! 33: #include <unistd.h>
! 34: #include <sys/socket.h>
! 35: #include <sys/types.h>
! 36: #include <netinet/in.h>
! 37: #include <netdb.h>
! 38: #include <netinet/tcp.h>
! 39: #include <sys/time.h>
! 40: #include <sys/select.h>
! 41:
! 42: #ifdef HAVE_NETINET_SCTP_H
! 43: #include <netinet/sctp.h>
! 44: #endif /* HAVE_NETINET_SCTP_H */
! 45:
! 46: #include "iperf.h"
! 47: #include "iperf_api.h"
! 48: #include "iperf_sctp.h"
! 49: #include "net.h"
! 50:
! 51:
! 52:
! 53: /* iperf_sctp_recv
! 54: *
! 55: * receives the data for SCTP
! 56: */
! 57: int
! 58: iperf_sctp_recv(struct iperf_stream *sp)
! 59: {
! 60: #if defined(HAVE_SCTP)
! 61: int r;
! 62:
! 63: r = Nread(sp->socket, sp->buffer, sp->settings->blksize, Psctp);
! 64: if (r < 0)
! 65: return r;
! 66:
! 67: sp->result->bytes_received += r;
! 68: sp->result->bytes_received_this_interval += r;
! 69:
! 70: return r;
! 71: #else
! 72: i_errno = IENOSCTP;
! 73: return -1;
! 74: #endif /* HAVE_SCTP */
! 75: }
! 76:
! 77:
! 78: /* iperf_sctp_send
! 79: *
! 80: * sends the data for SCTP
! 81: */
! 82: int
! 83: iperf_sctp_send(struct iperf_stream *sp)
! 84: {
! 85: #if defined(HAVE_SCTP)
! 86: int r;
! 87:
! 88: r = Nwrite(sp->socket, sp->buffer, sp->settings->blksize, Psctp);
! 89: if (r < 0)
! 90: return r;
! 91:
! 92: sp->result->bytes_sent += r;
! 93: sp->result->bytes_sent_this_interval += r;
! 94:
! 95: return r;
! 96: #else
! 97: i_errno = IENOSCTP;
! 98: return -1;
! 99: #endif /* HAVE_SCTP */
! 100: }
! 101:
! 102:
! 103:
! 104: /* iperf_sctp_accept
! 105: *
! 106: * accept a new SCTP stream connection
! 107: */
! 108: int
! 109: iperf_sctp_accept(struct iperf_test * test)
! 110: {
! 111: #if defined(HAVE_SCTP)
! 112: int s;
! 113: signed char rbuf = ACCESS_DENIED;
! 114: char cookie[COOKIE_SIZE];
! 115: socklen_t len;
! 116: struct sockaddr_storage addr;
! 117:
! 118: len = sizeof(addr);
! 119: s = accept(test->listener, (struct sockaddr *) &addr, &len);
! 120: if (s < 0) {
! 121: i_errno = IESTREAMCONNECT;
! 122: return -1;
! 123: }
! 124:
! 125: if (Nread(s, cookie, COOKIE_SIZE, Psctp) < 0) {
! 126: i_errno = IERECVCOOKIE;
! 127: return -1;
! 128: }
! 129:
! 130: if (strcmp(test->cookie, cookie) != 0) {
! 131: if (Nwrite(s, (char*) &rbuf, sizeof(rbuf), Psctp) < 0) {
! 132: i_errno = IESENDMESSAGE;
! 133: return -1;
! 134: }
! 135: close(s);
! 136: }
! 137:
! 138: return s;
! 139: #else
! 140: i_errno = IENOSCTP;
! 141: return -1;
! 142: #endif /* HAVE_SCTP */
! 143: }
! 144:
! 145:
! 146: /* iperf_sctp_listen
! 147: *
! 148: * start up a listener for SCTP stream connections
! 149: */
! 150: int
! 151: iperf_sctp_listen(struct iperf_test *test)
! 152: {
! 153: #if defined(HAVE_SCTP)
! 154: struct addrinfo hints, *res;
! 155: char portstr[6];
! 156: int s, opt;
! 157:
! 158: close(test->listener);
! 159:
! 160: snprintf(portstr, 6, "%d", test->server_port);
! 161: memset(&hints, 0, sizeof(hints));
! 162: hints.ai_family = (test->settings->domain == AF_UNSPEC ? AF_INET6 : test->settings->domain);
! 163: hints.ai_socktype = SOCK_STREAM;
! 164: hints.ai_flags = AI_PASSIVE;
! 165: if (getaddrinfo(test->bind_address, portstr, &hints, &res) != 0) {
! 166: i_errno = IESTREAMLISTEN;
! 167: return -1;
! 168: }
! 169:
! 170: if ((s = socket(res->ai_family, SOCK_STREAM, IPPROTO_SCTP)) < 0) {
! 171: freeaddrinfo(res);
! 172: i_errno = IESTREAMLISTEN;
! 173: return -1;
! 174: }
! 175:
! 176: #if defined(IPV6_V6ONLY) && !defined(__OpenBSD__)
! 177: if (test->settings->domain == AF_UNSPEC || test->settings->domain == AF_INET6) {
! 178: if (test->settings->domain == AF_UNSPEC)
! 179: opt = 0;
! 180: else if (test->settings->domain == AF_INET6)
! 181: opt = 1;
! 182: if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
! 183: (char *) &opt, sizeof(opt)) < 0) {
! 184: close(s);
! 185: freeaddrinfo(res);
! 186: i_errno = IEPROTOCOL;
! 187: return -1;
! 188: }
! 189: }
! 190: #endif /* IPV6_V6ONLY */
! 191:
! 192: opt = 1;
! 193: if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
! 194: close(s);
! 195: freeaddrinfo(res);
! 196: i_errno = IEREUSEADDR;
! 197: return -1;
! 198: }
! 199:
! 200: /* servers must call sctp_bindx() _instead_ of bind() */
! 201: if (!TAILQ_EMPTY(&test->xbind_addrs)) {
! 202: freeaddrinfo(res);
! 203: if (iperf_sctp_bindx(test, s, IPERF_SCTP_SERVER))
! 204: return -1;
! 205: } else
! 206: if (bind(s, (struct sockaddr *) res->ai_addr, res->ai_addrlen) < 0) {
! 207: close(s);
! 208: freeaddrinfo(res);
! 209: i_errno = IESTREAMLISTEN;
! 210: return -1;
! 211: }
! 212:
! 213: freeaddrinfo(res);
! 214:
! 215: if (listen(s, 5) < 0) {
! 216: i_errno = IESTREAMLISTEN;
! 217: return -1;
! 218: }
! 219:
! 220: test->listener = s;
! 221:
! 222: return s;
! 223: #else
! 224: i_errno = IENOSCTP;
! 225: return -1;
! 226: #endif /* HAVE_SCTP */
! 227: }
! 228:
! 229:
! 230: /* iperf_sctp_connect
! 231: *
! 232: * connect to a SCTP stream listener
! 233: */
! 234: int
! 235: iperf_sctp_connect(struct iperf_test *test)
! 236: {
! 237: #if defined(HAVE_SCTP)
! 238: int s, opt;
! 239: char portstr[6];
! 240: struct addrinfo hints, *local_res, *server_res;
! 241:
! 242: if (test->bind_address) {
! 243: memset(&hints, 0, sizeof(hints));
! 244: hints.ai_family = test->settings->domain;
! 245: hints.ai_socktype = SOCK_STREAM;
! 246: if (getaddrinfo(test->bind_address, NULL, &hints, &local_res) != 0) {
! 247: i_errno = IESTREAMCONNECT;
! 248: return -1;
! 249: }
! 250: }
! 251:
! 252: memset(&hints, 0, sizeof(hints));
! 253: hints.ai_family = test->settings->domain;
! 254: hints.ai_socktype = SOCK_STREAM;
! 255: snprintf(portstr, sizeof(portstr), "%d", test->server_port);
! 256: if (getaddrinfo(test->server_hostname, portstr, &hints, &server_res) != 0) {
! 257: if (test->bind_address)
! 258: freeaddrinfo(local_res);
! 259: i_errno = IESTREAMCONNECT;
! 260: return -1;
! 261: }
! 262:
! 263: s = socket(server_res->ai_family, SOCK_STREAM, IPPROTO_SCTP);
! 264: if (s < 0) {
! 265: if (test->bind_address)
! 266: freeaddrinfo(local_res);
! 267: freeaddrinfo(server_res);
! 268: i_errno = IESTREAMCONNECT;
! 269: return -1;
! 270: }
! 271:
! 272: if (test->no_delay != 0) {
! 273: opt = 1;
! 274: if (setsockopt(s, IPPROTO_SCTP, SCTP_NODELAY, &opt, sizeof(opt)) < 0) {
! 275: close(s);
! 276: freeaddrinfo(server_res);
! 277: i_errno = IESETNODELAY;
! 278: return -1;
! 279: }
! 280: }
! 281:
! 282: if ((test->settings->mss >= 512 && test->settings->mss <= 131072)) {
! 283:
! 284: /*
! 285: * Some platforms use a struct sctp_assoc_value as the
! 286: * argument to SCTP_MAXSEG. Other (older API implementations)
! 287: * take an int. FreeBSD 10 and CentOS 6 support SCTP_MAXSEG,
! 288: * but OpenSolaris 11 doesn't.
! 289: */
! 290: #ifdef HAVE_STRUCT_SCTP_ASSOC_VALUE
! 291: struct sctp_assoc_value av;
! 292:
! 293: /*
! 294: * Some platforms support SCTP_FUTURE_ASSOC, others need to
! 295: * (equivalently) do 0 here. FreeBSD 10 is an example of the
! 296: * former, CentOS 6 Linux is an example of the latter.
! 297: */
! 298: #ifdef SCTP_FUTURE_ASSOC
! 299: av.assoc_id = SCTP_FUTURE_ASSOC;
! 300: #else
! 301: av.assoc_id = 0;
! 302: #endif
! 303: av.assoc_value = test->settings->mss;
! 304:
! 305: if (setsockopt(s, IPPROTO_SCTP, SCTP_MAXSEG, &av, sizeof(av)) < 0) {
! 306: close(s);
! 307: freeaddrinfo(server_res);
! 308: i_errno = IESETMSS;
! 309: return -1;
! 310: }
! 311: #else
! 312: opt = test->settings->mss;
! 313:
! 314: /*
! 315: * Solaris might not support this option. If it doesn't work,
! 316: * ignore the error (at least for now).
! 317: */
! 318: if (setsockopt(s, IPPROTO_SCTP, SCTP_MAXSEG, &opt, sizeof(opt)) < 0 &&
! 319: errno != ENOPROTOOPT) {
! 320: close(s);
! 321: freeaddrinfo(server_res);
! 322: i_errno = IESETMSS;
! 323: return -1;
! 324: }
! 325: #endif HAVE_STRUCT_SCTP_ASSOC_VALUE
! 326: }
! 327:
! 328: if (test->settings->num_ostreams > 0) {
! 329: struct sctp_initmsg initmsg;
! 330:
! 331: memset(&initmsg, 0, sizeof(struct sctp_initmsg));
! 332: initmsg.sinit_num_ostreams = test->settings->num_ostreams;
! 333:
! 334: if (setsockopt(s, IPPROTO_SCTP, SCTP_INITMSG, &initmsg, sizeof(struct sctp_initmsg)) < 0) {
! 335: close(s);
! 336: freeaddrinfo(server_res);
! 337: i_errno = IESETSCTPNSTREAM;
! 338: return -1;
! 339: }
! 340: }
! 341:
! 342: /* clients must call bind() followed by sctp_bindx() before connect() */
! 343: if (!TAILQ_EMPTY(&test->xbind_addrs)) {
! 344: if (iperf_sctp_bindx(test, s, IPERF_SCTP_CLIENT))
! 345: return -1;
! 346: }
! 347:
! 348: /* TODO support sctp_connectx() to avoid heartbeating. */
! 349: if (connect(s, (struct sockaddr *) server_res->ai_addr, server_res->ai_addrlen) < 0 && errno != EINPROGRESS) {
! 350: close(s);
! 351: freeaddrinfo(server_res);
! 352: i_errno = IESTREAMCONNECT;
! 353: return -1;
! 354: }
! 355: freeaddrinfo(server_res);
! 356:
! 357: /* Send cookie for verification */
! 358: if (Nwrite(s, test->cookie, COOKIE_SIZE, Psctp) < 0) {
! 359: close(s);
! 360: i_errno = IESENDCOOKIE;
! 361: return -1;
! 362: }
! 363:
! 364: /*
! 365: * We want to allow fragmentation. But there's at least one
! 366: * implementation (Solaris) that doesn't support this option,
! 367: * even though it defines SCTP_DISABLE_FRAGMENTS. So we have to
! 368: * try setting the option and ignore the error, if it doesn't
! 369: * work.
! 370: */
! 371: opt = 0;
! 372: if (setsockopt(s, IPPROTO_SCTP, SCTP_DISABLE_FRAGMENTS, &opt, sizeof(opt)) < 0 &&
! 373: errno != ENOPROTOOPT) {
! 374: close(s);
! 375: freeaddrinfo(server_res);
! 376: i_errno = IESETSCTPDISABLEFRAG;
! 377: return -1;
! 378: }
! 379:
! 380: return s;
! 381: #else
! 382: i_errno = IENOSCTP;
! 383: return -1;
! 384: #endif /* HAVE_SCTP */
! 385: }
! 386:
! 387:
! 388:
! 389: int
! 390: iperf_sctp_init(struct iperf_test *test)
! 391: {
! 392: #if defined(HAVE_SCTP)
! 393: return 0;
! 394: #else
! 395: i_errno = IENOSCTP;
! 396: return -1;
! 397: #endif /* HAVE_SCTP */
! 398: }
! 399:
! 400:
! 401:
! 402: /* iperf_sctp_bindx
! 403: *
! 404: * handle binding to multiple endpoints (-X parameters)
! 405: */
! 406: int
! 407: iperf_sctp_bindx(struct iperf_test *test, int s, int is_server)
! 408: {
! 409: #if defined(HAVE_SCTP)
! 410: struct addrinfo hints;
! 411: char portstr[6];
! 412: char *servname;
! 413: struct addrinfo *ai, *ai0;
! 414: struct sockaddr *xaddrs;
! 415: struct xbind_entry *xbe, *xbe0;
! 416: char *bp;
! 417: size_t xaddrlen;
! 418: int nxaddrs;
! 419: int retval;
! 420: int domain;
! 421:
! 422: domain = test->settings->domain;
! 423: xbe0 = NULL;
! 424: retval = 0;
! 425:
! 426: if (TAILQ_EMPTY(&test->xbind_addrs))
! 427: return retval; /* nothing to do */
! 428:
! 429: memset(&hints, 0, sizeof(hints));
! 430: hints.ai_family = (domain == AF_UNSPEC ? AF_INET6 : domain);
! 431: hints.ai_socktype = SOCK_STREAM;
! 432: servname = NULL;
! 433: if (is_server) {
! 434: hints.ai_flags |= AI_PASSIVE;
! 435: snprintf(portstr, 6, "%d", test->server_port);
! 436: servname = portstr;
! 437: }
! 438:
! 439: /* client: must pop first -X address and call bind().
! 440: * sctp_bindx() must see the ephemeral port chosen by bind().
! 441: * we deliberately ignore the -B argument in this case.
! 442: */
! 443: if (!is_server) {
! 444: struct sockaddr *sa;
! 445: struct sockaddr_in *sin;
! 446: struct sockaddr_in6 *sin6;
! 447: int eport;
! 448:
! 449: xbe0 = TAILQ_FIRST(&test->xbind_addrs);
! 450: TAILQ_REMOVE(&test->xbind_addrs, xbe0, link);
! 451:
! 452: if (getaddrinfo(xbe0->name, servname, &hints, &xbe0->ai) != 0) {
! 453: i_errno = IESETSCTPBINDX;
! 454: retval = -1;
! 455: goto out;
! 456: }
! 457:
! 458: ai = xbe0->ai;
! 459: if (domain != AF_UNSPEC && domain != ai->ai_family) {
! 460: i_errno = IESETSCTPBINDX;
! 461: retval = -1;
! 462: goto out;
! 463: }
! 464: if (bind(s, (struct sockaddr *)ai->ai_addr, ai->ai_addrlen) < 0) {
! 465: i_errno = IESETSCTPBINDX;
! 466: retval = -1;
! 467: goto out;
! 468: }
! 469:
! 470: /* if only one -X argument, nothing more to do */
! 471: if (TAILQ_EMPTY(&test->xbind_addrs))
! 472: goto out;
! 473:
! 474: sa = (struct sockaddr *)ai->ai_addr;
! 475: if (sa->sa_family == AF_INET) {
! 476: sin = (struct sockaddr_in *)ai->ai_addr;
! 477: eport = sin->sin_port;
! 478: } else if (sa->sa_family == AF_INET6) {
! 479: sin6 = (struct sockaddr_in6 *)ai->ai_addr;
! 480: eport = sin6->sin6_port;
! 481: } else {
! 482: i_errno = IESETSCTPBINDX;
! 483: retval = -1;
! 484: goto out;
! 485: }
! 486: snprintf(portstr, 6, "%d", ntohs(eport));
! 487: servname = portstr;
! 488: }
! 489:
! 490: /* pass 1: resolve and compute lengths. */
! 491: nxaddrs = 0;
! 492: xaddrlen = 0;
! 493: TAILQ_FOREACH(xbe, &test->xbind_addrs, link) {
! 494: if (xbe->ai != NULL)
! 495: freeaddrinfo(xbe->ai);
! 496: if (getaddrinfo(xbe->name, servname, &hints, &xbe->ai) != 0) {
! 497: i_errno = IESETSCTPBINDX;
! 498: retval = -1;
! 499: goto out;
! 500: }
! 501: ai0 = xbe->ai;
! 502: for (ai = ai0; ai; ai = ai->ai_next) {
! 503: if (domain != AF_UNSPEC && domain != ai->ai_family)
! 504: continue;
! 505: xaddrlen += ai->ai_addrlen;
! 506: ++nxaddrs;
! 507: }
! 508: }
! 509:
! 510: /* pass 2: copy into flat buffer. */
! 511: xaddrs = (struct sockaddr *)malloc(xaddrlen);
! 512: if (!xaddrs) {
! 513: i_errno = IESETSCTPBINDX;
! 514: retval = -1;
! 515: goto out;
! 516: }
! 517: bp = (char *)xaddrs;
! 518: TAILQ_FOREACH(xbe, &test->xbind_addrs, link) {
! 519: ai0 = xbe->ai;
! 520: for (ai = ai0; ai; ai = ai->ai_next) {
! 521: if (domain != AF_UNSPEC && domain != ai->ai_family)
! 522: continue;
! 523: memcpy(bp, ai->ai_addr, ai->ai_addrlen);
! 524: bp += ai->ai_addrlen;
! 525: }
! 526: }
! 527:
! 528: if (sctp_bindx(s, xaddrs, nxaddrs, SCTP_BINDX_ADD_ADDR) == -1) {
! 529: close(s);
! 530: free(xaddrs);
! 531: i_errno = IESETSCTPBINDX;
! 532: retval = -1;
! 533: goto out;
! 534: }
! 535:
! 536: free(xaddrs);
! 537: retval = 0;
! 538:
! 539: out:
! 540: /* client: put head node back. */
! 541: if (!is_server && xbe0)
! 542: TAILQ_INSERT_HEAD(&test->xbind_addrs, xbe0, link);
! 543:
! 544: TAILQ_FOREACH(xbe, &test->xbind_addrs, link) {
! 545: if (xbe->ai) {
! 546: freeaddrinfo(xbe->ai);
! 547: xbe->ai = NULL;
! 548: }
! 549: }
! 550:
! 551: return retval;
! 552: #else
! 553: i_errno = IENOSCTP;
! 554: return -1;
! 555: #endif /* HAVE_SCTP */
! 556: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to iperf_sctp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / iperf / src