1 /* 2 * iperf, Copyright (c) 2014-2020 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 [email protected]. 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 /* iperf_server_api.c: Functions to be used by an iperf server 28 */ 29 30 #include <stdio.h> 31 #include <stdlib.h> 32 #include <string.h> 33 #include <getopt.h> 34 #include <errno.h> 35 #include <unistd.h> 36 #include <assert.h> 37 #include <fcntl.h> 38 #include <sys/socket.h> 39 #include <sys/types.h> 40 #include <netinet/in.h> 41 #include <arpa/inet.h> 42 #include <netdb.h> 43 #ifdef HAVE_STDINT_H 44 #include <stdint.h> 45 #endif 46 #include <sys/time.h> 47 #include <sys/resource.h> 48 #include <sched.h> 49 #include <setjmp.h> 50 51 #include "iperf.h" 52 #include "iperf_api.h" 53 #include "iperf_udp.h" 54 #include "iperf_tcp.h" 55 #include "iperf_util.h" 56 #include "timer.h" 57 #include "iperf_time.h" 58 #include "net.h" 59 #include "units.h" 60 #include "iperf_util.h" 61 #include "iperf_locale.h" 62 63 #if defined(HAVE_TCP_CONGESTION) 64 #if !defined(TCP_CA_NAME_MAX) 65 #define TCP_CA_NAME_MAX 16 66 #endif /* TCP_CA_NAME_MAX */ 67 #endif /* HAVE_TCP_CONGESTION */ 68 69 int 70 iperf_server_listen(struct iperf_test *test) 71 { 72 retry: 73 if((test->listener = netannounce(test->settings->domain, Ptcp, test->bind_address, test->bind_dev, test->server_port)) < 0) { 74 if (errno == EAFNOSUPPORT && (test->settings->domain == AF_INET6 || test->settings->domain == AF_UNSPEC)) { 75 /* If we get "Address family not supported by protocol", that 76 ** probably means we were compiled with IPv6 but the running 77 ** kernel does not actually do IPv6. This is not too unusual, 78 ** v6 support is and perhaps always will be spotty. 79 */ 80 warning("this system does not seem to support IPv6 - trying IPv4"); 81 test->settings->domain = AF_INET; 82 goto retry; 83 } else { 84 i_errno = IELISTEN; 85 return -1; 86 } 87 } 88 89 if (!test->json_output) { 90 iperf_printf(test, "-----------------------------------------------------------\n"); 91 iperf_printf(test, "Server listening on %d\n", test->server_port); 92 iperf_printf(test, "-----------------------------------------------------------\n"); 93 if (test->forceflush) 94 iflush(test); 95 } 96 97 FD_ZERO(&test->read_set); 98 FD_ZERO(&test->write_set); 99 FD_SET(test->listener, &test->read_set); 100 if (test->listener > test->max_fd) test->max_fd = test->listener; 101 102 return 0; 103 } 104 105 int 106 iperf_accept(struct iperf_test *test) 107 { 108 int s; 109 signed char rbuf = ACCESS_DENIED; 110 socklen_t len; 111 struct sockaddr_storage addr; 112 113 len = sizeof(addr); 114 if ((s = accept(test->listener, (struct sockaddr *) &addr, &len)) < 0) { 115 i_errno = IEACCEPT; 116 return -1; 117 } 118 119 if (test->ctrl_sck == -1) { 120 /* Server free, accept new client */ 121 test->ctrl_sck = s; 122 // set TCP_NODELAY for lower latency on control messages 123 int flag = 1; 124 if (setsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int))) { 125 i_errno = IESETNODELAY; 126 return -1; 127 } 128 129 if (Nread(test->ctrl_sck, test->cookie, COOKIE_SIZE, Ptcp) < 0) { 130 i_errno = IERECVCOOKIE; 131 return -1; 132 } 133 FD_SET(test->ctrl_sck, &test->read_set); 134 if (test->ctrl_sck > test->max_fd) test->max_fd = test->ctrl_sck; 135 136 if (iperf_set_send_state(test, PARAM_EXCHANGE) != 0) 137 return -1; 138 if (iperf_exchange_parameters(test) < 0) 139 return -1; 140 if (test->server_affinity != -1) 141 if (iperf_setaffinity(test, test->server_affinity) != 0) 142 return -1; 143 if (test->on_connect) 144 test->on_connect(test); 145 } else { 146 /* 147 * Don't try to read from the socket. It could block an ongoing test. 148 * Just send ACCESS_DENIED. 149 */ 150 if (Nwrite(s, (char*) &rbuf, sizeof(rbuf), Ptcp) < 0) { 151 i_errno = IESENDMESSAGE; 152 return -1; 153 } 154 close(s); 155 } 156 157 return 0; 158 } 159 160 161 /**************************************************************************/ 162 int 163 iperf_handle_message_server(struct iperf_test *test) 164 { 165 int rval; 166 struct iperf_stream *sp; 167 168 // XXX: Need to rethink how this behaves to fit API 169 if ((rval = Nread(test->ctrl_sck, (char*) &test->state, sizeof(signed char), Ptcp)) <= 0) { 170 if (rval == 0) { 171 iperf_err(test, "the client has unexpectedly closed the connection"); 172 i_errno = IECTRLCLOSE; 173 test->state = IPERF_DONE; 174 return 0; 175 } else { 176 i_errno = IERECVMESSAGE; 177 return -1; 178 } 179 } 180 181 switch(test->state) { 182 case TEST_START: 183 break; 184 case TEST_END: 185 test->done = 1; 186 cpu_util(test->cpu_util); 187 test->stats_callback(test); 188 SLIST_FOREACH(sp, &test->streams, streams) { 189 FD_CLR(sp->socket, &test->read_set); 190 FD_CLR(sp->socket, &test->write_set); 191 close(sp->socket); 192 } 193 test->reporter_callback(test); 194 if (iperf_set_send_state(test, EXCHANGE_RESULTS) != 0) 195 return -1; 196 if (iperf_exchange_results(test) < 0) 197 return -1; 198 if (iperf_set_send_state(test, DISPLAY_RESULTS) != 0) 199 return -1; 200 if (test->on_test_finish) 201 test->on_test_finish(test); 202 break; 203 case IPERF_DONE: 204 break; 205 case CLIENT_TERMINATE: 206 i_errno = IECLIENTTERM; 207 208 // Temporarily be in DISPLAY_RESULTS phase so we can get 209 // ending summary statistics. 210 signed char oldstate = test->state; 211 cpu_util(test->cpu_util); 212 test->state = DISPLAY_RESULTS; 213 test->reporter_callback(test); 214 test->state = oldstate; 215 216 // XXX: Remove this line below! 217 iperf_err(test, "the client has terminated"); 218 SLIST_FOREACH(sp, &test->streams, streams) { 219 FD_CLR(sp->socket, &test->read_set); 220 FD_CLR(sp->socket, &test->write_set); 221 close(sp->socket); 222 } 223 test->state = IPERF_DONE; 224 break; 225 default: 226 i_errno = IEMESSAGE; 227 return -1; 228 } 229 230 return 0; 231 } 232 233 static void 234 server_timer_proc(TimerClientData client_data, struct iperf_time *nowP) 235 { 236 struct iperf_test *test = client_data.p; 237 struct iperf_stream *sp; 238 239 test->timer = NULL; 240 if (test->done) 241 return; 242 test->done = 1; 243 /* Free streams */ 244 while (!SLIST_EMPTY(&test->streams)) { 245 sp = SLIST_FIRST(&test->streams); 246 SLIST_REMOVE_HEAD(&test->streams, streams); 247 close(sp->socket); 248 iperf_free_stream(sp); 249 } 250 close(test->ctrl_sck); 251 } 252 253 static void 254 server_stats_timer_proc(TimerClientData client_data, struct iperf_time *nowP) 255 { 256 struct iperf_test *test = client_data.p; 257 258 if (test->done) 259 return; 260 if (test->stats_callback) 261 test->stats_callback(test); 262 } 263 264 static void 265 server_reporter_timer_proc(TimerClientData client_data, struct iperf_time *nowP) 266 { 267 struct iperf_test *test = client_data.p; 268 269 if (test->done) 270 return; 271 if (test->reporter_callback) 272 test->reporter_callback(test); 273 } 274 275 static int 276 create_server_timers(struct iperf_test * test) 277 { 278 struct iperf_time now; 279 TimerClientData cd; 280 int max_rtt = 4; /* seconds */ 281 int state_transitions = 10; /* number of state transitions in iperf3 */ 282 int grace_period = max_rtt * state_transitions; 283 284 if (iperf_time_now(&now) < 0) { 285 i_errno = IEINITTEST; 286 return -1; 287 } 288 cd.p = test; 289 test->timer = test->stats_timer = test->reporter_timer = NULL; 290 if (test->duration != 0 ) { 291 test->done = 0; 292 test->timer = tmr_create(&now, server_timer_proc, cd, (test->duration + test->omit + grace_period) * SEC_TO_US, 0); 293 if (test->timer == NULL) { 294 i_errno = IEINITTEST; 295 return -1; 296 } 297 } 298 299 test->stats_timer = test->reporter_timer = NULL; 300 if (test->stats_interval != 0) { 301 test->stats_timer = tmr_create(&now, server_stats_timer_proc, cd, test->stats_interval * SEC_TO_US, 1); 302 if (test->stats_timer == NULL) { 303 i_errno = IEINITTEST; 304 return -1; 305 } 306 } 307 if (test->reporter_interval != 0) { 308 test->reporter_timer = tmr_create(&now, server_reporter_timer_proc, cd, test->reporter_interval * SEC_TO_US, 1); 309 if (test->reporter_timer == NULL) { 310 i_errno = IEINITTEST; 311 return -1; 312 } 313 } 314 return 0; 315 } 316 317 static void 318 server_omit_timer_proc(TimerClientData client_data, struct iperf_time *nowP) 319 { 320 struct iperf_test *test = client_data.p; 321 322 test->omit_timer = NULL; 323 test->omitting = 0; 324 iperf_reset_stats(test); 325 if (test->verbose && !test->json_output && test->reporter_interval == 0) 326 iperf_printf(test, "%s", report_omit_done); 327 328 /* Reset the timers. */ 329 if (test->stats_timer != NULL) 330 tmr_reset(nowP, test->stats_timer); 331 if (test->reporter_timer != NULL) 332 tmr_reset(nowP, test->reporter_timer); 333 } 334 335 static int 336 create_server_omit_timer(struct iperf_test * test) 337 { 338 struct iperf_time now; 339 TimerClientData cd; 340 341 if (test->omit == 0) { 342 test->omit_timer = NULL; 343 test->omitting = 0; 344 } else { 345 if (iperf_time_now(&now) < 0) { 346 i_errno = IEINITTEST; 347 return -1; 348 } 349 test->omitting = 1; 350 cd.p = test; 351 test->omit_timer = tmr_create(&now, server_omit_timer_proc, cd, test->omit * SEC_TO_US, 0); 352 if (test->omit_timer == NULL) { 353 i_errno = IEINITTEST; 354 return -1; 355 } 356 } 357 358 return 0; 359 } 360 361 static void 362 cleanup_server(struct iperf_test *test) 363 { 364 struct iperf_stream *sp; 365 366 /* Close open streams */ 367 SLIST_FOREACH(sp, &test->streams, streams) { 368 FD_CLR(sp->socket, &test->read_set); 369 FD_CLR(sp->socket, &test->write_set); 370 close(sp->socket); 371 } 372 373 /* Close open test sockets */ 374 if (test->ctrl_sck) { 375 close(test->ctrl_sck); 376 } 377 if (test->listener) { 378 close(test->listener); 379 } 380 if (test->prot_listener > -1) { // May remain open if create socket failed 381 close(test->prot_listener); 382 } 383 384 /* Cancel any remaining timers. */ 385 if (test->stats_timer != NULL) { 386 tmr_cancel(test->stats_timer); 387 test->stats_timer = NULL; 388 } 389 if (test->reporter_timer != NULL) { 390 tmr_cancel(test->reporter_timer); 391 test->reporter_timer = NULL; 392 } 393 if (test->omit_timer != NULL) { 394 tmr_cancel(test->omit_timer); 395 test->omit_timer = NULL; 396 } 397 if (test->congestion_used != NULL) { 398 free(test->congestion_used); 399 test->congestion_used = NULL; 400 } 401 if (test->timer != NULL) { 402 tmr_cancel(test->timer); 403 test->timer = NULL; 404 } 405 } 406 407 408 int 409 iperf_run_server(struct iperf_test *test) 410 { 411 int result, s; 412 int send_streams_accepted, rec_streams_accepted; 413 int streams_to_send = 0, streams_to_rec = 0; 414 #if defined(HAVE_TCP_CONGESTION) 415 int saved_errno; 416 #endif /* HAVE_TCP_CONGESTION */ 417 fd_set read_set, write_set; 418 struct iperf_stream *sp; 419 struct iperf_time now; 420 struct timeval* timeout; 421 int flag; 422 423 if (test->logfile) 424 if (iperf_open_logfile(test) < 0) 425 return -1; 426 427 if (test->affinity != -1) 428 if (iperf_setaffinity(test, test->affinity) != 0) 429 return -2; 430 431 if (test->json_output) 432 if (iperf_json_start(test) < 0) 433 return -2; 434 435 if (test->json_output) { 436 cJSON_AddItemToObject(test->json_start, "version", cJSON_CreateString(version)); 437 cJSON_AddItemToObject(test->json_start, "system_info", cJSON_CreateString(get_system_info())); 438 } else if (test->verbose) { 439 iperf_printf(test, "%s\n", version); 440 iperf_printf(test, "%s", ""); 441 iperf_printf(test, "%s\n", get_system_info()); 442 iflush(test); 443 } 444 445 // Open socket and listen 446 if (iperf_server_listen(test) < 0) { 447 return -2; 448 } 449 450 test->state = IPERF_START; 451 send_streams_accepted = 0; 452 rec_streams_accepted = 0; 453 454 while (test->state != IPERF_DONE) { 455 456 // Check if average transfer rate was exceeded (condition set in the callback routines) 457 if (test->bitrate_limit_exceeded) { 458 cleanup_server(test); 459 i_errno = IETOTALRATE; 460 return -1; 461 } 462 463 memcpy(&read_set, &test->read_set, sizeof(fd_set)); 464 memcpy(&write_set, &test->write_set, sizeof(fd_set)); 465 466 iperf_time_now(&now); 467 timeout = tmr_timeout(&now); 468 result = select(test->max_fd + 1, &read_set, &write_set, NULL, timeout); 469 470 if (result < 0 && errno != EINTR) { 471 cleanup_server(test); 472 i_errno = IESELECT; 473 return -1; 474 } 475 if (result > 0) { 476 if (FD_ISSET(test->listener, &read_set)) { 477 if (test->state != CREATE_STREAMS) { 478 if (iperf_accept(test) < 0) { 479 cleanup_server(test); 480 return -1; 481 } 482 FD_CLR(test->listener, &read_set); 483 484 // Set streams number 485 if (test->mode == BIDIRECTIONAL) { 486 streams_to_send = test->num_streams; 487 streams_to_rec = test->num_streams; 488 } else if (test->mode == RECEIVER) { 489 streams_to_rec = test->num_streams; 490 streams_to_send = 0; 491 } else { 492 streams_to_send = test->num_streams; 493 streams_to_rec = 0; 494 } 495 } 496 } 497 if (FD_ISSET(test->ctrl_sck, &read_set)) { 498 if (iperf_handle_message_server(test) < 0) { 499 cleanup_server(test); 500 return -1; 501 } 502 FD_CLR(test->ctrl_sck, &read_set); 503 } 504 505 if (test->state == CREATE_STREAMS) { 506 if (FD_ISSET(test->prot_listener, &read_set)) { 507 508 if ((s = test->protocol->accept(test)) < 0) { 509 cleanup_server(test); 510 return -1; 511 } 512 513 #if defined(HAVE_TCP_CONGESTION) 514 if (test->protocol->id == Ptcp) { 515 if (test->congestion) { 516 if (setsockopt(s, IPPROTO_TCP, TCP_CONGESTION, test->congestion, strlen(test->congestion)) < 0) { 517 /* 518 * ENOENT means we tried to set the 519 * congestion algorithm but the algorithm 520 * specified doesn't exist. This can happen 521 * if the client and server have different 522 * congestion algorithms available. In this 523 * case, print a warning, but otherwise 524 * continue. 525 */ 526 if (errno == ENOENT) { 527 warning("TCP congestion control algorithm not supported"); 528 } 529 else { 530 saved_errno = errno; 531 close(s); 532 cleanup_server(test); 533 errno = saved_errno; 534 i_errno = IESETCONGESTION; 535 return -1; 536 } 537 } 538 } 539 { 540 socklen_t len = TCP_CA_NAME_MAX; 541 char ca[TCP_CA_NAME_MAX + 1]; 542 if (getsockopt(s, IPPROTO_TCP, TCP_CONGESTION, ca, &len) < 0) { 543 saved_errno = errno; 544 close(s); 545 cleanup_server(test); 546 errno = saved_errno; 547 i_errno = IESETCONGESTION; 548 return -1; 549 } 550 test->congestion_used = strdup(ca); 551 if (test->debug) { 552 printf("Congestion algorithm is %s\n", test->congestion_used); 553 } 554 } 555 } 556 #endif /* HAVE_TCP_CONGESTION */ 557 558 if (!is_closed(s)) { 559 560 if (rec_streams_accepted != streams_to_rec) { 561 flag = 0; 562 ++rec_streams_accepted; 563 } else if (send_streams_accepted != streams_to_send) { 564 flag = 1; 565 ++send_streams_accepted; 566 } 567 568 if (flag != -1) { 569 sp = iperf_new_stream(test, s, flag); 570 if (!sp) { 571 cleanup_server(test); 572 return -1; 573 } 574 575 if (sp->sender) 576 FD_SET(s, &test->write_set); 577 else 578 FD_SET(s, &test->read_set); 579 580 if (s > test->max_fd) test->max_fd = s; 581 582 /* 583 * If the protocol isn't UDP, or even if it is but 584 * we're the receiver, set nonblocking sockets. 585 * We need this to allow a server receiver to 586 * maintain interactivity with the control channel. 587 */ 588 if (test->protocol->id != Pudp || 589 !sp->sender) { 590 setnonblocking(s, 1); 591 } 592 593 if (test->on_new_stream) 594 test->on_new_stream(sp); 595 596 flag = -1; 597 } 598 } 599 FD_CLR(test->prot_listener, &read_set); 600 } 601 602 603 if (rec_streams_accepted == streams_to_rec && send_streams_accepted == streams_to_send) { 604 if (test->protocol->id != Ptcp) { 605 FD_CLR(test->prot_listener, &test->read_set); 606 close(test->prot_listener); 607 } else { 608 if (test->no_delay || test->settings->mss || test->settings->socket_bufsize) { 609 FD_CLR(test->listener, &test->read_set); 610 close(test->listener); 611 test->listener = 0; 612 if ((s = netannounce(test->settings->domain, Ptcp, test->bind_address, test->bind_dev, test->server_port)) < 0) { 613 cleanup_server(test); 614 i_errno = IELISTEN; 615 return -1; 616 } 617 test->listener = s; 618 FD_SET(test->listener, &test->read_set); 619 if (test->listener > test->max_fd) test->max_fd = test->listener; 620 } 621 } 622 test->prot_listener = -1; 623 624 /* Ensure that total requested data rate is not above limit */ 625 iperf_size_t total_requested_rate = test->num_streams * test->settings->rate * (test->mode == BIDIRECTIONAL? 2 : 1); 626 if (test->settings->bitrate_limit > 0 && total_requested_rate > test->settings->bitrate_limit) { 627 iperf_err(test, "Client total requested throughput rate of %" PRIu64 " bps exceeded %" PRIu64 " bps limit", 628 total_requested_rate, test->settings->bitrate_limit); 629 cleanup_server(test); 630 i_errno = IETOTALRATE; 631 return -1; 632 } 633 634 // Begin calculating CPU utilization 635 cpu_util(NULL); 636 637 if (iperf_set_send_state(test, TEST_START) != 0) { 638 cleanup_server(test); 639 return -1; 640 } 641 if (iperf_init_test(test) < 0) { 642 cleanup_server(test); 643 return -1; 644 } 645 if (create_server_timers(test) < 0) { 646 cleanup_server(test); 647 return -1; 648 } 649 if (create_server_omit_timer(test) < 0) { 650 cleanup_server(test); 651 return -1; 652 } 653 if (test->mode != RECEIVER) 654 if (iperf_create_send_timers(test) < 0) { 655 cleanup_server(test); 656 return -1; 657 } 658 if (iperf_set_send_state(test, TEST_RUNNING) != 0) { 659 cleanup_server(test); 660 return -1; 661 } 662 } 663 } 664 665 if (test->state == TEST_RUNNING) { 666 if (test->mode == BIDIRECTIONAL) { 667 if (iperf_recv(test, &read_set) < 0) { 668 cleanup_server(test); 669 return -1; 670 } 671 if (iperf_send(test, &write_set) < 0) { 672 cleanup_server(test); 673 return -1; 674 } 675 } else if (test->mode == SENDER) { 676 // Reverse mode. Server sends. 677 if (iperf_send(test, &write_set) < 0) { 678 cleanup_server(test); 679 return -1; 680 } 681 } else { 682 // Regular mode. Server receives. 683 if (iperf_recv(test, &read_set) < 0) { 684 cleanup_server(test); 685 return -1; 686 } 687 } 688 } 689 } 690 691 if (result == 0 || 692 (timeout != NULL && timeout->tv_sec == 0 && timeout->tv_usec == 0)) { 693 /* Run the timers. */ 694 iperf_time_now(&now); 695 tmr_run(&now); 696 } 697 } 698 699 cleanup_server(test); 700 701 if (test->json_output) { 702 if (iperf_json_finish(test) < 0) 703 return -1; 704 } 705 706 iflush(test); 707 708 if (test->server_affinity != -1) 709 if (iperf_clearaffinity(test) != 0) 710 return -1; 711 712 return 0; 713 } 714