Annotation of embedaddon/iperf/src/iperf_tcp.c, revision 1.1
1.1 ! misho 1: /*
! 2: * iperf, Copyright (c) 2014, 2016, 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: #include "iperf.h"
! 43: #include "iperf_api.h"
! 44: #include "iperf_tcp.h"
! 45: #include "net.h"
! 46:
! 47: #if defined(HAVE_FLOWLABEL)
! 48: #include "flowlabel.h"
! 49: #endif /* HAVE_FLOWLABEL */
! 50:
! 51: /* iperf_tcp_recv
! 52: *
! 53: * receives the data for TCP
! 54: */
! 55: int
! 56: iperf_tcp_recv(struct iperf_stream *sp)
! 57: {
! 58: int r;
! 59:
! 60: r = Nread(sp->socket, sp->buffer, sp->settings->blksize, Ptcp);
! 61:
! 62: if (r < 0)
! 63: return r;
! 64:
! 65: sp->result->bytes_received += r;
! 66: sp->result->bytes_received_this_interval += r;
! 67:
! 68: return r;
! 69: }
! 70:
! 71:
! 72: /* iperf_tcp_send
! 73: *
! 74: * sends the data for TCP
! 75: */
! 76: int
! 77: iperf_tcp_send(struct iperf_stream *sp)
! 78: {
! 79: int r;
! 80:
! 81: if (sp->test->zerocopy)
! 82: r = Nsendfile(sp->buffer_fd, sp->socket, sp->buffer, sp->settings->blksize);
! 83: else
! 84: r = Nwrite(sp->socket, sp->buffer, sp->settings->blksize, Ptcp);
! 85:
! 86: if (r < 0)
! 87: return r;
! 88:
! 89: sp->result->bytes_sent += r;
! 90: sp->result->bytes_sent_this_interval += r;
! 91:
! 92: return r;
! 93: }
! 94:
! 95:
! 96: /* iperf_tcp_accept
! 97: *
! 98: * accept a new TCP stream connection
! 99: */
! 100: int
! 101: iperf_tcp_accept(struct iperf_test * test)
! 102: {
! 103: int s;
! 104: signed char rbuf = ACCESS_DENIED;
! 105: char cookie[COOKIE_SIZE];
! 106: socklen_t len;
! 107: struct sockaddr_storage addr;
! 108:
! 109: len = sizeof(addr);
! 110: if ((s = accept(test->listener, (struct sockaddr *) &addr, &len)) < 0) {
! 111: i_errno = IESTREAMCONNECT;
! 112: return -1;
! 113: }
! 114:
! 115: if (Nread(s, cookie, COOKIE_SIZE, Ptcp) < 0) {
! 116: i_errno = IERECVCOOKIE;
! 117: return -1;
! 118: }
! 119:
! 120: if (strcmp(test->cookie, cookie) != 0) {
! 121: if (Nwrite(s, (char*) &rbuf, sizeof(rbuf), Ptcp) < 0) {
! 122: i_errno = IESENDMESSAGE;
! 123: return -1;
! 124: }
! 125: close(s);
! 126: }
! 127:
! 128: return s;
! 129: }
! 130:
! 131:
! 132: /* iperf_tcp_listen
! 133: *
! 134: * start up a listener for TCP stream connections
! 135: */
! 136: int
! 137: iperf_tcp_listen(struct iperf_test *test)
! 138: {
! 139: struct addrinfo hints, *res;
! 140: char portstr[6];
! 141: int s, opt;
! 142: int saved_errno;
! 143:
! 144: s = test->listener;
! 145:
! 146: /*
! 147: * If certain parameters are specified (such as socket buffer
! 148: * size), then throw away the listening socket (the one for which
! 149: * we just accepted the control connection) and recreate it with
! 150: * those parameters. That way, when new data connections are
! 151: * set, they'll have all the correct parameters in place.
! 152: *
! 153: * It's not clear whether this is a requirement or a convenience.
! 154: */
! 155: if (test->no_delay || test->settings->mss || test->settings->socket_bufsize) {
! 156: FD_CLR(s, &test->read_set);
! 157: close(s);
! 158:
! 159: snprintf(portstr, 6, "%d", test->server_port);
! 160: memset(&hints, 0, sizeof(hints));
! 161:
! 162: /*
! 163: * If binding to the wildcard address with no explicit address
! 164: * family specified, then force us to get an AF_INET6 socket.
! 165: * More details in the comments in netanounce().
! 166: */
! 167: if (test->settings->domain == AF_UNSPEC && !test->bind_address) {
! 168: hints.ai_family = AF_INET6;
! 169: }
! 170: else {
! 171: hints.ai_family = test->settings->domain;
! 172: }
! 173: hints.ai_socktype = SOCK_STREAM;
! 174: hints.ai_flags = AI_PASSIVE;
! 175: if (getaddrinfo(test->bind_address, portstr, &hints, &res) != 0) {
! 176: i_errno = IESTREAMLISTEN;
! 177: return -1;
! 178: }
! 179:
! 180: if ((s = socket(res->ai_family, SOCK_STREAM, 0)) < 0) {
! 181: freeaddrinfo(res);
! 182: i_errno = IESTREAMLISTEN;
! 183: return -1;
! 184: }
! 185:
! 186: if (test->no_delay) {
! 187: opt = 1;
! 188: if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)) < 0) {
! 189: saved_errno = errno;
! 190: close(s);
! 191: freeaddrinfo(res);
! 192: errno = saved_errno;
! 193: i_errno = IESETNODELAY;
! 194: return -1;
! 195: }
! 196: }
! 197: // XXX: Setting MSS is very buggy!
! 198: if ((opt = test->settings->mss)) {
! 199: if (setsockopt(s, IPPROTO_TCP, TCP_MAXSEG, &opt, sizeof(opt)) < 0) {
! 200: saved_errno = errno;
! 201: close(s);
! 202: freeaddrinfo(res);
! 203: errno = saved_errno;
! 204: i_errno = IESETMSS;
! 205: return -1;
! 206: }
! 207: }
! 208: if ((opt = test->settings->socket_bufsize)) {
! 209: if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) < 0) {
! 210: saved_errno = errno;
! 211: close(s);
! 212: freeaddrinfo(res);
! 213: errno = saved_errno;
! 214: i_errno = IESETBUF;
! 215: return -1;
! 216: }
! 217: if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) < 0) {
! 218: saved_errno = errno;
! 219: close(s);
! 220: freeaddrinfo(res);
! 221: errno = saved_errno;
! 222: i_errno = IESETBUF;
! 223: return -1;
! 224: }
! 225: }
! 226: if (test->debug) {
! 227: socklen_t optlen = sizeof(opt);
! 228: if (getsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, &optlen) < 0) {
! 229: saved_errno = errno;
! 230: close(s);
! 231: freeaddrinfo(res);
! 232: errno = saved_errno;
! 233: i_errno = IESETBUF;
! 234: return -1;
! 235: }
! 236: printf("SO_SNDBUF is %u\n", opt);
! 237: }
! 238: #if defined(HAVE_TCP_CONGESTION)
! 239: if (test->congestion) {
! 240: if (setsockopt(s, IPPROTO_TCP, TCP_CONGESTION, test->congestion, strlen(test->congestion)) < 0) {
! 241: close(s);
! 242: freeaddrinfo(res);
! 243: i_errno = IESETCONGESTION;
! 244: return -1;
! 245: }
! 246: }
! 247: #endif /* HAVE_TCP_CONGESTION */
! 248: #if defined(HAVE_SO_MAX_PACING_RATE)
! 249: /* If socket pacing is available and not disabled, try it. */
! 250: if (! test->no_fq_socket_pacing) {
! 251: /* Convert bits per second to bytes per second */
! 252: unsigned int rate = test->settings->rate / 8;
! 253: if (rate > 0) {
! 254: if (test->debug) {
! 255: printf("Setting fair-queue socket pacing to %u\n", rate);
! 256: }
! 257: if (setsockopt(s, SOL_SOCKET, SO_MAX_PACING_RATE, &rate, sizeof(rate)) < 0) {
! 258: warning("Unable to set socket pacing, using application pacing instead");
! 259: test->no_fq_socket_pacing = 1;
! 260: }
! 261: }
! 262: }
! 263: #endif /* HAVE_SO_MAX_PACING_RATE */
! 264: opt = 1;
! 265: if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
! 266: saved_errno = errno;
! 267: close(s);
! 268: freeaddrinfo(res);
! 269: errno = saved_errno;
! 270: i_errno = IEREUSEADDR;
! 271: return -1;
! 272: }
! 273:
! 274: /*
! 275: * If we got an IPv6 socket, figure out if it shoudl accept IPv4
! 276: * connections as well. See documentation in netannounce() for
! 277: * more details.
! 278: */
! 279: #if defined(IPV6_V6ONLY) && !defined(__OpenBSD__)
! 280: if (res->ai_family == AF_INET6 && (test->settings->domain == AF_UNSPEC || test->settings->domain == AF_INET)) {
! 281: if (test->settings->domain == AF_UNSPEC)
! 282: opt = 0;
! 283: else
! 284: opt = 1;
! 285: if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
! 286: (char *) &opt, sizeof(opt)) < 0) {
! 287: saved_errno = errno;
! 288: close(s);
! 289: freeaddrinfo(res);
! 290: errno = saved_errno;
! 291: i_errno = IEV6ONLY;
! 292: return -1;
! 293: }
! 294: }
! 295: #endif /* IPV6_V6ONLY */
! 296:
! 297: if (bind(s, (struct sockaddr *) res->ai_addr, res->ai_addrlen) < 0) {
! 298: saved_errno = errno;
! 299: close(s);
! 300: freeaddrinfo(res);
! 301: errno = saved_errno;
! 302: i_errno = IESTREAMLISTEN;
! 303: return -1;
! 304: }
! 305:
! 306: freeaddrinfo(res);
! 307:
! 308: if (listen(s, 5) < 0) {
! 309: i_errno = IESTREAMLISTEN;
! 310: return -1;
! 311: }
! 312:
! 313: test->listener = s;
! 314: }
! 315:
! 316: return s;
! 317: }
! 318:
! 319:
! 320: /* iperf_tcp_connect
! 321: *
! 322: * connect to a TCP stream listener
! 323: */
! 324: int
! 325: iperf_tcp_connect(struct iperf_test *test)
! 326: {
! 327: struct addrinfo hints, *local_res, *server_res;
! 328: char portstr[6];
! 329: int s, opt;
! 330: int saved_errno;
! 331:
! 332: if (test->bind_address) {
! 333: memset(&hints, 0, sizeof(hints));
! 334: hints.ai_family = test->settings->domain;
! 335: hints.ai_socktype = SOCK_STREAM;
! 336: if (getaddrinfo(test->bind_address, NULL, &hints, &local_res) != 0) {
! 337: i_errno = IESTREAMCONNECT;
! 338: return -1;
! 339: }
! 340: }
! 341:
! 342: memset(&hints, 0, sizeof(hints));
! 343: hints.ai_family = test->settings->domain;
! 344: hints.ai_socktype = SOCK_STREAM;
! 345: snprintf(portstr, sizeof(portstr), "%d", test->server_port);
! 346: if (getaddrinfo(test->server_hostname, portstr, &hints, &server_res) != 0) {
! 347: if (test->bind_address)
! 348: freeaddrinfo(local_res);
! 349: i_errno = IESTREAMCONNECT;
! 350: return -1;
! 351: }
! 352:
! 353: if ((s = socket(server_res->ai_family, SOCK_STREAM, 0)) < 0) {
! 354: if (test->bind_address)
! 355: freeaddrinfo(local_res);
! 356: freeaddrinfo(server_res);
! 357: i_errno = IESTREAMCONNECT;
! 358: return -1;
! 359: }
! 360:
! 361: if (test->bind_address) {
! 362: struct sockaddr_in *lcladdr;
! 363: lcladdr = (struct sockaddr_in *)local_res->ai_addr;
! 364: lcladdr->sin_port = htons(test->bind_port);
! 365: local_res->ai_addr = (struct sockaddr *)lcladdr;
! 366:
! 367: if (bind(s, (struct sockaddr *) local_res->ai_addr, local_res->ai_addrlen) < 0) {
! 368: saved_errno = errno;
! 369: close(s);
! 370: freeaddrinfo(local_res);
! 371: freeaddrinfo(server_res);
! 372: errno = saved_errno;
! 373: i_errno = IESTREAMCONNECT;
! 374: return -1;
! 375: }
! 376: freeaddrinfo(local_res);
! 377: }
! 378:
! 379: /* Set socket options */
! 380: if (test->no_delay) {
! 381: opt = 1;
! 382: if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)) < 0) {
! 383: saved_errno = errno;
! 384: close(s);
! 385: freeaddrinfo(server_res);
! 386: errno = saved_errno;
! 387: i_errno = IESETNODELAY;
! 388: return -1;
! 389: }
! 390: }
! 391: if ((opt = test->settings->mss)) {
! 392: if (setsockopt(s, IPPROTO_TCP, TCP_MAXSEG, &opt, sizeof(opt)) < 0) {
! 393: saved_errno = errno;
! 394: close(s);
! 395: freeaddrinfo(server_res);
! 396: errno = saved_errno;
! 397: i_errno = IESETMSS;
! 398: return -1;
! 399: }
! 400: }
! 401: if ((opt = test->settings->socket_bufsize)) {
! 402: if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) < 0) {
! 403: saved_errno = errno;
! 404: close(s);
! 405: freeaddrinfo(server_res);
! 406: errno = saved_errno;
! 407: i_errno = IESETBUF;
! 408: return -1;
! 409: }
! 410: if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) < 0) {
! 411: saved_errno = errno;
! 412: close(s);
! 413: freeaddrinfo(server_res);
! 414: errno = saved_errno;
! 415: i_errno = IESETBUF;
! 416: return -1;
! 417: }
! 418: }
! 419: if (test->debug) {
! 420: socklen_t optlen = sizeof(opt);
! 421: if (getsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, &optlen) < 0) {
! 422: saved_errno = errno;
! 423: close(s);
! 424: freeaddrinfo(server_res);
! 425: errno = saved_errno;
! 426: i_errno = IESETBUF;
! 427: return -1;
! 428: }
! 429: printf("SO_SNDBUF is %u\n", opt);
! 430: }
! 431: #if defined(HAVE_FLOWLABEL)
! 432: if (test->settings->flowlabel) {
! 433: if (server_res->ai_addr->sa_family != AF_INET6) {
! 434: saved_errno = errno;
! 435: close(s);
! 436: freeaddrinfo(server_res);
! 437: errno = saved_errno;
! 438: i_errno = IESETFLOW;
! 439: return -1;
! 440: } else {
! 441: struct sockaddr_in6* sa6P = (struct sockaddr_in6*) server_res->ai_addr;
! 442: char freq_buf[sizeof(struct in6_flowlabel_req)];
! 443: struct in6_flowlabel_req *freq = (struct in6_flowlabel_req *)freq_buf;
! 444: int freq_len = sizeof(*freq);
! 445:
! 446: memset(freq, 0, sizeof(*freq));
! 447: freq->flr_label = htonl(test->settings->flowlabel & IPV6_FLOWINFO_FLOWLABEL);
! 448: freq->flr_action = IPV6_FL_A_GET;
! 449: freq->flr_flags = IPV6_FL_F_CREATE;
! 450: freq->flr_share = IPV6_FL_F_CREATE | IPV6_FL_S_EXCL;
! 451: memcpy(&freq->flr_dst, &sa6P->sin6_addr, 16);
! 452:
! 453: if (setsockopt(s, IPPROTO_IPV6, IPV6_FLOWLABEL_MGR, freq, freq_len) < 0) {
! 454: saved_errno = errno;
! 455: close(s);
! 456: freeaddrinfo(server_res);
! 457: errno = saved_errno;
! 458: i_errno = IESETFLOW;
! 459: return -1;
! 460: }
! 461: sa6P->sin6_flowinfo = freq->flr_label;
! 462:
! 463: opt = 1;
! 464: if (setsockopt(s, IPPROTO_IPV6, IPV6_FLOWINFO_SEND, &opt, sizeof(opt)) < 0) {
! 465: saved_errno = errno;
! 466: close(s);
! 467: freeaddrinfo(server_res);
! 468: errno = saved_errno;
! 469: i_errno = IESETFLOW;
! 470: return -1;
! 471: }
! 472: }
! 473: }
! 474: #endif /* HAVE_FLOWLABEL */
! 475:
! 476: #if defined(HAVE_TCP_CONGESTION)
! 477: if (test->congestion) {
! 478: if (setsockopt(s, IPPROTO_TCP, TCP_CONGESTION, test->congestion, strlen(test->congestion)) < 0) {
! 479: close(s);
! 480: freeaddrinfo(server_res);
! 481: i_errno = IESETCONGESTION;
! 482: return -1;
! 483: }
! 484: }
! 485: #endif /* HAVE_TCP_CONGESTION */
! 486:
! 487: #if defined(HAVE_SO_MAX_PACING_RATE)
! 488: /* If socket pacing is available and not disabled, try it. */
! 489: if (! test->no_fq_socket_pacing) {
! 490: /* Convert bits per second to bytes per second */
! 491: unsigned int rate = test->settings->rate / 8;
! 492: if (rate > 0) {
! 493: if (test->debug) {
! 494: printf("Socket pacing set to %u\n", rate);
! 495: }
! 496: if (setsockopt(s, SOL_SOCKET, SO_MAX_PACING_RATE, &rate, sizeof(rate)) < 0) {
! 497: warning("Unable to set socket pacing, using application pacing instead");
! 498: test->no_fq_socket_pacing = 1;
! 499: }
! 500: }
! 501: }
! 502: #endif /* HAVE_SO_MAX_PACING_RATE */
! 503:
! 504: if (connect(s, (struct sockaddr *) server_res->ai_addr, server_res->ai_addrlen) < 0 && errno != EINPROGRESS) {
! 505: saved_errno = errno;
! 506: close(s);
! 507: freeaddrinfo(server_res);
! 508: errno = saved_errno;
! 509: i_errno = IESTREAMCONNECT;
! 510: return -1;
! 511: }
! 512:
! 513: freeaddrinfo(server_res);
! 514:
! 515: /* Send cookie for verification */
! 516: if (Nwrite(s, test->cookie, COOKIE_SIZE, Ptcp) < 0) {
! 517: saved_errno = errno;
! 518: close(s);
! 519: errno = saved_errno;
! 520: i_errno = IESENDCOOKIE;
! 521: return -1;
! 522: }
! 523:
! 524: return s;
! 525: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to iperf_tcp.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