1 /* 2 * Copyright (c) 2009-2014, The Regents of the University of California, 3 * through Lawrence Berkeley National Laboratory (subject to receipt of any 4 * required approvals from the U.S. Dept. of Energy). All rights reserved. 5 * 6 * This code is distributed under a BSD style license, see the LICENSE file 7 * for complete information. 8 */ 9 10 #define _GNU_SOURCE 11 #define __USE_GNU 12 13 #include "iperf_config.h" 14 15 #include <stdio.h> 16 #include <stdlib.h> 17 #include <string.h> 18 #include <getopt.h> 19 #include <errno.h> 20 #include <signal.h> 21 #include <unistd.h> 22 #include <assert.h> 23 #include <fcntl.h> 24 #include <sys/socket.h> 25 #include <sys/types.h> 26 #include <netinet/in.h> 27 #include <arpa/inet.h> 28 #include <netdb.h> 29 #include <pthread.h> 30 #ifdef HAVE_STDINT_H 31 #include <stdint.h> 32 #endif 33 #include <netinet/tcp.h> 34 #include <sys/time.h> 35 #include <sys/resource.h> 36 #include <sys/mman.h> 37 #include <sys/stat.h> 38 #include <sched.h> 39 #include <setjmp.h> 40 #include <stdarg.h> 41 42 #if defined(HAVE_CPUSET_SETAFFINITY) 43 #include <sys/param.h> 44 #include <sys/cpuset.h> 45 #endif /* HAVE_CPUSET_SETAFFINITY */ 46 47 #include "net.h" 48 #include "iperf.h" 49 #include "iperf_api.h" 50 #include "iperf_udp.h" 51 #include "iperf_tcp.h" 52 #if defined(HAVE_SCTP) 53 #include "iperf_sctp.h" 54 #endif /* HAVE_SCTP */ 55 #include "timer.h" 56 57 #include "cjson.h" 58 #include "units.h" 59 #include "tcp_window_size.h" 60 #include "iperf_util.h" 61 #include "locale.h" 62 63 64 /* Forwards. */ 65 static int send_parameters(struct iperf_test *test); 66 static int get_parameters(struct iperf_test *test); 67 static int send_results(struct iperf_test *test); 68 static int get_results(struct iperf_test *test); 69 static int diskfile_send(struct iperf_stream *sp); 70 static int diskfile_recv(struct iperf_stream *sp); 71 static int JSON_write(int fd, cJSON *json); 72 static void print_interval_results(struct iperf_test *test, struct iperf_stream *sp, cJSON *json_interval_streams); 73 static cJSON *JSON_read(int fd); 74 75 76 /*************************** Print usage functions ****************************/ 77 78 void 79 usage() 80 { 81 fputs(usage_shortstr, stderr); 82 } 83 84 85 void 86 usage_long() 87 { 88 fprintf(stderr, usage_longstr, UDP_RATE / (1024*1024), DURATION, DEFAULT_TCP_BLKSIZE / 1024, DEFAULT_UDP_BLKSIZE / 1024); 89 } 90 91 92 void warning(char *str) 93 { 94 fprintf(stderr, "warning: %s\n", str); 95 } 96 97 98 /************** Getter routines for some fields inside iperf_test *************/ 99 100 int 101 iperf_get_verbose(struct iperf_test *ipt) 102 { 103 return ipt->verbose; 104 } 105 106 int 107 iperf_get_control_socket(struct iperf_test *ipt) 108 { 109 return ipt->ctrl_sck; 110 } 111 112 int 113 iperf_get_test_omit(struct iperf_test *ipt) 114 { 115 return ipt->omit; 116 } 117 118 int 119 iperf_get_test_duration(struct iperf_test *ipt) 120 { 121 return ipt->duration; 122 } 123 124 uint64_t 125 iperf_get_test_rate(struct iperf_test *ipt) 126 { 127 return ipt->settings->rate; 128 } 129 130 int 131 iperf_get_test_burst(struct iperf_test *ipt) 132 { 133 return ipt->settings->burst; 134 } 135 136 char 137 iperf_get_test_role(struct iperf_test *ipt) 138 { 139 return ipt->role; 140 } 141 142 int 143 iperf_get_test_reverse(struct iperf_test *ipt) 144 { 145 return ipt->reverse; 146 } 147 148 int 149 iperf_get_test_blksize(struct iperf_test *ipt) 150 { 151 return ipt->settings->blksize; 152 } 153 154 FILE * 155 iperf_get_test_outfile (struct iperf_test *ipt) 156 { 157 return ipt->outfile; 158 } 159 160 int 161 iperf_get_test_socket_bufsize(struct iperf_test *ipt) 162 { 163 return ipt->settings->socket_bufsize; 164 } 165 166 double 167 iperf_get_test_reporter_interval(struct iperf_test *ipt) 168 { 169 return ipt->reporter_interval; 170 } 171 172 double 173 iperf_get_test_stats_interval(struct iperf_test *ipt) 174 { 175 return ipt->stats_interval; 176 } 177 178 int 179 iperf_get_test_num_streams(struct iperf_test *ipt) 180 { 181 return ipt->num_streams; 182 } 183 184 int 185 iperf_get_test_server_port(struct iperf_test *ipt) 186 { 187 return ipt->server_port; 188 } 189 190 char* 191 iperf_get_test_server_hostname(struct iperf_test *ipt) 192 { 193 return ipt->server_hostname; 194 } 195 196 int 197 iperf_get_test_protocol_id(struct iperf_test *ipt) 198 { 199 return ipt->protocol->id; 200 } 201 202 int 203 iperf_get_test_json_output(struct iperf_test *ipt) 204 { 205 return ipt->json_output; 206 } 207 208 char * 209 iperf_get_test_json_output_string(struct iperf_test *ipt) 210 { 211 return ipt->json_output_string; 212 } 213 214 int 215 iperf_get_test_zerocopy(struct iperf_test *ipt) 216 { 217 return ipt->zerocopy; 218 } 219 220 char 221 iperf_get_test_unit_format(struct iperf_test *ipt) 222 { 223 return ipt->settings->unit_format; 224 } 225 226 /************** Setter routines for some fields inside iperf_test *************/ 227 228 void 229 iperf_set_verbose(struct iperf_test *ipt, int verbose) 230 { 231 ipt->verbose = verbose; 232 } 233 234 void 235 iperf_set_control_socket(struct iperf_test *ipt, int ctrl_sck) 236 { 237 ipt->ctrl_sck = ctrl_sck; 238 } 239 240 void 241 iperf_set_test_omit(struct iperf_test *ipt, int omit) 242 { 243 ipt->omit = omit; 244 } 245 246 void 247 iperf_set_test_duration(struct iperf_test *ipt, int duration) 248 { 249 ipt->duration = duration; 250 } 251 252 void 253 iperf_set_test_reporter_interval(struct iperf_test *ipt, double reporter_interval) 254 { 255 ipt->reporter_interval = reporter_interval; 256 } 257 258 void 259 iperf_set_test_stats_interval(struct iperf_test *ipt, double stats_interval) 260 { 261 ipt->stats_interval = stats_interval; 262 } 263 264 void 265 iperf_set_test_state(struct iperf_test *ipt, signed char state) 266 { 267 ipt->state = state; 268 } 269 270 void 271 iperf_set_test_blksize(struct iperf_test *ipt, int blksize) 272 { 273 ipt->settings->blksize = blksize; 274 } 275 276 void 277 iperf_set_test_rate(struct iperf_test *ipt, uint64_t rate) 278 { 279 ipt->settings->rate = rate; 280 } 281 282 void 283 iperf_set_test_burst(struct iperf_test *ipt, int burst) 284 { 285 ipt->settings->burst = burst; 286 } 287 288 void 289 iperf_set_test_server_port(struct iperf_test *ipt, int server_port) 290 { 291 ipt->server_port = server_port; 292 } 293 294 void 295 iperf_set_test_socket_bufsize(struct iperf_test *ipt, int socket_bufsize) 296 { 297 ipt->settings->socket_bufsize = socket_bufsize; 298 } 299 300 void 301 iperf_set_test_num_streams(struct iperf_test *ipt, int num_streams) 302 { 303 ipt->num_streams = num_streams; 304 } 305 306 static void 307 check_sender_has_retransmits(struct iperf_test *ipt) 308 { 309 if (ipt->sender && ipt->protocol->id == Ptcp && has_tcpinfo_retransmits()) 310 ipt->sender_has_retransmits = 1; 311 else 312 ipt->sender_has_retransmits = 0; 313 } 314 315 void 316 iperf_set_test_role(struct iperf_test *ipt, char role) 317 { 318 ipt->role = role; 319 if (role == 'c') 320 ipt->sender = 1; 321 else if (role == 's') 322 ipt->sender = 0; 323 if (ipt->reverse) 324 ipt->sender = ! ipt->sender; 325 check_sender_has_retransmits(ipt); 326 } 327 328 void 329 iperf_set_test_server_hostname(struct iperf_test *ipt, char *server_hostname) 330 { 331 ipt->server_hostname = strdup(server_hostname); 332 } 333 334 void 335 iperf_set_test_reverse(struct iperf_test *ipt, int reverse) 336 { 337 ipt->reverse = reverse; 338 if (ipt->reverse) 339 ipt->sender = ! ipt->sender; 340 check_sender_has_retransmits(ipt); 341 } 342 343 void 344 iperf_set_test_json_output(struct iperf_test *ipt, int json_output) 345 { 346 ipt->json_output = json_output; 347 } 348 349 int 350 iperf_has_zerocopy( void ) 351 { 352 return has_sendfile(); 353 } 354 355 void 356 iperf_set_test_zerocopy(struct iperf_test *ipt, int zerocopy) 357 { 358 ipt->zerocopy = zerocopy; 359 } 360 361 void 362 iperf_set_test_unit_format(struct iperf_test *ipt, char unit_format) 363 { 364 ipt->settings->unit_format = unit_format; 365 } 366 367 /********************** Get/set test protocol structure ***********************/ 368 369 struct protocol * 370 get_protocol(struct iperf_test *test, int prot_id) 371 { 372 struct protocol *prot; 373 374 SLIST_FOREACH(prot, &test->protocols, protocols) { 375 if (prot->id == prot_id) 376 break; 377 } 378 379 if (prot == NULL) 380 i_errno = IEPROTOCOL; 381 382 return prot; 383 } 384 385 int 386 set_protocol(struct iperf_test *test, int prot_id) 387 { 388 struct protocol *prot = NULL; 389 390 SLIST_FOREACH(prot, &test->protocols, protocols) { 391 if (prot->id == prot_id) { 392 test->protocol = prot; 393 check_sender_has_retransmits(test); 394 return 0; 395 } 396 } 397 398 i_errno = IEPROTOCOL; 399 return -1; 400 } 401 402 403 /************************** Iperf callback functions **************************/ 404 405 void 406 iperf_on_new_stream(struct iperf_stream *sp) 407 { 408 connect_msg(sp); 409 } 410 411 void 412 iperf_on_test_start(struct iperf_test *test) 413 { 414 if (test->json_output) { 415 cJSON_AddItemToObject(test->json_start, "test_start", iperf_json_printf("protocol: %s num_streams: %d blksize: %d omit: %d duration: %d bytes: %d blocks: %d reverse: %d", test->protocol->name, (int64_t) test->num_streams, (int64_t) test->settings->blksize, (int64_t) test->omit, (int64_t) test->duration, (int64_t) test->settings->bytes, (int64_t) test->settings->blocks, test->reverse?(int64_t)1:(int64_t)0)); 416 } else { 417 if (test->verbose) { 418 if (test->settings->bytes) 419 iprintf(test, test_start_bytes, test->protocol->name, test->num_streams, test->settings->blksize, test->omit, test->settings->bytes); 420 else if (test->settings->blocks) 421 iprintf(test, test_start_blocks, test->protocol->name, test->num_streams, test->settings->blksize, test->omit, test->settings->blocks); 422 else 423 iprintf(test, test_start_time, test->protocol->name, test->num_streams, test->settings->blksize, test->omit, test->duration); 424 } 425 } 426 } 427 428 /* This converts an IPv6 string address from IPv4-mapped format into regular 429 ** old IPv4 format, which is easier on the eyes of network veterans. 430 ** 431 ** If the v6 address is not v4-mapped it is left alone. 432 */ 433 static void 434 mapped_v4_to_regular_v4(char *str) 435 { 436 char *prefix = "::ffff:"; 437 int prefix_len; 438 439 prefix_len = strlen(prefix); 440 if (strncmp(str, prefix, prefix_len) == 0) { 441 int str_len = strlen(str); 442 memmove(str, str + prefix_len, str_len - prefix_len + 1); 443 } 444 } 445 446 void 447 iperf_on_connect(struct iperf_test *test) 448 { 449 time_t now_secs; 450 const char* rfc1123_fmt = "%a, %d %b %Y %H:%M:%S GMT"; 451 char now_str[100]; 452 char ipr[INET6_ADDRSTRLEN]; 453 int port; 454 struct sockaddr_storage sa; 455 struct sockaddr_in *sa_inP; 456 struct sockaddr_in6 *sa_in6P; 457 socklen_t len; 458 int opt; 459 460 now_secs = time((time_t*) 0); 461 (void) strftime(now_str, sizeof(now_str), rfc1123_fmt, gmtime(&now_secs)); 462 if (test->json_output) 463 cJSON_AddItemToObject(test->json_start, "timestamp", iperf_json_printf("time: %s timesecs: %d", now_str, (int64_t) now_secs)); 464 else if (test->verbose) 465 iprintf(test, report_time, now_str); 466 467 if (test->role == 'c') { 468 if (test->json_output) 469 cJSON_AddItemToObject(test->json_start, "connecting_to", iperf_json_printf("host: %s port: %d", test->server_hostname, (int64_t) test->server_port)); 470 else { 471 iprintf(test, report_connecting, test->server_hostname, test->server_port); 472 if (test->reverse) 473 iprintf(test, report_reverse, test->server_hostname); 474 } 475 } else { 476 len = sizeof(sa); 477 getpeername(test->ctrl_sck, (struct sockaddr *) &sa, &len); 478 if (getsockdomain(test->ctrl_sck) == AF_INET) { 479 sa_inP = (struct sockaddr_in *) &sa; 480 inet_ntop(AF_INET, &sa_inP->sin_addr, ipr, sizeof(ipr)); 481 port = ntohs(sa_inP->sin_port); 482 } else { 483 sa_in6P = (struct sockaddr_in6 *) &sa; 484 inet_ntop(AF_INET6, &sa_in6P->sin6_addr, ipr, sizeof(ipr)); 485 port = ntohs(sa_in6P->sin6_port); 486 } 487 mapped_v4_to_regular_v4(ipr); 488 if (test->json_output) 489 cJSON_AddItemToObject(test->json_start, "accepted_connection", iperf_json_printf("host: %s port: %d", ipr, (int64_t) port)); 490 else 491 iprintf(test, report_accepted, ipr, port); 492 } 493 if (test->json_output) { 494 cJSON_AddStringToObject(test->json_start, "cookie", test->cookie); 495 if (test->protocol->id == SOCK_STREAM) { 496 if (test->settings->mss) 497 cJSON_AddIntToObject(test->json_start, "tcp_mss", test->settings->mss); 498 else { 499 len = sizeof(opt); 500 getsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_MAXSEG, &opt, &len); 501 cJSON_AddIntToObject(test->json_start, "tcp_mss_default", opt); 502 } 503 } 504 } else if (test->verbose) { 505 iprintf(test, report_cookie, test->cookie); 506 if (test->protocol->id == SOCK_STREAM) { 507 if (test->settings->mss) 508 iprintf(test, " TCP MSS: %d\n", test->settings->mss); 509 else { 510 len = sizeof(opt); 511 getsockopt(test->ctrl_sck, IPPROTO_TCP, TCP_MAXSEG, &opt, &len); 512 iprintf(test, " TCP MSS: %d (default)\n", opt); 513 } 514 } 515 516 } 517 } 518 519 void 520 iperf_on_test_finish(struct iperf_test *test) 521 { 522 } 523 524 525 /******************************************************************************/ 526 527 int 528 iperf_parse_arguments(struct iperf_test *test, int argc, char **argv) 529 { 530 static struct option longopts[] = 531 { 532 {"port", required_argument, NULL, 'p'}, 533 {"format", required_argument, NULL, 'f'}, 534 {"interval", required_argument, NULL, 'i'}, 535 {"daemon", no_argument, NULL, 'D'}, 536 {"verbose", no_argument, NULL, 'V'}, 537 {"json", no_argument, NULL, 'J'}, 538 {"version", no_argument, NULL, 'v'}, 539 {"server", no_argument, NULL, 's'}, 540 {"client", required_argument, NULL, 'c'}, 541 {"udp", no_argument, NULL, 'u'}, 542 {"bandwidth", required_argument, NULL, 'b'}, 543 {"time", required_argument, NULL, 't'}, 544 {"bytes", required_argument, NULL, 'n'}, 545 {"blockcount", required_argument, NULL, 'k'}, 546 {"length", required_argument, NULL, 'l'}, 547 {"parallel", required_argument, NULL, 'P'}, 548 {"reverse", no_argument, NULL, 'R'}, 549 {"window", required_argument, NULL, 'w'}, 550 {"bind", required_argument, NULL, 'B'}, 551 {"set-mss", required_argument, NULL, 'M'}, 552 {"no-delay", no_argument, NULL, 'N'}, 553 {"version4", no_argument, NULL, '4'}, 554 {"version6", no_argument, NULL, '6'}, 555 {"tos", required_argument, NULL, 'S'}, 556 #if defined(HAVE_FLOWLABEL) 557 {"flowlabel", required_argument, NULL, 'L'}, 558 #endif /* HAVE_FLOWLABEL */ 559 {"zerocopy", no_argument, NULL, 'Z'}, 560 {"omit", required_argument, NULL, 'O'}, 561 {"file", required_argument, NULL, 'F'}, 562 #if defined(HAVE_CPU_AFFINITY) 563 {"affinity", required_argument, NULL, 'A'}, 564 #endif /* HAVE_CPU_AFFINITY */ 565 {"title", required_argument, NULL, 'T'}, 566 #if defined(HAVE_TCP_CONGESTION) 567 {"congestion", required_argument, NULL, 'C'}, 568 {"linux-congestion", required_argument, NULL, 'C'}, 569 #endif /* HAVE_TCP_CONGESTION */ 570 #if defined(HAVE_SCTP) 571 {"sctp", no_argument, NULL, OPT_SCTP}, 572 #endif 573 {"pidfile", required_argument, NULL, 'I'}, 574 {"logfile", required_argument, NULL, OPT_LOGFILE}, 575 {"debug", no_argument, NULL, 'd'}, 576 {"help", no_argument, NULL, 'h'}, 577 {NULL, 0, NULL, 0} 578 }; 579 int flag; 580 int blksize; 581 int server_flag, client_flag, rate_flag, duration_flag; 582 #if defined(HAVE_CPU_AFFINITY) 583 char* comma; 584 #endif /* HAVE_CPU_AFFINITY */ 585 char* slash; 586 587 blksize = 0; 588 server_flag = client_flag = rate_flag = duration_flag = 0; 589 while ((flag = getopt_long(argc, argv, "p:f:i:DVJvsc:ub:t:n:k:l:P:Rw:B:M:N46S:L:ZO:F:A:T:C:dI:h", longopts, NULL)) != -1) { 590 switch (flag) { 591 case 'p': 592 test->server_port = atoi(optarg); 593 break; 594 case 'f': 595 test->settings->unit_format = *optarg; 596 break; 597 case 'i': 598 /* XXX: could potentially want separate stat collection and reporting intervals, 599 but just set them to be the same for now */ 600 test->stats_interval = test->reporter_interval = atof(optarg); 601 if ((test->stats_interval < MIN_INTERVAL || test->stats_interval > MAX_INTERVAL) && test->stats_interval != 0) { 602 i_errno = IEINTERVAL; 603 return -1; 604 } 605 break; 606 case 'D': 607 test->daemon = 1; 608 server_flag = 1; 609 break; 610 case 'V': 611 test->verbose = 1; 612 break; 613 case 'J': 614 test->json_output = 1; 615 break; 616 case 'v': 617 printf("%s\n%s\n%s\n", version, get_system_info(), 618 get_optional_features()); 619 exit(0); 620 case 's': 621 if (test->role == 'c') { 622 i_errno = IESERVCLIENT; 623 return -1; 624 } 625 iperf_set_test_role(test, 's'); 626 break; 627 case 'c': 628 if (test->role == 's') { 629 i_errno = IESERVCLIENT; 630 return -1; 631 } 632 iperf_set_test_role(test, 'c'); 633 iperf_set_test_server_hostname(test, optarg); 634 break; 635 case 'u': 636 set_protocol(test, Pudp); 637 client_flag = 1; 638 break; 639 case OPT_SCTP: 640 #if defined(HAVE_SCTP) 641 set_protocol(test, Psctp); 642 client_flag = 1; 643 #else /* HAVE_SCTP */ 644 i_errno = IEUNIMP; 645 return -1; 646 #endif /* HAVE_SCTP */ 647 break; 648 649 case 'b': 650 slash = strchr(optarg, '/'); 651 if (slash) { 652 *slash = '\0'; 653 ++slash; 654 test->settings->burst = atoi(slash); 655 if (test->settings->burst <= 0 || 656 test->settings->burst > MAX_BURST) { 657 i_errno = IEBURST; 658 return -1; 659 } 660 } 661 test->settings->rate = unit_atof(optarg); 662 rate_flag = 1; 663 client_flag = 1; 664 break; 665 case 't': 666 test->duration = atoi(optarg); 667 if (test->duration > MAX_TIME) { 668 i_errno = IEDURATION; 669 return -1; 670 } 671 duration_flag = 1; 672 client_flag = 1; 673 break; 674 case 'n': 675 test->settings->bytes = unit_atoi(optarg); 676 client_flag = 1; 677 break; 678 case 'k': 679 test->settings->blocks = unit_atoi(optarg); 680 client_flag = 1; 681 break; 682 case 'l': 683 blksize = unit_atoi(optarg); 684 client_flag = 1; 685 break; 686 case 'P': 687 test->num_streams = atoi(optarg); 688 if (test->num_streams > MAX_STREAMS) { 689 i_errno = IENUMSTREAMS; 690 return -1; 691 } 692 client_flag = 1; 693 break; 694 case 'R': 695 iperf_set_test_reverse(test, 1); 696 client_flag = 1; 697 break; 698 case 'w': 699 // XXX: This is a socket buffer, not specific to TCP 700 test->settings->socket_bufsize = unit_atof(optarg); 701 if (test->settings->socket_bufsize > MAX_TCP_BUFFER) { 702 i_errno = IEBUFSIZE; 703 return -1; 704 } 705 client_flag = 1; 706 break; 707 case 'B': 708 test->bind_address = strdup(optarg); 709 break; 710 case 'M': 711 test->settings->mss = atoi(optarg); 712 if (test->settings->mss > MAX_MSS) { 713 i_errno = IEMSS; 714 return -1; 715 } 716 client_flag = 1; 717 break; 718 case 'N': 719 test->no_delay = 1; 720 client_flag = 1; 721 break; 722 case '4': 723 test->settings->domain = AF_INET; 724 break; 725 case '6': 726 test->settings->domain = AF_INET6; 727 break; 728 case 'S': 729 test->settings->tos = strtol(optarg, NULL, 0); 730 client_flag = 1; 731 break; 732 case 'L': 733 #if defined(HAVE_FLOWLABEL) 734 test->settings->flowlabel = strtol(optarg, NULL, 0); 735 if (test->settings->flowlabel < 1 || test->settings->flowlabel > 0xfffff) { 736 i_errno = IESETFLOW; 737 return -1; 738 } 739 client_flag = 1; 740 #else /* HAVE_FLOWLABEL */ 741 i_errno = IEUNIMP; 742 return -1; 743 #endif /* HAVE_FLOWLABEL */ 744 break; 745 case 'Z': 746 if (!has_sendfile()) { 747 i_errno = IENOSENDFILE; 748 return -1; 749 } 750 test->zerocopy = 1; 751 client_flag = 1; 752 break; 753 case 'O': 754 test->omit = atoi(optarg); 755 if (test->omit < 0 || test->omit > 60) { 756 i_errno = IEOMIT; 757 return -1; 758 } 759 client_flag = 1; 760 break; 761 case 'F': 762 test->diskfile_name = optarg; 763 break; 764 case 'A': 765 #if defined(HAVE_CPU_AFFINITY) 766 test->affinity = atoi(optarg); 767 if (test->affinity < 0 || test->affinity > 1024) { 768 i_errno = IEAFFINITY; 769 return -1; 770 } 771 comma = strchr(optarg, ','); 772 if (comma != NULL) { 773 test->server_affinity = atoi(comma+1); 774 if (test->server_affinity < 0 || test->server_affinity > 1024) { 775 i_errno = IEAFFINITY; 776 return -1; 777 } 778 client_flag = 1; 779 } 780 #else /* HAVE_CPU_AFFINITY */ 781 i_errno = IEUNIMP; 782 return -1; 783 #endif /* HAVE_CPU_AFFINITY */ 784 break; 785 case 'T': 786 test->title = strdup(optarg); 787 client_flag = 1; 788 break; 789 case 'C': 790 #if defined(HAVE_TCP_CONGESTION) 791 test->congestion = strdup(optarg); 792 client_flag = 1; 793 #else /* HAVE_TCP_CONGESTION */ 794 i_errno = IEUNIMP; 795 return -1; 796 #endif /* HAVE_TCP_CONGESTION */ 797 break; 798 case 'd': 799 test->debug = 1; 800 break; 801 case 'I': 802 test->pidfile = strdup(optarg); 803 server_flag = 1; 804 break; 805 case OPT_LOGFILE: 806 test->logfile = strdup(optarg); 807 break; 808 case 'h': 809 default: 810 usage_long(); 811 exit(1); 812 } 813 } 814 815 /* Set logging to a file if specified, otherwise use the default (stdout) */ 816 if (test->logfile) { 817 test->outfile = fopen(test->logfile, "a+"); 818 if (test->outfile == NULL) { 819 i_errno = IELOGFILE; 820 return -1; 821 } 822 } 823 824 /* Check flag / role compatibility. */ 825 if (test->role == 'c' && server_flag) { 826 i_errno = IESERVERONLY; 827 return -1; 828 } 829 if (test->role == 's' && client_flag) { 830 i_errno = IECLIENTONLY; 831 return -1; 832 } 833 834 if (blksize == 0) { 835 if (test->protocol->id == Pudp) 836 blksize = DEFAULT_UDP_BLKSIZE; 837 else if (test->protocol->id == Psctp) 838 blksize = DEFAULT_SCTP_BLKSIZE; 839 else 840 blksize = DEFAULT_TCP_BLKSIZE; 841 } 842 if (blksize <= 0 || blksize > MAX_BLOCKSIZE) { 843 i_errno = IEBLOCKSIZE; 844 return -1; 845 } 846 test->settings->blksize = blksize; 847 848 if (!rate_flag) 849 test->settings->rate = test->protocol->id == Pudp ? UDP_RATE : 0; 850 851 if ((test->settings->bytes != 0 || test->settings->blocks != 0) && ! duration_flag) 852 test->duration = 0; 853 854 /* Disallow specifying multiple test end conditions. The code actually 855 ** works just fine without this prohibition. As soon as any one of the 856 ** three possible end conditions is met, the test ends. So this check 857 ** could be removed if desired. 858 */ 859 if ((duration_flag && test->settings->bytes != 0) || 860 (duration_flag && test->settings->blocks != 0) || 861 (test->settings->bytes != 0 && test->settings->blocks != 0)) { 862 i_errno = IEENDCONDITIONS; 863 return -1; 864 } 865 866 /* For subsequent calls to getopt */ 867 #ifdef __APPLE__ 868 optreset = 1; 869 #endif 870 optind = 0; 871 872 if ((test->role != 'c') && (test->role != 's')) { 873 i_errno = IENOROLE; 874 return -1; 875 } 876 877 return 0; 878 } 879 880 int 881 iperf_set_send_state(struct iperf_test *test, signed char state) 882 { 883 test->state = state; 884 if (Nwrite(test->ctrl_sck, (char*) &state, sizeof(state), Ptcp) < 0) { 885 i_errno = IESENDMESSAGE; 886 return -1; 887 } 888 return 0; 889 } 890 891 void 892 iperf_check_throttle(struct iperf_stream *sp, struct timeval *nowP) 893 { 894 double seconds; 895 uint64_t bits_per_second; 896 897 if (sp->test->done) 898 return; 899 seconds = timeval_diff(&sp->result->start_time, nowP); 900 bits_per_second = sp->result->bytes_sent * 8 / seconds; 901 if (bits_per_second < sp->test->settings->rate) { 902 sp->green_light = 1; 903 FD_SET(sp->socket, &sp->test->write_set); 904 } else { 905 sp->green_light = 0; 906 FD_CLR(sp->socket, &sp->test->write_set); 907 } 908 } 909 910 int 911 iperf_send(struct iperf_test *test, fd_set *write_setP) 912 { 913 register int multisend, r; 914 register struct iperf_stream *sp; 915 struct timeval now; 916 917 /* Can we do multisend mode? */ 918 if (test->settings->burst != 0) 919 multisend = test->settings->burst; 920 else if (test->settings->rate == 0) 921 multisend = test->multisend; 922 else 923 multisend = 1; /* nope */ 924 925 for (; multisend > 0; --multisend) { 926 if (test->settings->rate != 0 && test->settings->burst == 0) 927 gettimeofday(&now, NULL); 928 SLIST_FOREACH(sp, &test->streams, streams) { 929 if (sp->green_light && 930 (write_setP == NULL || FD_ISSET(sp->socket, write_setP))) { 931 if ((r = sp->snd(sp)) < 0) { 932 if (r == NET_SOFTERROR) 933 break; 934 i_errno = IESTREAMWRITE; 935 return r; 936 } 937 test->bytes_sent += r; 938 ++test->blocks_sent; 939 if (test->settings->rate != 0 && test->settings->burst == 0) 940 iperf_check_throttle(sp, &now); 941 if (multisend > 1 && test->settings->bytes != 0 && test->bytes_sent >= test->settings->bytes) 942 break; 943 if (multisend > 1 && test->settings->blocks != 0 && test->blocks_sent >= test->settings->blocks) 944 break; 945 } 946 } 947 } 948 if (test->settings->burst != 0) { 949 gettimeofday(&now, NULL); 950 SLIST_FOREACH(sp, &test->streams, streams) 951 iperf_check_throttle(sp, &now); 952 } 953 if (write_setP != NULL) 954 SLIST_FOREACH(sp, &test->streams, streams) 955 if (FD_ISSET(sp->socket, write_setP)) 956 FD_CLR(sp->socket, write_setP); 957 958 return 0; 959 } 960 961 int 962 iperf_recv(struct iperf_test *test, fd_set *read_setP) 963 { 964 int r; 965 struct iperf_stream *sp; 966 967 SLIST_FOREACH(sp, &test->streams, streams) { 968 if (FD_ISSET(sp->socket, read_setP)) { 969 if ((r = sp->rcv(sp)) < 0) { 970 i_errno = IESTREAMREAD; 971 return r; 972 } 973 test->bytes_sent += r; 974 ++test->blocks_sent; 975 FD_CLR(sp->socket, read_setP); 976 } 977 } 978 979 return 0; 980 } 981 982 int 983 iperf_init_test(struct iperf_test *test) 984 { 985 struct timeval now; 986 struct iperf_stream *sp; 987 988 if (test->protocol->init) { 989 if (test->protocol->init(test) < 0) 990 return -1; 991 } 992 993 /* Init each stream. */ 994 if (gettimeofday(&now, NULL) < 0) { 995 i_errno = IEINITTEST; 996 return -1; 997 } 998 SLIST_FOREACH(sp, &test->streams, streams) { 999 sp->result->start_time = now; 1000 } 1001 1002 if (test->on_test_start) 1003 test->on_test_start(test); 1004 1005 return 0; 1006 } 1007 1008 static void 1009 send_timer_proc(TimerClientData client_data, struct timeval *nowP) 1010 { 1011 struct iperf_stream *sp = client_data.p; 1012 1013 /* All we do here is set or clear the flag saying that this stream may 1014 ** be sent to. The actual sending gets done in the send proc, after 1015 ** checking the flag. 1016 */ 1017 iperf_check_throttle(sp, nowP); 1018 } 1019 1020 int 1021 iperf_create_send_timers(struct iperf_test * test) 1022 { 1023 struct timeval now; 1024 struct iperf_stream *sp; 1025 TimerClientData cd; 1026 1027 if (gettimeofday(&now, NULL) < 0) { 1028 i_errno = IEINITTEST; 1029 return -1; 1030 } 1031 SLIST_FOREACH(sp, &test->streams, streams) { 1032 sp->green_light = 1; 1033 if (test->settings->rate != 0) { 1034 cd.p = sp; 1035 sp->send_timer = tmr_create((struct timeval*) 0, send_timer_proc, cd, 100000L, 1); 1036 /* (Repeat every tenth second - arbitrary often value.) */ 1037 if (sp->send_timer == NULL) { 1038 i_errno = IEINITTEST; 1039 return -1; 1040 } 1041 } 1042 } 1043 return 0; 1044 } 1045 1046 /** 1047 * iperf_exchange_parameters - handles the param_Exchange part for client 1048 * 1049 */ 1050 1051 int 1052 iperf_exchange_parameters(struct iperf_test *test) 1053 { 1054 int s; 1055 int32_t err; 1056 1057 if (test->role == 'c') { 1058 1059 if (send_parameters(test) < 0) 1060 return -1; 1061 1062 } else { 1063 1064 if (get_parameters(test) < 0) 1065 return -1; 1066 1067 if ((s = test->protocol->listen(test)) < 0) { 1068 if (iperf_set_send_state(test, SERVER_ERROR) != 0) 1069 return -1; 1070 err = htonl(i_errno); 1071 if (Nwrite(test->ctrl_sck, (char*) &err, sizeof(err), Ptcp) < 0) { 1072 i_errno = IECTRLWRITE; 1073 return -1; 1074 } 1075 err = htonl(errno); 1076 if (Nwrite(test->ctrl_sck, (char*) &err, sizeof(err), Ptcp) < 0) { 1077 i_errno = IECTRLWRITE; 1078 return -1; 1079 } 1080 return -1; 1081 } 1082 FD_SET(s, &test->read_set); 1083 test->max_fd = (s > test->max_fd) ? s : test->max_fd; 1084 test->prot_listener = s; 1085 1086 // Send the control message to create streams and start the test 1087 if (iperf_set_send_state(test, CREATE_STREAMS) != 0) 1088 return -1; 1089 1090 } 1091 1092 return 0; 1093 } 1094 1095 /*************************************************************/ 1096 1097 int 1098 iperf_exchange_results(struct iperf_test *test) 1099 { 1100 if (test->role == 'c') { 1101 /* Send results to server. */ 1102 if (send_results(test) < 0) 1103 return -1; 1104 /* Get server results. */ 1105 if (get_results(test) < 0) 1106 return -1; 1107 } else { 1108 /* Get client results. */ 1109 if (get_results(test) < 0) 1110 return -1; 1111 /* Send results to client. */ 1112 if (send_results(test) < 0) 1113 return -1; 1114 } 1115 return 0; 1116 } 1117 1118 /*************************************************************/ 1119 1120 static int 1121 send_parameters(struct iperf_test *test) 1122 { 1123 int r = 0; 1124 cJSON *j; 1125 1126 j = cJSON_CreateObject(); 1127 if (j == NULL) { 1128 i_errno = IESENDPARAMS; 1129 r = -1; 1130 } else { 1131 if (test->protocol->id == Ptcp) 1132 cJSON_AddTrueToObject(j, "tcp"); 1133 else if (test->protocol->id == Pudp) 1134 cJSON_AddTrueToObject(j, "udp"); 1135 else if (test->protocol->id == Psctp) 1136 cJSON_AddTrueToObject(j, "sctp"); 1137 cJSON_AddIntToObject(j, "omit", test->omit); 1138 if (test->server_affinity != -1) 1139 cJSON_AddIntToObject(j, "server_affinity", test->server_affinity); 1140 if (test->duration) 1141 cJSON_AddIntToObject(j, "time", test->duration); 1142 if (test->settings->bytes) 1143 cJSON_AddIntToObject(j, "num", test->settings->bytes); 1144 if (test->settings->blocks) 1145 cJSON_AddIntToObject(j, "blockcount", test->settings->blocks); 1146 if (test->settings->mss) 1147 cJSON_AddIntToObject(j, "MSS", test->settings->mss); 1148 if (test->no_delay) 1149 cJSON_AddTrueToObject(j, "nodelay"); 1150 cJSON_AddIntToObject(j, "parallel", test->num_streams); 1151 if (test->reverse) 1152 cJSON_AddTrueToObject(j, "reverse"); 1153 if (test->settings->socket_bufsize) 1154 cJSON_AddIntToObject(j, "window", test->settings->socket_bufsize); 1155 if (test->settings->blksize) 1156 cJSON_AddIntToObject(j, "len", test->settings->blksize); 1157 if (test->settings->rate) 1158 cJSON_AddIntToObject(j, "bandwidth", test->settings->rate); 1159 if (test->settings->burst) 1160 cJSON_AddIntToObject(j, "burst", test->settings->burst); 1161 if (test->settings->tos) 1162 cJSON_AddIntToObject(j, "TOS", test->settings->tos); 1163 if (test->settings->flowlabel) 1164 cJSON_AddIntToObject(j, "flowlabel", test->settings->flowlabel); 1165 if (test->title) 1166 cJSON_AddStringToObject(j, "title", test->title); 1167 if (test->congestion) 1168 cJSON_AddStringToObject(j, "congestion", test->congestion); 1169 if (JSON_write(test->ctrl_sck, j) < 0) { 1170 i_errno = IESENDPARAMS; 1171 r = -1; 1172 } 1173 cJSON_Delete(j); 1174 } 1175 return r; 1176 } 1177 1178 /*************************************************************/ 1179 1180 static int 1181 get_parameters(struct iperf_test *test) 1182 { 1183 int r = 0; 1184 cJSON *j; 1185 cJSON *j_p; 1186 1187 j = JSON_read(test->ctrl_sck); 1188 if (j == NULL) { 1189 i_errno = IERECVPARAMS; 1190 r = -1; 1191 } else { 1192 if ((j_p = cJSON_GetObjectItem(j, "tcp")) != NULL) 1193 set_protocol(test, Ptcp); 1194 if ((j_p = cJSON_GetObjectItem(j, "udp")) != NULL) 1195 set_protocol(test, Pudp); 1196 if ((j_p = cJSON_GetObjectItem(j, "sctp")) != NULL) 1197 set_protocol(test, Psctp); 1198 if ((j_p = cJSON_GetObjectItem(j, "omit")) != NULL) 1199 test->omit = j_p->valueint; 1200 if ((j_p = cJSON_GetObjectItem(j, "server_affinity")) != NULL) 1201 test->server_affinity = j_p->valueint; 1202 if ((j_p = cJSON_GetObjectItem(j, "time")) != NULL) 1203 test->duration = j_p->valueint; 1204 if ((j_p = cJSON_GetObjectItem(j, "num")) != NULL) 1205 test->settings->bytes = j_p->valueint; 1206 if ((j_p = cJSON_GetObjectItem(j, "blockcount")) != NULL) 1207 test->settings->blocks = j_p->valueint; 1208 if ((j_p = cJSON_GetObjectItem(j, "MSS")) != NULL) 1209 test->settings->mss = j_p->valueint; 1210 if ((j_p = cJSON_GetObjectItem(j, "nodelay")) != NULL) 1211 test->no_delay = 1; 1212 if ((j_p = cJSON_GetObjectItem(j, "parallel")) != NULL) 1213 test->num_streams = j_p->valueint; 1214 if ((j_p = cJSON_GetObjectItem(j, "reverse")) != NULL) 1215 iperf_set_test_reverse(test, 1); 1216 if ((j_p = cJSON_GetObjectItem(j, "window")) != NULL) 1217 test->settings->socket_bufsize = j_p->valueint; 1218 if ((j_p = cJSON_GetObjectItem(j, "len")) != NULL) 1219 test->settings->blksize = j_p->valueint; 1220 if ((j_p = cJSON_GetObjectItem(j, "bandwidth")) != NULL) 1221 test->settings->rate = j_p->valueint; 1222 if ((j_p = cJSON_GetObjectItem(j, "burst")) != NULL) 1223 test->settings->burst = j_p->valueint; 1224 if ((j_p = cJSON_GetObjectItem(j, "TOS")) != NULL) 1225 test->settings->tos = j_p->valueint; 1226 if ((j_p = cJSON_GetObjectItem(j, "flowlabel")) != NULL) 1227 test->settings->flowlabel = j_p->valueint; 1228 if ((j_p = cJSON_GetObjectItem(j, "title")) != NULL) 1229 test->title = strdup(j_p->valuestring); 1230 if ((j_p = cJSON_GetObjectItem(j, "congestion")) != NULL) 1231 test->congestion = strdup(j_p->valuestring); 1232 if (test->sender && test->protocol->id == Ptcp && has_tcpinfo_retransmits()) 1233 test->sender_has_retransmits = 1; 1234 cJSON_Delete(j); 1235 } 1236 return r; 1237 } 1238 1239 /*************************************************************/ 1240 1241 static int 1242 send_results(struct iperf_test *test) 1243 { 1244 int r = 0; 1245 cJSON *j; 1246 cJSON *j_streams; 1247 struct iperf_stream *sp; 1248 cJSON *j_stream; 1249 int sender_has_retransmits; 1250 iperf_size_t bytes_transferred; 1251 int retransmits; 1252 1253 j = cJSON_CreateObject(); 1254 if (j == NULL) { 1255 i_errno = IEPACKAGERESULTS; 1256 r = -1; 1257 } else { 1258 cJSON_AddFloatToObject(j, "cpu_util_total", test->cpu_util[0]); 1259 cJSON_AddFloatToObject(j, "cpu_util_user", test->cpu_util[1]); 1260 cJSON_AddFloatToObject(j, "cpu_util_system", test->cpu_util[2]); 1261 if ( ! test->sender ) 1262 sender_has_retransmits = -1; 1263 else 1264 sender_has_retransmits = test->sender_has_retransmits; 1265 cJSON_AddIntToObject(j, "sender_has_retransmits", sender_has_retransmits); 1266 j_streams = cJSON_CreateArray(); 1267 if (j_streams == NULL) { 1268 i_errno = IEPACKAGERESULTS; 1269 r = -1; 1270 } else { 1271 cJSON_AddItemToObject(j, "streams", j_streams); 1272 SLIST_FOREACH(sp, &test->streams, streams) { 1273 j_stream = cJSON_CreateObject(); 1274 if (j_stream == NULL) { 1275 i_errno = IEPACKAGERESULTS; 1276 r = -1; 1277 } else { 1278 cJSON_AddItemToArray(j_streams, j_stream); 1279 bytes_transferred = test->sender ? sp->result->bytes_sent : sp->result->bytes_received; 1280 retransmits = (test->sender && test->sender_has_retransmits) ? sp->result->stream_retrans : -1; 1281 cJSON_AddIntToObject(j_stream, "id", sp->id); 1282 cJSON_AddIntToObject(j_stream, "bytes", bytes_transferred); 1283 cJSON_AddIntToObject(j_stream, "retransmits", retransmits); 1284 cJSON_AddFloatToObject(j_stream, "jitter", sp->jitter); 1285 cJSON_AddIntToObject(j_stream, "errors", sp->cnt_error); 1286 cJSON_AddIntToObject(j_stream, "packets", sp->packet_count); 1287 } 1288 } 1289 if (r == 0 && JSON_write(test->ctrl_sck, j) < 0) { 1290 i_errno = IESENDRESULTS; 1291 r = -1; 1292 } 1293 } 1294 cJSON_Delete(j); 1295 } 1296 return r; 1297 } 1298 1299 /*************************************************************/ 1300 1301 static int 1302 get_results(struct iperf_test *test) 1303 { 1304 int r = 0; 1305 cJSON *j; 1306 cJSON *j_cpu_util_total; 1307 cJSON *j_cpu_util_user; 1308 cJSON *j_cpu_util_system; 1309 cJSON *j_sender_has_retransmits; 1310 int result_has_retransmits; 1311 cJSON *j_streams; 1312 int n, i; 1313 cJSON *j_stream; 1314 cJSON *j_id; 1315 cJSON *j_bytes; 1316 cJSON *j_retransmits; 1317 cJSON *j_jitter; 1318 cJSON *j_errors; 1319 cJSON *j_packets; 1320 int sid, cerror, pcount; 1321 double jitter; 1322 iperf_size_t bytes_transferred; 1323 int retransmits; 1324 struct iperf_stream *sp; 1325 1326 j = JSON_read(test->ctrl_sck); 1327 if (j == NULL) { 1328 i_errno = IERECVRESULTS; 1329 r = -1; 1330 } else { 1331 j_cpu_util_total = cJSON_GetObjectItem(j, "cpu_util_total"); 1332 j_cpu_util_user = cJSON_GetObjectItem(j, "cpu_util_user"); 1333 j_cpu_util_system = cJSON_GetObjectItem(j, "cpu_util_system"); 1334 j_sender_has_retransmits = cJSON_GetObjectItem(j, "sender_has_retransmits"); 1335 if (j_cpu_util_total == NULL || j_cpu_util_user == NULL || j_cpu_util_system == NULL || j_sender_has_retransmits == NULL) { 1336 i_errno = IERECVRESULTS; 1337 r = -1; 1338 } else { 1339 test->remote_cpu_util[0] = j_cpu_util_total->valuefloat; 1340 test->remote_cpu_util[1] = j_cpu_util_user->valuefloat; 1341 test->remote_cpu_util[2] = j_cpu_util_system->valuefloat; 1342 result_has_retransmits = j_sender_has_retransmits->valueint; 1343 if (! test->sender) 1344 test->sender_has_retransmits = result_has_retransmits; 1345 j_streams = cJSON_GetObjectItem(j, "streams"); 1346 if (j_streams == NULL) { 1347 i_errno = IERECVRESULTS; 1348 r = -1; 1349 } else { 1350 n = cJSON_GetArraySize(j_streams); 1351 for (i=0; i<n; ++i) { 1352 j_stream = cJSON_GetArrayItem(j_streams, i); 1353 if (j_stream == NULL) { 1354 i_errno = IERECVRESULTS; 1355 r = -1; 1356 } else { 1357 j_id = cJSON_GetObjectItem(j_stream, "id"); 1358 j_bytes = cJSON_GetObjectItem(j_stream, "bytes"); 1359 j_retransmits = cJSON_GetObjectItem(j_stream, "retransmits"); 1360 j_jitter = cJSON_GetObjectItem(j_stream, "jitter"); 1361 j_errors = cJSON_GetObjectItem(j_stream, "errors"); 1362 j_packets = cJSON_GetObjectItem(j_stream, "packets"); 1363 if (j_id == NULL || j_bytes == NULL || j_retransmits == NULL || j_jitter == NULL || j_errors == NULL || j_packets == NULL) { 1364 i_errno = IERECVRESULTS; 1365 r = -1; 1366 } else { 1367 sid = j_id->valueint; 1368 bytes_transferred = j_bytes->valueint; 1369 retransmits = j_retransmits->valueint; 1370 jitter = j_jitter->valuefloat; 1371 cerror = j_errors->valueint; 1372 pcount = j_packets->valueint; 1373 SLIST_FOREACH(sp, &test->streams, streams) 1374 if (sp->id == sid) break; 1375 if (sp == NULL) { 1376 i_errno = IESTREAMID; 1377 r = -1; 1378 } else { 1379 if (test->sender) { 1380 sp->jitter = jitter; 1381 sp->cnt_error = cerror; 1382 sp->packet_count = pcount; 1383 sp->result->bytes_received = bytes_transferred; 1384 } else { 1385 sp->result->bytes_sent = bytes_transferred; 1386 sp->result->stream_retrans = retransmits; 1387 } 1388 } 1389 } 1390 } 1391 } 1392 } 1393 } 1394 cJSON_Delete(j); 1395 } 1396 return r; 1397 } 1398 1399 /*************************************************************/ 1400 1401 static int 1402 JSON_write(int fd, cJSON *json) 1403 { 1404 uint32_t hsize, nsize; 1405 char *str; 1406 int r = 0; 1407 1408 str = cJSON_PrintUnformatted(json); 1409 if (str == NULL) 1410 r = -1; 1411 else { 1412 hsize = strlen(str); 1413 nsize = htonl(hsize); 1414 if (Nwrite(fd, (char*) &nsize, sizeof(nsize), Ptcp) < 0) 1415 r = -1; 1416 else { 1417 if (Nwrite(fd, str, hsize, Ptcp) < 0) 1418 r = -1; 1419 } 1420 free(str); 1421 } 1422 return r; 1423 } 1424 1425 /*************************************************************/ 1426 1427 static cJSON * 1428 JSON_read(int fd) 1429 { 1430 uint32_t hsize, nsize; 1431 char *str; 1432 cJSON *json = NULL; 1433 1434 if (Nread(fd, (char*) &nsize, sizeof(nsize), Ptcp) >= 0) { 1435 hsize = ntohl(nsize); 1436 str = (char *) malloc(hsize+1); /* +1 for EOS */ 1437 if (str != NULL) { 1438 if (Nread(fd, str, hsize, Ptcp) >= 0) { 1439 str[hsize] = '\0'; /* add the EOS */ 1440 json = cJSON_Parse(str); 1441 } 1442 } 1443 free(str); 1444 } 1445 return json; 1446 } 1447 1448 /*************************************************************/ 1449 /** 1450 * add_to_interval_list -- adds new interval to the interval_list 1451 */ 1452 1453 void 1454 add_to_interval_list(struct iperf_stream_result * rp, struct iperf_interval_results * new) 1455 { 1456 struct iperf_interval_results *irp; 1457 1458 irp = (struct iperf_interval_results *) malloc(sizeof(struct iperf_interval_results)); 1459 memcpy(irp, new, sizeof(struct iperf_interval_results)); 1460 TAILQ_INSERT_TAIL(&rp->interval_results, irp, irlistentries); 1461 } 1462 1463 1464 /************************************************************/ 1465 1466 /** 1467 * connect_msg -- displays connection message 1468 * denoting sender/receiver details 1469 * 1470 */ 1471 1472 void 1473 connect_msg(struct iperf_stream *sp) 1474 { 1475 char ipl[INET6_ADDRSTRLEN], ipr[INET6_ADDRSTRLEN]; 1476 int lport, rport; 1477 1478 if (getsockdomain(sp->socket) == AF_INET) { 1479 inet_ntop(AF_INET, (void *) &((struct sockaddr_in *) &sp->local_addr)->sin_addr, ipl, sizeof(ipl)); 1480 mapped_v4_to_regular_v4(ipl); 1481 inet_ntop(AF_INET, (void *) &((struct sockaddr_in *) &sp->remote_addr)->sin_addr, ipr, sizeof(ipr)); 1482 mapped_v4_to_regular_v4(ipr); 1483 lport = ntohs(((struct sockaddr_in *) &sp->local_addr)->sin_port); 1484 rport = ntohs(((struct sockaddr_in *) &sp->remote_addr)->sin_port); 1485 } else { 1486 inet_ntop(AF_INET6, (void *) &((struct sockaddr_in6 *) &sp->local_addr)->sin6_addr, ipl, sizeof(ipl)); 1487 mapped_v4_to_regular_v4(ipl); 1488 inet_ntop(AF_INET6, (void *) &((struct sockaddr_in6 *) &sp->remote_addr)->sin6_addr, ipr, sizeof(ipr)); 1489 mapped_v4_to_regular_v4(ipr); 1490 lport = ntohs(((struct sockaddr_in6 *) &sp->local_addr)->sin6_port); 1491 rport = ntohs(((struct sockaddr_in6 *) &sp->remote_addr)->sin6_port); 1492 } 1493 1494 if (sp->test->json_output) 1495 cJSON_AddItemToObject(sp->test->json_start, "connected", iperf_json_printf("socket: %d local_host: %s local_port: %d remote_host: %s remote_port: %d", (int64_t) sp->socket, ipl, (int64_t) lport, ipr, (int64_t) rport)); 1496 else 1497 iprintf(sp->test, report_connected, sp->socket, ipl, lport, ipr, rport); 1498 } 1499 1500 1501 /**************************************************************************/ 1502 1503 struct iperf_test * 1504 iperf_new_test() 1505 { 1506 struct iperf_test *test; 1507 1508 test = (struct iperf_test *) malloc(sizeof(struct iperf_test)); 1509 if (!test) { 1510 i_errno = IENEWTEST; 1511 return NULL; 1512 } 1513 /* initialize everything to zero */ 1514 memset(test, 0, sizeof(struct iperf_test)); 1515 1516 test->settings = (struct iperf_settings *) malloc(sizeof(struct iperf_settings)); 1517 if (!test->settings) { 1518 free(test); 1519 i_errno = IENEWTEST; 1520 return NULL; 1521 } 1522 memset(test->settings, 0, sizeof(struct iperf_settings)); 1523 1524 /* By default all output goes to stdout */ 1525 test->outfile = stdout; 1526 1527 return test; 1528 } 1529 1530 /**************************************************************************/ 1531 1532 struct protocol * 1533 protocol_new(void) 1534 { 1535 struct protocol *proto; 1536 1537 proto = malloc(sizeof(struct protocol)); 1538 if(!proto) { 1539 return NULL; 1540 } 1541 memset(proto, 0, sizeof(struct protocol)); 1542 1543 return proto; 1544 } 1545 1546 void 1547 protocol_free(struct protocol *proto) 1548 { 1549 free(proto); 1550 } 1551 1552 /**************************************************************************/ 1553 int 1554 iperf_defaults(struct iperf_test *testp) 1555 { 1556 struct protocol *tcp, *udp; 1557 #if defined(HAVE_SCTP) 1558 struct protocol *sctp; 1559 #endif /* HAVE_SCTP */ 1560 1561 testp->omit = OMIT; 1562 testp->duration = DURATION; 1563 testp->diskfile_name = (char*) 0; 1564 testp->affinity = -1; 1565 testp->server_affinity = -1; 1566 #if defined(HAVE_CPUSET_SETAFFINITY) 1567 CPU_ZERO(&testp->cpumask); 1568 #endif /* HAVE_CPUSET_SETAFFINITY */ 1569 testp->title = NULL; 1570 testp->congestion = NULL; 1571 testp->server_port = PORT; 1572 testp->ctrl_sck = -1; 1573 testp->prot_listener = -1; 1574 1575 testp->stats_callback = iperf_stats_callback; 1576 testp->reporter_callback = iperf_reporter_callback; 1577 1578 testp->stats_interval = testp->reporter_interval = 1; 1579 testp->num_streams = 1; 1580 1581 testp->settings->domain = AF_UNSPEC; 1582 testp->settings->unit_format = 'a'; 1583 testp->settings->socket_bufsize = 0; /* use autotuning */ 1584 testp->settings->blksize = DEFAULT_TCP_BLKSIZE; 1585 testp->settings->rate = 0; 1586 testp->settings->burst = 0; 1587 testp->settings->mss = 0; 1588 testp->settings->bytes = 0; 1589 testp->settings->blocks = 0; 1590 memset(testp->cookie, 0, COOKIE_SIZE); 1591 1592 testp->multisend = 10; /* arbitrary */ 1593 1594 /* Set up protocol list */ 1595 SLIST_INIT(&testp->streams); 1596 SLIST_INIT(&testp->protocols); 1597 1598 tcp = protocol_new(); 1599 if (!tcp) 1600 return -1; 1601 1602 tcp->id = Ptcp; 1603 tcp->name = "TCP"; 1604 tcp->accept = iperf_tcp_accept; 1605 tcp->listen = iperf_tcp_listen; 1606 tcp->connect = iperf_tcp_connect; 1607 tcp->send = iperf_tcp_send; 1608 tcp->recv = iperf_tcp_recv; 1609 tcp->init = NULL; 1610 SLIST_INSERT_HEAD(&testp->protocols, tcp, protocols); 1611 1612 udp = protocol_new(); 1613 if (!udp) { 1614 protocol_free(tcp); 1615 return -1; 1616 } 1617 1618 udp->id = Pudp; 1619 udp->name = "UDP"; 1620 udp->accept = iperf_udp_accept; 1621 udp->listen = iperf_udp_listen; 1622 udp->connect = iperf_udp_connect; 1623 udp->send = iperf_udp_send; 1624 udp->recv = iperf_udp_recv; 1625 udp->init = iperf_udp_init; 1626 SLIST_INSERT_AFTER(tcp, udp, protocols); 1627 1628 set_protocol(testp, Ptcp); 1629 1630 #if defined(HAVE_SCTP) 1631 sctp = protocol_new(); 1632 if (!sctp) { 1633 protocol_free(tcp); 1634 protocol_free(udp); 1635 return -1; 1636 } 1637 1638 sctp->id = Psctp; 1639 sctp->name = "SCTP"; 1640 sctp->accept = iperf_sctp_accept; 1641 sctp->listen = iperf_sctp_listen; 1642 sctp->connect = iperf_sctp_connect; 1643 sctp->send = iperf_sctp_send; 1644 sctp->recv = iperf_sctp_recv; 1645 sctp->init = iperf_sctp_init; 1646 1647 SLIST_INSERT_AFTER(udp, sctp, protocols); 1648 #endif /* HAVE_SCTP */ 1649 1650 testp->on_new_stream = iperf_on_new_stream; 1651 testp->on_test_start = iperf_on_test_start; 1652 testp->on_connect = iperf_on_connect; 1653 testp->on_test_finish = iperf_on_test_finish; 1654 1655 return 0; 1656 } 1657 1658 1659 /**************************************************************************/ 1660 void 1661 iperf_free_test(struct iperf_test *test) 1662 { 1663 struct protocol *prot; 1664 struct iperf_stream *sp; 1665 1666 /* Free streams */ 1667 while (!SLIST_EMPTY(&test->streams)) { 1668 sp = SLIST_FIRST(&test->streams); 1669 SLIST_REMOVE_HEAD(&test->streams, streams); 1670 iperf_free_stream(sp); 1671 } 1672 1673 if (test->server_hostname) 1674 free(test->server_hostname); 1675 if (test->bind_address) 1676 free(test->bind_address); 1677 free(test->settings); 1678 if (test->title) 1679 free(test->title); 1680 if (test->congestion) 1681 free(test->congestion); 1682 if (test->omit_timer != NULL) 1683 tmr_cancel(test->omit_timer); 1684 if (test->timer != NULL) 1685 tmr_cancel(test->timer); 1686 if (test->stats_timer != NULL) 1687 tmr_cancel(test->stats_timer); 1688 if (test->reporter_timer != NULL) 1689 tmr_cancel(test->reporter_timer); 1690 1691 /* Free protocol list */ 1692 while (!SLIST_EMPTY(&test->protocols)) { 1693 prot = SLIST_FIRST(&test->protocols); 1694 SLIST_REMOVE_HEAD(&test->protocols, protocols); 1695 free(prot); 1696 } 1697 1698 if (test->json_output_string) { 1699 free(test->json_output_string); 1700 test->json_output_string = NULL; 1701 } 1702 1703 /* XXX: Why are we setting these values to NULL? */ 1704 // test->streams = NULL; 1705 test->stats_callback = NULL; 1706 test->reporter_callback = NULL; 1707 free(test); 1708 } 1709 1710 1711 void 1712 iperf_reset_test(struct iperf_test *test) 1713 { 1714 struct iperf_stream *sp; 1715 1716 /* Free streams */ 1717 while (!SLIST_EMPTY(&test->streams)) { 1718 sp = SLIST_FIRST(&test->streams); 1719 SLIST_REMOVE_HEAD(&test->streams, streams); 1720 iperf_free_stream(sp); 1721 } 1722 if (test->omit_timer != NULL) { 1723 tmr_cancel(test->omit_timer); 1724 test->omit_timer = NULL; 1725 } 1726 if (test->timer != NULL) { 1727 tmr_cancel(test->timer); 1728 test->timer = NULL; 1729 } 1730 if (test->stats_timer != NULL) { 1731 tmr_cancel(test->stats_timer); 1732 test->stats_timer = NULL; 1733 } 1734 if (test->reporter_timer != NULL) { 1735 tmr_cancel(test->reporter_timer); 1736 test->reporter_timer = NULL; 1737 } 1738 test->done = 0; 1739 1740 SLIST_INIT(&test->streams); 1741 1742 test->role = 's'; 1743 test->sender = 0; 1744 test->sender_has_retransmits = 0; 1745 set_protocol(test, Ptcp); 1746 test->omit = OMIT; 1747 test->duration = DURATION; 1748 test->server_affinity = -1; 1749 #if defined(HAVE_CPUSET_SETAFFINITY) 1750 CPU_ZERO(&test->cpumask); 1751 #endif /* HAVE_CPUSET_SETAFFINITY */ 1752 test->state = 0; 1753 1754 if(test->title) { 1755 free(test->title); 1756 test->title = NULL; 1757 } 1758 if(test->server_hostname) { 1759 free(test->server_hostname); 1760 test->server_hostname = NULL; 1761 } 1762 if(test->bind_address) { 1763 free(test->bind_address); 1764 test->bind_address = NULL; 1765 } 1766 if(test->congestion) { 1767 free(test->congestion); 1768 test->congestion = NULL; 1769 } 1770 1771 test->ctrl_sck = -1; 1772 test->prot_listener = -1; 1773 1774 test->bytes_sent = 0; 1775 test->blocks_sent = 0; 1776 1777 test->reverse = 0; 1778 test->no_delay = 0; 1779 1780 FD_ZERO(&test->read_set); 1781 FD_ZERO(&test->write_set); 1782 1783 test->num_streams = 1; 1784 test->settings->socket_bufsize = 0; 1785 test->settings->blksize = DEFAULT_TCP_BLKSIZE; 1786 test->settings->rate = 0; 1787 test->settings->burst = 0; 1788 test->settings->mss = 0; 1789 memset(test->cookie, 0, COOKIE_SIZE); 1790 test->multisend = 10; /* arbitrary */ 1791 } 1792 1793 1794 /* Reset all of a test's stats back to zero. Called when the omitting 1795 ** period is over. 1796 */ 1797 void 1798 iperf_reset_stats(struct iperf_test *test) 1799 { 1800 struct timeval now; 1801 struct iperf_stream *sp; 1802 struct iperf_stream_result *rp; 1803 1804 test->bytes_sent = 0; 1805 test->blocks_sent = 0; 1806 gettimeofday(&now, NULL); 1807 SLIST_FOREACH(sp, &test->streams, streams) { 1808 sp->omitted_packet_count = sp->packet_count; 1809 sp->jitter = 0; 1810 sp->outoforder_packets = 0; 1811 sp->cnt_error = 0; 1812 rp = sp->result; 1813 rp->bytes_sent = rp->bytes_received = 0; 1814 rp->bytes_sent_this_interval = rp->bytes_received_this_interval = 0; 1815 if (test->sender && test->sender_has_retransmits) { 1816 struct iperf_interval_results ir; /* temporary results structure */ 1817 save_tcpinfo(sp, &ir); 1818 rp->stream_prev_total_retrans = get_total_retransmits(&ir); 1819 } 1820 rp->stream_retrans = 0; 1821 rp->start_time = now; 1822 } 1823 } 1824 1825 1826 /**************************************************************************/ 1827 1828 /** 1829 * Gather statistics during a test. 1830 * This function works for both the client and server side. 1831 */ 1832 void 1833 iperf_stats_callback(struct iperf_test *test) 1834 { 1835 struct iperf_stream *sp; 1836 struct iperf_stream_result *rp = NULL; 1837 struct iperf_interval_results *irp, temp; 1838 1839 temp.omitted = test->omitting; 1840 SLIST_FOREACH(sp, &test->streams, streams) { 1841 rp = sp->result; 1842 1843 temp.bytes_transferred = test->sender ? rp->bytes_sent_this_interval : rp->bytes_received_this_interval; 1844 1845 irp = TAILQ_LAST(&rp->interval_results, irlisthead); 1846 /* result->end_time contains timestamp of previous interval */ 1847 if ( irp != NULL ) /* not the 1st interval */ 1848 memcpy(&temp.interval_start_time, &rp->end_time, sizeof(struct timeval)); 1849 else /* or use timestamp from beginning */ 1850 memcpy(&temp.interval_start_time, &rp->start_time, sizeof(struct timeval)); 1851 /* now save time of end of this interval */ 1852 gettimeofday(&rp->end_time, NULL); 1853 memcpy(&temp.interval_end_time, &rp->end_time, sizeof(struct timeval)); 1854 temp.interval_duration = timeval_diff(&temp.interval_start_time, &temp.interval_end_time); 1855 //temp.interval_duration = timeval_diff(&temp.interval_start_time, &temp.interval_end_time); 1856 if (test->protocol->id == Ptcp) { 1857 if ( has_tcpinfo()) { 1858 save_tcpinfo(sp, &temp); 1859 if (test->sender && test->sender_has_retransmits) { 1860 long total_retrans = get_total_retransmits(&temp); 1861 temp.interval_retrans = total_retrans - rp->stream_prev_total_retrans; 1862 rp->stream_retrans += temp.interval_retrans; 1863 rp->stream_prev_total_retrans = total_retrans; 1864 1865 temp.snd_cwnd = get_snd_cwnd(&temp); 1866 } 1867 } 1868 } else { 1869 if (irp == NULL) { 1870 temp.interval_packet_count = sp->packet_count; 1871 temp.interval_outoforder_packets = sp->outoforder_packets; 1872 temp.interval_cnt_error = sp->cnt_error; 1873 } else { 1874 temp.interval_packet_count = sp->packet_count - irp->packet_count; 1875 temp.interval_outoforder_packets = sp->outoforder_packets - irp->outoforder_packets; 1876 temp.interval_cnt_error = sp->cnt_error - irp->cnt_error; 1877 } 1878 temp.packet_count = sp->packet_count; 1879 temp.jitter = sp->jitter; 1880 temp.outoforder_packets = sp->outoforder_packets; 1881 temp.cnt_error = sp->cnt_error; 1882 } 1883 add_to_interval_list(rp, &temp); 1884 rp->bytes_sent_this_interval = rp->bytes_received_this_interval = 0; 1885 } 1886 } 1887 1888 /** 1889 * Print intermediate results during a test (interval report). 1890 * Uses print_interval_results to print the results for each stream, 1891 * then prints an interval summary for all streams in this 1892 * interval. 1893 */ 1894 static void 1895 iperf_print_intermediate(struct iperf_test *test) 1896 { 1897 char ubuf[UNIT_LEN]; 1898 char nbuf[UNIT_LEN]; 1899 struct iperf_stream *sp = NULL; 1900 struct iperf_interval_results *irp; 1901 iperf_size_t bytes = 0; 1902 double bandwidth; 1903 int retransmits = 0; 1904 double start_time, end_time; 1905 cJSON *json_interval; 1906 cJSON *json_interval_streams; 1907 int total_packets = 0, lost_packets = 0; 1908 double avg_jitter = 0.0, lost_percent; 1909 1910 if (test->json_output) { 1911 json_interval = cJSON_CreateObject(); 1912 if (json_interval == NULL) 1913 return; 1914 cJSON_AddItemToArray(test->json_intervals, json_interval); 1915 json_interval_streams = cJSON_CreateArray(); 1916 if (json_interval_streams == NULL) 1917 return; 1918 cJSON_AddItemToObject(json_interval, "streams", json_interval_streams); 1919 } else { 1920 json_interval = NULL; 1921 json_interval_streams = NULL; 1922 } 1923 1924 SLIST_FOREACH(sp, &test->streams, streams) { 1925 print_interval_results(test, sp, json_interval_streams); 1926 /* sum up all streams */ 1927 irp = TAILQ_LAST(&sp->result->interval_results, irlisthead); 1928 if (irp == NULL) { 1929 iperf_err(test, "iperf_print_intermediate error: interval_results is NULL"); 1930 return; 1931 } 1932 bytes += irp->bytes_transferred; 1933 if (test->protocol->id == Ptcp) { 1934 if (test->sender && test->sender_has_retransmits) { 1935 retransmits += irp->interval_retrans; 1936 } 1937 } else { 1938 total_packets += irp->interval_packet_count; 1939 lost_packets += irp->interval_cnt_error; 1940 avg_jitter += irp->jitter; 1941 } 1942 } 1943 1944 /* next build string with sum of all streams */ 1945 if (test->num_streams > 1 || test->json_output) { 1946 sp = SLIST_FIRST(&test->streams); /* reset back to 1st stream */ 1947 irp = TAILQ_LAST(&sp->result->interval_results, irlisthead); /* use 1st stream for timing info */ 1948 1949 unit_snprintf(ubuf, UNIT_LEN, (double) bytes, 'A'); 1950 bandwidth = (double) bytes / (double) irp->interval_duration; 1951 unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format); 1952 1953 start_time = timeval_diff(&sp->result->start_time,&irp->interval_start_time); 1954 end_time = timeval_diff(&sp->result->start_time,&irp->interval_end_time); 1955 if (test->protocol->id == Ptcp || test->protocol->id == Psctp) { 1956 if (test->sender && test->sender_has_retransmits) { 1957 /* Interval sum, TCP with retransmits. */ 1958 if (test->json_output) 1959 cJSON_AddItemToObject(json_interval, "sum", iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f retransmits: %d omitted: %b", (double) start_time, (double) end_time, (double) irp->interval_duration, (int64_t) bytes, bandwidth * 8, (int64_t) retransmits, irp->omitted)); /* XXX irp->omitted or test->omitting? */ 1960 else 1961 iprintf(test, report_sum_bw_retrans_format, start_time, end_time, ubuf, nbuf, retransmits, irp->omitted?report_omitted:""); /* XXX irp->omitted or test->omitting? */ 1962 } else { 1963 /* Interval sum, TCP without retransmits. */ 1964 if (test->json_output) 1965 cJSON_AddItemToObject(json_interval, "sum", iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f omitted: %b", (double) start_time, (double) end_time, (double) irp->interval_duration, (int64_t) bytes, bandwidth * 8, test->omitting)); 1966 else 1967 iprintf(test, report_sum_bw_format, start_time, end_time, ubuf, nbuf, test->omitting?report_omitted:""); 1968 } 1969 } else { 1970 /* Interval sum, UDP. */ 1971 if (test->sender) { 1972 if (test->json_output) 1973 cJSON_AddItemToObject(json_interval, "sum", iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f packets: %d omitted: %b", (double) start_time, (double) end_time, (double) irp->interval_duration, (int64_t) bytes, bandwidth * 8, (int64_t) total_packets, test->omitting)); 1974 else 1975 iprintf(test, report_sum_bw_udp_sender_format, start_time, end_time, ubuf, nbuf, total_packets, test->omitting?report_omitted:""); 1976 } else { 1977 avg_jitter /= test->num_streams; 1978 lost_percent = 100.0 * lost_packets / total_packets; 1979 if (test->json_output) 1980 cJSON_AddItemToObject(json_interval, "sum", iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f jitter_ms: %f lost_packets: %d packets: %d lost_percent: %f omitted: %b", (double) start_time, (double) end_time, (double) irp->interval_duration, (int64_t) bytes, bandwidth * 8, (double) avg_jitter * 1000.0, (int64_t) lost_packets, (int64_t) total_packets, (double) lost_percent, test->omitting)); 1981 else 1982 iprintf(test, report_sum_bw_udp_format, start_time, end_time, ubuf, nbuf, avg_jitter * 1000.0, lost_packets, total_packets, lost_percent, test->omitting?report_omitted:""); 1983 } 1984 } 1985 } 1986 } 1987 1988 /** 1989 * Print overall summary statistics at the end of a test. 1990 */ 1991 static void 1992 iperf_print_results(struct iperf_test *test) 1993 { 1994 1995 cJSON *json_summary_streams = NULL; 1996 cJSON *json_summary_stream = NULL; 1997 int total_retransmits = 0; 1998 int total_packets = 0, lost_packets = 0; 1999 char ubuf[UNIT_LEN]; 2000 char nbuf[UNIT_LEN]; 2001 struct stat sb; 2002 char sbuf[UNIT_LEN]; 2003 struct iperf_stream *sp = NULL; 2004 iperf_size_t bytes_sent, total_sent = 0; 2005 iperf_size_t bytes_received, total_received = 0; 2006 double start_time, end_time, avg_jitter = 0.0, lost_percent; 2007 double bandwidth; 2008 2009 /* print final summary for all intervals */ 2010 2011 if (test->json_output) { 2012 json_summary_streams = cJSON_CreateArray(); 2013 if (json_summary_streams == NULL) 2014 return; 2015 cJSON_AddItemToObject(test->json_end, "streams", json_summary_streams); 2016 } else { 2017 iprintf(test, "%s", report_bw_separator); 2018 if (test->verbose) 2019 iprintf(test, "%s", report_summary); 2020 if (test->protocol->id == Ptcp || test->protocol->id == Psctp) { 2021 if (test->sender_has_retransmits) 2022 iprintf(test, "%s", report_bw_retrans_header); 2023 else 2024 iprintf(test, "%s", report_bw_header); 2025 } else 2026 iprintf(test, "%s", report_bw_udp_header); 2027 } 2028 2029 start_time = 0.; 2030 sp = SLIST_FIRST(&test->streams); 2031 end_time = timeval_diff(&sp->result->start_time, &sp->result->end_time); 2032 SLIST_FOREACH(sp, &test->streams, streams) { 2033 if (test->json_output) { 2034 json_summary_stream = cJSON_CreateObject(); 2035 if (json_summary_stream == NULL) 2036 return; 2037 cJSON_AddItemToArray(json_summary_streams, json_summary_stream); 2038 } 2039 2040 bytes_sent = sp->result->bytes_sent; 2041 bytes_received = sp->result->bytes_received; 2042 total_sent += bytes_sent; 2043 total_received += bytes_received; 2044 2045 if (test->protocol->id == Ptcp || test->protocol->id == Psctp) { 2046 if (test->sender_has_retransmits) { 2047 total_retransmits += sp->result->stream_retrans; 2048 } 2049 } else { 2050 total_packets += (sp->packet_count - sp->omitted_packet_count); 2051 lost_packets += sp->cnt_error; 2052 avg_jitter += sp->jitter; 2053 } 2054 2055 unit_snprintf(ubuf, UNIT_LEN, (double) bytes_sent, 'A'); 2056 bandwidth = (double) bytes_sent / (double) end_time; 2057 unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format); 2058 if (test->protocol->id == Ptcp || test->protocol->id == Psctp) { 2059 if (test->sender_has_retransmits) { 2060 /* Summary, TCP with retransmits. */ 2061 if (test->json_output) 2062 cJSON_AddItemToObject(json_summary_stream, "sender", iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f retransmits: %d", (int64_t) sp->socket, (double) start_time, (double) end_time, (double) end_time, (int64_t) bytes_sent, bandwidth * 8, (int64_t) sp->result->stream_retrans)); 2063 else 2064 iprintf(test, report_bw_retrans_format, sp->socket, start_time, end_time, ubuf, nbuf, sp->result->stream_retrans, report_sender); 2065 } else { 2066 /* Summary, TCP without retransmits. */ 2067 if (test->json_output) 2068 cJSON_AddItemToObject(json_summary_stream, "sender", iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f", (int64_t) sp->socket, (double) start_time, (double) end_time, (double) end_time, (int64_t) bytes_sent, bandwidth * 8)); 2069 else 2070 iprintf(test, report_bw_format, sp->socket, start_time, end_time, ubuf, nbuf, report_sender); 2071 } 2072 } else { 2073 /* Summary, UDP. */ 2074 lost_percent = 100.0 * sp->cnt_error / (sp->packet_count - sp->omitted_packet_count); 2075 if (test->json_output) 2076 cJSON_AddItemToObject(json_summary_stream, "udp", iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f jitter_ms: %f lost_packets: %d packets: %d lost_percent: %f", (int64_t) sp->socket, (double) start_time, (double) end_time, (double) end_time, (int64_t) bytes_sent, bandwidth * 8, (double) sp->jitter * 1000.0, (int64_t) sp->cnt_error, (int64_t) (sp->packet_count - sp->omitted_packet_count), (double) lost_percent)); 2077 else { 2078 iprintf(test, report_bw_udp_format, sp->socket, start_time, end_time, ubuf, nbuf, sp->jitter * 1000.0, sp->cnt_error, (sp->packet_count - sp->omitted_packet_count), lost_percent, ""); 2079 if (test->role == 'c') 2080 iprintf(test, report_datagrams, sp->socket, (sp->packet_count - sp->omitted_packet_count)); 2081 if (sp->outoforder_packets > 0) 2082 iprintf(test, report_sum_outoforder, start_time, end_time, sp->cnt_error); 2083 } 2084 } 2085 2086 if (sp->diskfile_fd >= 0) { 2087 if (fstat(sp->diskfile_fd, &sb) == 0) { 2088 int percent = (int) ( ( (double) bytes_sent / (double) sb.st_size ) * 100.0 ); 2089 unit_snprintf(sbuf, UNIT_LEN, (double) sb.st_size, 'A'); 2090 if (test->json_output) 2091 cJSON_AddItemToObject(json_summary_stream, "diskfile", iperf_json_printf("sent: %d size: %d percent: %d filename: %s", (int64_t) bytes_sent, (int64_t) sb.st_size, (int64_t) percent, test->diskfile_name)); 2092 else 2093 iprintf(test, report_diskfile, ubuf, sbuf, percent, test->diskfile_name); 2094 } 2095 } 2096 2097 unit_snprintf(ubuf, UNIT_LEN, (double) bytes_received, 'A'); 2098 bandwidth = (double) bytes_received / (double) end_time; 2099 unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format); 2100 if (test->protocol->id == Ptcp || test->protocol->id == Psctp) { 2101 if (test->json_output) 2102 cJSON_AddItemToObject(json_summary_stream, "receiver", iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f", (int64_t) sp->socket, (double) start_time, (double) end_time, (double) end_time, (int64_t) bytes_received, bandwidth * 8)); 2103 else 2104 iprintf(test, report_bw_format, sp->socket, start_time, end_time, ubuf, nbuf, report_receiver); 2105 } 2106 } 2107 2108 if (test->num_streams > 1 || test->json_output) { 2109 unit_snprintf(ubuf, UNIT_LEN, (double) total_sent, 'A'); 2110 bandwidth = (double) total_sent / (double) end_time; 2111 unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format); 2112 if (test->protocol->id == Ptcp || test->protocol->id == Psctp) { 2113 if (test->sender_has_retransmits) { 2114 /* Summary sum, TCP with retransmits. */ 2115 if (test->json_output) 2116 cJSON_AddItemToObject(test->json_end, "sum_sent", iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f retransmits: %d", (double) start_time, (double) end_time, (double) end_time, (int64_t) total_sent, bandwidth * 8, (int64_t) total_retransmits)); 2117 else 2118 iprintf(test, report_sum_bw_retrans_format, start_time, end_time, ubuf, nbuf, total_retransmits, report_sender); 2119 } else { 2120 /* Summary sum, TCP without retransmits. */ 2121 if (test->json_output) 2122 cJSON_AddItemToObject(test->json_end, "sum_sent", iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f", (double) start_time, (double) end_time, (double) end_time, (int64_t) total_sent, bandwidth * 8)); 2123 else 2124 iprintf(test, report_sum_bw_format, start_time, end_time, ubuf, nbuf, report_sender); 2125 } 2126 unit_snprintf(ubuf, UNIT_LEN, (double) total_received, 'A'); 2127 bandwidth = (double) total_received / (double) end_time; 2128 unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format); 2129 if (test->json_output) 2130 cJSON_AddItemToObject(test->json_end, "sum_received", iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f", (double) start_time, (double) end_time, (double) end_time, (int64_t) total_received, bandwidth * 8)); 2131 else 2132 iprintf(test, report_sum_bw_format, start_time, end_time, ubuf, nbuf, report_receiver); 2133 } else { 2134 /* Summary sum, UDP. */ 2135 avg_jitter /= test->num_streams; 2136 lost_percent = 100.0 * lost_packets / total_packets; 2137 if (test->json_output) 2138 cJSON_AddItemToObject(test->json_end, "sum", iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f jitter_ms: %f lost_packets: %d packets: %d lost_percent: %f", (double) start_time, (double) end_time, (double) end_time, (int64_t) total_sent, bandwidth * 8, (double) avg_jitter * 1000.0, (int64_t) lost_packets, (int64_t) total_packets, (double) lost_percent)); 2139 else 2140 iprintf(test, report_sum_bw_udp_format, start_time, end_time, ubuf, nbuf, avg_jitter * 1000.0, lost_packets, total_packets, lost_percent, ""); 2141 } 2142 } 2143 2144 if (test->json_output) 2145 cJSON_AddItemToObject(test->json_end, "cpu_utilization_percent", iperf_json_printf("host_total: %f host_user: %f host_system: %f remote_total: %f remote_user: %f remote_system: %f", (double) test->cpu_util[0], (double) test->cpu_util[1], (double) test->cpu_util[2], (double) test->remote_cpu_util[0], (double) test->remote_cpu_util[1], (double) test->remote_cpu_util[2])); 2146 else if (test->verbose) 2147 iprintf(test, report_cpu, report_local, test->sender?report_sender:report_receiver, test->cpu_util[0], test->cpu_util[1], test->cpu_util[2], report_remote, test->sender?report_receiver:report_sender, test->remote_cpu_util[0], test->remote_cpu_util[1], test->remote_cpu_util[2]); 2148 } 2149 2150 /**************************************************************************/ 2151 2152 /** 2153 * Main report-printing callback. 2154 * Prints results either during a test (interval report only) or 2155 * after the entire test has been run (last interval report plus 2156 * overall summary). 2157 */ 2158 void 2159 iperf_reporter_callback(struct iperf_test *test) 2160 { 2161 switch (test->state) { 2162 case TEST_RUNNING: 2163 case STREAM_RUNNING: 2164 /* print interval results for each stream */ 2165 iperf_print_intermediate(test); 2166 break; 2167 case DISPLAY_RESULTS: 2168 iperf_print_intermediate(test); 2169 iperf_print_results(test); 2170 break; 2171 } 2172 2173 } 2174 2175 /** 2176 * Print the interval results for one stream. 2177 * This function needs to know about the overall test so it can determine the 2178 * context for printing headers, separators, etc. 2179 */ 2180 static void 2181 print_interval_results(struct iperf_test *test, struct iperf_stream *sp, cJSON *json_interval_streams) 2182 { 2183 char ubuf[UNIT_LEN]; 2184 char nbuf[UNIT_LEN]; 2185 char cbuf[UNIT_LEN]; 2186 double st = 0., et = 0.; 2187 struct iperf_interval_results *irp = NULL; 2188 double bandwidth, lost_percent; 2189 2190 irp = TAILQ_LAST(&sp->result->interval_results, irlisthead); /* get last entry in linked list */ 2191 if (irp == NULL) { 2192 iperf_err(test, "print_interval_results error: interval_results is NULL"); 2193 return; 2194 } 2195 if (!test->json_output) { 2196 /* First stream? */ 2197 if (sp == SLIST_FIRST(&test->streams)) { 2198 /* It it's the first interval, print the header; 2199 ** else if there's more than one stream, print the separator; 2200 ** else nothing. 2201 */ 2202 if (timeval_equals(&sp->result->start_time, &irp->interval_start_time)) { 2203 if (test->protocol->id == Ptcp || test->protocol->id == Psctp) { 2204 if (test->sender && test->sender_has_retransmits) 2205 iprintf(test, "%s", report_bw_retrans_cwnd_header); 2206 else 2207 iprintf(test, "%s", report_bw_header); 2208 } else { 2209 if (test->sender) 2210 iprintf(test, "%s", report_bw_udp_sender_header); 2211 else 2212 iprintf(test, "%s", report_bw_udp_header); 2213 } 2214 } else if (test->num_streams > 1) 2215 iprintf(test, "%s", report_bw_separator); 2216 } 2217 } 2218 2219 unit_snprintf(ubuf, UNIT_LEN, (double) (irp->bytes_transferred), 'A'); 2220 bandwidth = (double) irp->bytes_transferred / (double) irp->interval_duration; 2221 unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format); 2222 2223 st = timeval_diff(&sp->result->start_time, &irp->interval_start_time); 2224 et = timeval_diff(&sp->result->start_time, &irp->interval_end_time); 2225 2226 if (test->protocol->id == Ptcp || test->protocol->id == Psctp) { 2227 if (test->sender && test->sender_has_retransmits) { 2228 /* Interval, TCP with retransmits. */ 2229 if (test->json_output) 2230 cJSON_AddItemToArray(json_interval_streams, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f retransmits: %d snd_cwnd: %d omitted: %b", (int64_t) sp->socket, (double) st, (double) et, (double) irp->interval_duration, (int64_t) irp->bytes_transferred, bandwidth * 8, (int64_t) irp->interval_retrans, (int64_t) irp->snd_cwnd, irp->omitted)); 2231 else { 2232 unit_snprintf(cbuf, UNIT_LEN, irp->snd_cwnd, 'A'); 2233 iprintf(test, report_bw_retrans_cwnd_format, sp->socket, st, et, ubuf, nbuf, irp->interval_retrans, cbuf, irp->omitted?report_omitted:""); 2234 } 2235 } else { 2236 /* Interval, TCP without retransmits. */ 2237 if (test->json_output) 2238 cJSON_AddItemToArray(json_interval_streams, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f omitted: %b", (int64_t) sp->socket, (double) st, (double) et, (double) irp->interval_duration, (int64_t) irp->bytes_transferred, bandwidth * 8, irp->omitted)); 2239 else 2240 iprintf(test, report_bw_format, sp->socket, st, et, ubuf, nbuf, irp->omitted?report_omitted:""); 2241 } 2242 } else { 2243 /* Interval, UDP. */ 2244 if (test->sender) { 2245 if (test->json_output) 2246 cJSON_AddItemToArray(json_interval_streams, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f packets: %d omitted: %b", (int64_t) sp->socket, (double) st, (double) et, (double) irp->interval_duration, (int64_t) irp->bytes_transferred, bandwidth * 8, (int64_t) irp->interval_packet_count, irp->omitted)); 2247 else 2248 iprintf(test, report_bw_udp_sender_format, sp->socket, st, et, ubuf, nbuf, irp->interval_packet_count, irp->omitted?report_omitted:""); 2249 } else { 2250 lost_percent = 100.0 * irp->interval_cnt_error / irp->interval_packet_count; 2251 if (test->json_output) 2252 cJSON_AddItemToArray(json_interval_streams, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f jitter_ms: %f lost_packets: %d packets: %d lost_percent: %f omitted: %b", (int64_t) sp->socket, (double) st, (double) et, (double) irp->interval_duration, (int64_t) irp->bytes_transferred, bandwidth * 8, (double) irp->jitter * 1000.0, (int64_t) irp->interval_cnt_error, (int64_t) irp->interval_packet_count, (double) lost_percent, irp->omitted)); 2253 else 2254 iprintf(test, report_bw_udp_format, sp->socket, st, et, ubuf, nbuf, irp->jitter * 1000.0, irp->interval_cnt_error, irp->interval_packet_count, lost_percent, irp->omitted?report_omitted:""); 2255 } 2256 } 2257 } 2258 2259 /**************************************************************************/ 2260 void 2261 iperf_free_stream(struct iperf_stream *sp) 2262 { 2263 struct iperf_interval_results *irp, *nirp; 2264 2265 /* XXX: need to free interval list too! */ 2266 munmap(sp->buffer, sp->test->settings->blksize); 2267 close(sp->buffer_fd); 2268 if (sp->diskfile_fd >= 0) 2269 close(sp->diskfile_fd); 2270 for (irp = TAILQ_FIRST(&sp->result->interval_results); irp != TAILQ_END(sp->result->interval_results); irp = nirp) { 2271 nirp = TAILQ_NEXT(irp, irlistentries); 2272 free(irp); 2273 } 2274 free(sp->result); 2275 if (sp->send_timer != NULL) 2276 tmr_cancel(sp->send_timer); 2277 free(sp); 2278 } 2279 2280 /**************************************************************************/ 2281 struct iperf_stream * 2282 iperf_new_stream(struct iperf_test *test, int s) 2283 { 2284 int i; 2285 struct iperf_stream *sp; 2286 char template[] = "/tmp/iperf3.XXXXXX"; 2287 2288 h_errno = 0; 2289 2290 sp = (struct iperf_stream *) malloc(sizeof(struct iperf_stream)); 2291 if (!sp) { 2292 i_errno = IECREATESTREAM; 2293 return NULL; 2294 } 2295 2296 memset(sp, 0, sizeof(struct iperf_stream)); 2297 2298 sp->test = test; 2299 sp->settings = test->settings; 2300 sp->result = (struct iperf_stream_result *) malloc(sizeof(struct iperf_stream_result)); 2301 if (!sp->result) { 2302 free(sp); 2303 i_errno = IECREATESTREAM; 2304 return NULL; 2305 } 2306 2307 memset(sp->result, 0, sizeof(struct iperf_stream_result)); 2308 TAILQ_INIT(&sp->result->interval_results); 2309 2310 /* Create and randomize the buffer */ 2311 sp->buffer_fd = mkstemp(template); 2312 if (sp->buffer_fd == -1) { 2313 i_errno = IECREATESTREAM; 2314 free(sp->result); 2315 free(sp); 2316 return NULL; 2317 } 2318 if (unlink(template) < 0) { 2319 i_errno = IECREATESTREAM; 2320 free(sp->result); 2321 free(sp); 2322 return NULL; 2323 } 2324 if (ftruncate(sp->buffer_fd, test->settings->blksize) < 0) { 2325 i_errno = IECREATESTREAM; 2326 free(sp->result); 2327 free(sp); 2328 return NULL; 2329 } 2330 sp->buffer = (char *) mmap(NULL, test->settings->blksize, PROT_READ|PROT_WRITE, MAP_PRIVATE, sp->buffer_fd, 0); 2331 if (sp->buffer == MAP_FAILED) { 2332 i_errno = IECREATESTREAM; 2333 free(sp->result); 2334 free(sp); 2335 return NULL; 2336 } 2337 srandom(time(NULL)); 2338 for (i = 0; i < test->settings->blksize; ++i) 2339 sp->buffer[i] = random(); 2340 2341 /* Set socket */ 2342 sp->socket = s; 2343 2344 sp->snd = test->protocol->send; 2345 sp->rcv = test->protocol->recv; 2346 2347 if (test->diskfile_name != (char*) 0) { 2348 sp->diskfile_fd = open(test->diskfile_name, test->sender ? O_RDONLY : (O_WRONLY|O_CREAT|O_TRUNC)); 2349 if (sp->diskfile_fd == -1) { 2350 i_errno = IEFILE; 2351 munmap(sp->buffer, sp->test->settings->blksize); 2352 free(sp->result); 2353 free(sp); 2354 return NULL; 2355 } 2356 sp->snd2 = sp->snd; 2357 sp->snd = diskfile_send; 2358 sp->rcv2 = sp->rcv; 2359 sp->rcv = diskfile_recv; 2360 } else 2361 sp->diskfile_fd = -1; 2362 2363 /* Initialize stream */ 2364 if (iperf_init_stream(sp, test) < 0) { 2365 close(sp->buffer_fd); 2366 munmap(sp->buffer, sp->test->settings->blksize); 2367 free(sp->result); 2368 free(sp); 2369 return NULL; 2370 } 2371 iperf_add_stream(test, sp); 2372 2373 return sp; 2374 } 2375 2376 /**************************************************************************/ 2377 int 2378 iperf_init_stream(struct iperf_stream *sp, struct iperf_test *test) 2379 { 2380 socklen_t len; 2381 int opt; 2382 2383 len = sizeof(struct sockaddr_storage); 2384 if (getsockname(sp->socket, (struct sockaddr *) &sp->local_addr, &len) < 0) { 2385 i_errno = IEINITSTREAM; 2386 return -1; 2387 } 2388 len = sizeof(struct sockaddr_storage); 2389 if (getpeername(sp->socket, (struct sockaddr *) &sp->remote_addr, &len) < 0) { 2390 i_errno = IEINITSTREAM; 2391 return -1; 2392 } 2393 2394 /* Set IP TOS */ 2395 if ((opt = test->settings->tos)) { 2396 if (getsockdomain(sp->socket) == AF_INET6) { 2397 #ifdef IPV6_TCLASS 2398 if (setsockopt(sp->socket, IPPROTO_IPV6, IPV6_TCLASS, &opt, sizeof(opt)) < 0) { 2399 i_errno = IESETCOS; 2400 return -1; 2401 } 2402 #else 2403 i_errno = IESETCOS; 2404 return -1; 2405 #endif 2406 } else { 2407 if (setsockopt(sp->socket, IPPROTO_IP, IP_TOS, &opt, sizeof(opt)) < 0) { 2408 i_errno = IESETTOS; 2409 return -1; 2410 } 2411 } 2412 } 2413 2414 return 0; 2415 } 2416 2417 /**************************************************************************/ 2418 void 2419 iperf_add_stream(struct iperf_test *test, struct iperf_stream *sp) 2420 { 2421 int i; 2422 struct iperf_stream *n, *prev; 2423 2424 if (SLIST_EMPTY(&test->streams)) { 2425 SLIST_INSERT_HEAD(&test->streams, sp, streams); 2426 sp->id = 1; 2427 } else { 2428 // for (n = test->streams, i = 2; n->next; n = n->next, ++i); 2429 i = 2; 2430 SLIST_FOREACH(n, &test->streams, streams) { 2431 prev = n; 2432 ++i; 2433 } 2434 SLIST_INSERT_AFTER(prev, sp, streams); 2435 sp->id = i; 2436 } 2437 } 2438 2439 /* This pair of routines gets inserted into the snd/rcv function pointers 2440 ** when there's a -F flag. They handle the file stuff and call the real 2441 ** snd/rcv functions, which have been saved in snd2/rcv2. 2442 ** 2443 ** The advantage of doing it this way is that in the much more common 2444 ** case of no -F flag, there is zero extra overhead. 2445 */ 2446 2447 static int 2448 diskfile_send(struct iperf_stream *sp) 2449 { 2450 int r; 2451 2452 r = read(sp->diskfile_fd, sp->buffer, sp->test->settings->blksize); 2453 if (r == 0) 2454 sp->test->done = 1; 2455 else 2456 r = sp->snd2(sp); 2457 return r; 2458 } 2459 2460 static int 2461 diskfile_recv(struct iperf_stream *sp) 2462 { 2463 int r; 2464 2465 r = sp->rcv2(sp); 2466 if (r > 0) { 2467 (void) write(sp->diskfile_fd, sp->buffer, r); 2468 (void) fsync(sp->diskfile_fd); 2469 } 2470 return r; 2471 } 2472 2473 2474 void 2475 iperf_catch_sigend(void (*handler)(int)) 2476 { 2477 signal(SIGINT, handler); 2478 signal(SIGTERM, handler); 2479 signal(SIGHUP, handler); 2480 } 2481 2482 /** 2483 * Called as a result of getting a signal. 2484 * Depending on the current state of the test (and the role of this 2485 * process) compute and report one more set of ending statistics 2486 * before cleaning up and exiting. 2487 */ 2488 void 2489 iperf_got_sigend(struct iperf_test *test) 2490 { 2491 /* 2492 * If we're the client, or if we're a server and running a test, 2493 * then dump out the accumulated stats so far. 2494 */ 2495 if (test->role == 'c' || 2496 (test->role == 's' && test->state == TEST_RUNNING)) { 2497 2498 test->done = 1; 2499 cpu_util(test->cpu_util); 2500 test->stats_callback(test); 2501 test->state = DISPLAY_RESULTS; /* change local state only */ 2502 if (test->on_test_finish) 2503 test->on_test_finish(test); 2504 test->reporter_callback(test); 2505 } 2506 2507 if (test->ctrl_sck >= 0) { 2508 test->state = (test->role == 'c') ? CLIENT_TERMINATE : SERVER_TERMINATE; 2509 (void) Nwrite(test->ctrl_sck, (char*) &test->state, sizeof(signed char), Ptcp); 2510 } 2511 i_errno = (test->role == 'c') ? IECLIENTTERM : IESERVERTERM; 2512 iperf_errexit(test, "interrupt - %s", iperf_strerror(i_errno)); 2513 } 2514 2515 /* Try to write a PID file if requested, return -1 on an error. */ 2516 int 2517 iperf_create_pidfile(struct iperf_test *test) 2518 { 2519 if (test->pidfile) { 2520 int fd; 2521 char buf[8]; 2522 fd = open(test->pidfile, O_WRONLY | O_CREAT | O_TRUNC, 0666); 2523 if (fd < 0) { 2524 return -1; 2525 } 2526 snprintf(buf, sizeof(buf), "%d", getpid()); /* no trailing newline */ 2527 if (write(fd, buf, strlen(buf) + 1) < 0) { 2528 return -1; 2529 } 2530 if (close(fd) < 0) { 2531 return -1; 2532 }; 2533 } 2534 return 0; 2535 } 2536 2537 /* Get rid of a PID file, return -1 on error. */ 2538 int 2539 iperf_delete_pidfile(struct iperf_test *test) 2540 { 2541 if (test->pidfile) { 2542 if (unlink(test->pidfile) < 0) { 2543 return -1; 2544 } 2545 } 2546 return 0; 2547 } 2548 2549 int 2550 iperf_json_start(struct iperf_test *test) 2551 { 2552 test->json_top = cJSON_CreateObject(); 2553 if (test->json_top == NULL) 2554 return -1; 2555 if (test->title) 2556 cJSON_AddStringToObject(test->json_top, "title", test->title); 2557 test->json_start = cJSON_CreateObject(); 2558 if (test->json_start == NULL) 2559 return -1; 2560 cJSON_AddItemToObject(test->json_top, "start", test->json_start); 2561 test->json_intervals = cJSON_CreateArray(); 2562 if (test->json_intervals == NULL) 2563 return -1; 2564 cJSON_AddItemToObject(test->json_top, "intervals", test->json_intervals); 2565 test->json_end = cJSON_CreateObject(); 2566 if (test->json_end == NULL) 2567 return -1; 2568 cJSON_AddItemToObject(test->json_top, "end", test->json_end); 2569 return 0; 2570 } 2571 2572 int 2573 iperf_json_finish(struct iperf_test *test) 2574 { 2575 test->json_output_string = cJSON_Print(test->json_top); 2576 if (test->json_output_string == NULL) 2577 return -1; 2578 fprintf(test->outfile, "%s\n", test->json_output_string); 2579 iflush(test); 2580 cJSON_Delete(test->json_top); 2581 test->json_top = test->json_start = test->json_intervals = test->json_end = NULL; 2582 return 0; 2583 } 2584 2585 2586 /* CPU affinity stuff - Linux and FreeBSD only. */ 2587 2588 int 2589 iperf_setaffinity(struct iperf_test *test, int affinity) 2590 { 2591 #if defined(HAVE_SCHED_SETAFFINITY) 2592 cpu_set_t cpu_set; 2593 2594 CPU_ZERO(&cpu_set); 2595 CPU_SET(affinity, &cpu_set); 2596 if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) != 0) { 2597 i_errno = IEAFFINITY; 2598 return -1; 2599 } 2600 return 0; 2601 #elif defined(HAVE_CPUSET_SETAFFINITY) 2602 cpuset_t cpumask; 2603 2604 if(cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, 2605 sizeof(cpuset_t), &test->cpumask) != 0) { 2606 i_errno = IEAFFINITY; 2607 return -1; 2608 } 2609 2610 CPU_ZERO(&cpumask); 2611 CPU_SET(affinity, &cpumask); 2612 2613 if(cpuset_setaffinity(CPU_LEVEL_WHICH,CPU_WHICH_PID, -1, 2614 sizeof(cpuset_t), &cpumask) != 0) { 2615 i_errno = IEAFFINITY; 2616 return -1; 2617 } 2618 return 0; 2619 #else /* neither HAVE_SCHED_SETAFFINITY nor HAVE_CPUSET_SETAFFINITY */ 2620 i_errno = IEAFFINITY; 2621 return -1; 2622 #endif /* neither HAVE_SCHED_SETAFFINITY nor HAVE_CPUSET_SETAFFINITY */ 2623 } 2624 2625 int 2626 iperf_clearaffinity(struct iperf_test *test) 2627 { 2628 #if defined(HAVE_SCHED_SETAFFINITY) 2629 cpu_set_t cpu_set; 2630 int i; 2631 2632 CPU_ZERO(&cpu_set); 2633 for (i = 0; i < CPU_SETSIZE; ++i) 2634 CPU_SET(i, &cpu_set); 2635 if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) != 0) { 2636 i_errno = IEAFFINITY; 2637 return -1; 2638 } 2639 return 0; 2640 #elif defined(HAVE_CPUSET_SETAFFINITY) 2641 if(cpuset_setaffinity(CPU_LEVEL_WHICH,CPU_WHICH_PID, -1, 2642 sizeof(cpuset_t), &test->cpumask) != 0) { 2643 i_errno = IEAFFINITY; 2644 return -1; 2645 } 2646 return 0; 2647 #else /* neither HAVE_SCHED_SETAFFINITY nor HAVE_CPUSET_SETAFFINITY */ 2648 i_errno = IEAFFINITY; 2649 return -1; 2650 #endif /* neither HAVE_SCHED_SETAFFINITY nor HAVE_CPUSET_SETAFFINITY */ 2651 } 2652 2653 int 2654 iprintf(struct iperf_test *test, const char* format, ...) 2655 { 2656 va_list argp; 2657 int r; 2658 2659 if (test->title) 2660 fprintf(test->outfile, "%s: ", test->title); 2661 va_start(argp, format); 2662 r = vfprintf(test->outfile, format, argp); 2663 va_end(argp); 2664 return r; 2665 } 2666 2667 int 2668 iflush(struct iperf_test *test) 2669 { 2670 return fflush(test->outfile); 2671 } 2672