Annotation of embedaddon/iperf/src/iperf_server_api.c, revision 1.1.1.1
1.1 misho 1: /*
2: * iperf, Copyright (c) 2014, 2015, The Regents of the University of
3: * California, through Lawrence Berkeley National Laboratory (subject
4: * to receipt of any required approvals from the U.S. Dept. of
5: * Energy). All rights reserved.
6: *
7: * If you have questions about your rights to use or distribute this
8: * software, please contact Berkeley Lab's Technology Transfer
9: * Department at TTD@lbl.gov.
10: *
11: * NOTICE. This software is owned by the U.S. Department of Energy.
12: * As such, the U.S. Government has been granted for itself and others
13: * acting on its behalf a paid-up, nonexclusive, irrevocable,
14: * worldwide license in the Software to reproduce, prepare derivative
15: * works, and perform publicly and display publicly. Beginning five
16: * (5) years after the date permission to assert copyright is obtained
17: * from the U.S. Department of Energy, and subject to any subsequent
18: * five (5) year renewals, the U.S. Government is granted for itself
19: * and others acting on its behalf a paid-up, nonexclusive,
20: * irrevocable, worldwide license in the Software to reproduce,
21: * prepare derivative works, distribute copies to the public, perform
22: * publicly and display publicly, and to permit others to do so.
23: *
24: * This code is distributed under a BSD style license, see the LICENSE
25: * file for complete information.
26: */
27: /* 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: #include <pthread.h>
44: #ifdef HAVE_STDINT_H
45: #include <stdint.h>
46: #endif
47: #include <netinet/tcp.h>
48: #include <sys/time.h>
49: #include <sys/resource.h>
50: #include <sched.h>
51: #include <setjmp.h>
52:
53: #include "iperf.h"
54: #include "iperf_api.h"
55: #include "iperf_udp.h"
56: #include "iperf_tcp.h"
57: #include "iperf_util.h"
58: #include "timer.h"
59: #include "net.h"
60: #include "units.h"
61: #include "tcp_window_size.h"
62: #include "iperf_util.h"
63: #include "iperf_locale.h"
64:
65:
66: int
67: iperf_server_listen(struct iperf_test *test)
68: {
69: retry:
70: if((test->listener = netannounce(test->settings->domain, Ptcp, test->bind_address, test->server_port)) < 0) {
71: if (errno == EAFNOSUPPORT && (test->settings->domain == AF_INET6 || test->settings->domain == AF_UNSPEC)) {
72: /* If we get "Address family not supported by protocol", that
73: ** probably means we were compiled with IPv6 but the running
74: ** kernel does not actually do IPv6. This is not too unusual,
75: ** v6 support is and perhaps always will be spotty.
76: */
77: warning("this system does not seem to support IPv6 - trying IPv4");
78: test->settings->domain = AF_INET;
79: goto retry;
80: } else {
81: i_errno = IELISTEN;
82: return -1;
83: }
84: }
85:
86: if (!test->json_output) {
87: iprintf(test, "-----------------------------------------------------------\n");
88: iprintf(test, "Server listening on %d\n", test->server_port);
89: }
90:
91: // This needs to be changed to reflect if client has different window size
92: // make sure we got what we asked for
93: /* XXX: This needs to be moved to the stream listener
94: if ((x = get_tcp_windowsize(test->listener, SO_RCVBUF)) < 0) {
95: // Needs to set some sort of error number/message
96: perror("SO_RCVBUF");
97: return -1;
98: }
99: */
100:
101: // XXX: This code needs to be moved to after parameter exhange
102: /*
103: char ubuf[UNIT_LEN];
104: int x;
105:
106: if (test->protocol->id == Ptcp) {
107: if (test->settings->socket_bufsize > 0) {
108: unit_snprintf(ubuf, UNIT_LEN, (double) x, 'A');
109: if (!test->json_output)
110: iprintf(test, report_window, ubuf);
111: } else {
112: if (!test->json_output)
113: iprintf(test, "%s", report_autotune);
114: }
115: }
116: */
117: if (!test->json_output)
118: iprintf(test, "-----------------------------------------------------------\n");
119:
120: FD_ZERO(&test->read_set);
121: FD_ZERO(&test->write_set);
122: FD_SET(test->listener, &test->read_set);
123: if (test->listener > test->max_fd) test->max_fd = test->listener;
124:
125: return 0;
126: }
127:
128: int
129: iperf_accept(struct iperf_test *test)
130: {
131: int s;
132: signed char rbuf = ACCESS_DENIED;
133: socklen_t len;
134: struct sockaddr_storage addr;
135:
136: len = sizeof(addr);
137: if ((s = accept(test->listener, (struct sockaddr *) &addr, &len)) < 0) {
138: i_errno = IEACCEPT;
139: return -1;
140: }
141:
142: if (test->ctrl_sck == -1) {
143: /* Server free, accept new client */
144: test->ctrl_sck = s;
145: if (Nread(test->ctrl_sck, test->cookie, COOKIE_SIZE, Ptcp) < 0) {
146: i_errno = IERECVCOOKIE;
147: return -1;
148: }
149: FD_SET(test->ctrl_sck, &test->read_set);
150: if (test->ctrl_sck > test->max_fd) test->max_fd = test->ctrl_sck;
151:
152: if (iperf_set_send_state(test, PARAM_EXCHANGE) != 0)
153: return -1;
154: if (iperf_exchange_parameters(test) < 0)
155: return -1;
156: if (test->server_affinity != -1)
157: if (iperf_setaffinity(test, test->server_affinity) != 0)
158: return -1;
159: if (test->on_connect)
160: test->on_connect(test);
161: } else {
162: /*
163: * Don't try to read from the socket. It could block an ongoing test.
164: * Just send ACCESS_DENIED.
165: */
166: if (Nwrite(s, (char*) &rbuf, sizeof(rbuf), Ptcp) < 0) {
167: i_errno = IESENDMESSAGE;
168: return -1;
169: }
170: close(s);
171: }
172:
173: return 0;
174: }
175:
176:
177: /**************************************************************************/
178: int
179: iperf_handle_message_server(struct iperf_test *test)
180: {
181: int rval;
182: struct iperf_stream *sp;
183:
184: // XXX: Need to rethink how this behaves to fit API
185: if ((rval = Nread(test->ctrl_sck, (char*) &test->state, sizeof(signed char), Ptcp)) <= 0) {
186: if (rval == 0) {
187: iperf_err(test, "the client has unexpectedly closed the connection");
188: i_errno = IECTRLCLOSE;
189: test->state = IPERF_DONE;
190: return 0;
191: } else {
192: i_errno = IERECVMESSAGE;
193: return -1;
194: }
195: }
196:
197: switch(test->state) {
198: case TEST_START:
199: break;
200: case TEST_END:
201: test->done = 1;
202: cpu_util(test->cpu_util);
203: test->stats_callback(test);
204: SLIST_FOREACH(sp, &test->streams, streams) {
205: FD_CLR(sp->socket, &test->read_set);
206: FD_CLR(sp->socket, &test->write_set);
207: close(sp->socket);
208: }
209: test->reporter_callback(test);
210: if (iperf_set_send_state(test, EXCHANGE_RESULTS) != 0)
211: return -1;
212: if (iperf_exchange_results(test) < 0)
213: return -1;
214: if (iperf_set_send_state(test, DISPLAY_RESULTS) != 0)
215: return -1;
216: if (test->on_test_finish)
217: test->on_test_finish(test);
218: break;
219: case IPERF_DONE:
220: break;
221: case CLIENT_TERMINATE:
222: i_errno = IECLIENTTERM;
223:
224: // Temporarily be in DISPLAY_RESULTS phase so we can get
225: // ending summary statistics.
226: signed char oldstate = test->state;
227: cpu_util(test->cpu_util);
228: test->state = DISPLAY_RESULTS;
229: test->reporter_callback(test);
230: test->state = oldstate;
231:
232: // XXX: Remove this line below!
233: iperf_err(test, "the client has terminated");
234: SLIST_FOREACH(sp, &test->streams, streams) {
235: FD_CLR(sp->socket, &test->read_set);
236: FD_CLR(sp->socket, &test->write_set);
237: close(sp->socket);
238: }
239: test->state = IPERF_DONE;
240: break;
241: default:
242: i_errno = IEMESSAGE;
243: return -1;
244: }
245:
246: return 0;
247: }
248:
249: /* XXX: This function is not used anymore */
250: void
251: iperf_test_reset(struct iperf_test *test)
252: {
253: struct iperf_stream *sp;
254:
255: close(test->ctrl_sck);
256:
257: /* Free streams */
258: while (!SLIST_EMPTY(&test->streams)) {
259: sp = SLIST_FIRST(&test->streams);
260: SLIST_REMOVE_HEAD(&test->streams, streams);
261: iperf_free_stream(sp);
262: }
263: if (test->timer != NULL) {
264: tmr_cancel(test->timer);
265: test->timer = NULL;
266: }
267: if (test->stats_timer != NULL) {
268: tmr_cancel(test->stats_timer);
269: test->stats_timer = NULL;
270: }
271: if (test->reporter_timer != NULL) {
272: tmr_cancel(test->reporter_timer);
273: test->reporter_timer = NULL;
274: }
275: test->done = 0;
276:
277: SLIST_INIT(&test->streams);
278:
279: test->role = 's';
280: set_protocol(test, Ptcp);
281: test->omit = OMIT;
282: test->duration = DURATION;
283: test->diskfile_name = (char*) 0;
284: test->affinity = -1;
285: test->server_affinity = -1;
286: test->title = NULL;
287: test->congestion = NULL;
288: test->state = 0;
289: test->server_hostname = NULL;
290:
291: test->ctrl_sck = -1;
292: test->prot_listener = -1;
293:
294: test->bytes_sent = 0;
295:
296: test->reverse = 0;
297: test->sender = 0;
298: test->sender_has_retransmits = 0;
299: test->no_delay = 0;
300:
301: FD_ZERO(&test->read_set);
302: FD_ZERO(&test->write_set);
303: FD_SET(test->listener, &test->read_set);
304: test->max_fd = test->listener;
305:
306: test->num_streams = 1;
307: test->settings->socket_bufsize = 0;
308: test->settings->blksize = DEFAULT_TCP_BLKSIZE;
309: test->settings->rate = 0;
310: test->settings->mss = 0;
311: memset(test->cookie, 0, COOKIE_SIZE);
312: }
313:
314: static void
315: server_stats_timer_proc(TimerClientData client_data, struct timeval *nowP)
316: {
317: struct iperf_test *test = client_data.p;
318:
319: if (test->done)
320: return;
321: if (test->stats_callback)
322: test->stats_callback(test);
323: }
324:
325: static void
326: server_reporter_timer_proc(TimerClientData client_data, struct timeval *nowP)
327: {
328: struct iperf_test *test = client_data.p;
329:
330: if (test->done)
331: return;
332: if (test->reporter_callback)
333: test->reporter_callback(test);
334: }
335:
336: static int
337: create_server_timers(struct iperf_test * test)
338: {
339: struct timeval now;
340: TimerClientData cd;
341:
342: if (gettimeofday(&now, NULL) < 0) {
343: i_errno = IEINITTEST;
344: return -1;
345: }
346: cd.p = test;
347: test->stats_timer = test->reporter_timer = NULL;
348: if (test->stats_interval != 0) {
349: test->stats_timer = tmr_create(&now, server_stats_timer_proc, cd, test->stats_interval * SEC_TO_US, 1);
350: if (test->stats_timer == NULL) {
351: i_errno = IEINITTEST;
352: return -1;
353: }
354: }
355: if (test->reporter_interval != 0) {
356: test->reporter_timer = tmr_create(&now, server_reporter_timer_proc, cd, test->reporter_interval * SEC_TO_US, 1);
357: if (test->reporter_timer == NULL) {
358: i_errno = IEINITTEST;
359: return -1;
360: }
361: }
362: return 0;
363: }
364:
365: static void
366: server_omit_timer_proc(TimerClientData client_data, struct timeval *nowP)
367: {
368: struct iperf_test *test = client_data.p;
369:
370: test->omit_timer = NULL;
371: test->omitting = 0;
372: iperf_reset_stats(test);
373: if (test->verbose && !test->json_output && test->reporter_interval == 0)
374: iprintf(test, "%s", report_omit_done);
375:
376: /* Reset the timers. */
377: if (test->stats_timer != NULL)
378: tmr_reset(nowP, test->stats_timer);
379: if (test->reporter_timer != NULL)
380: tmr_reset(nowP, test->reporter_timer);
381: }
382:
383: static int
384: create_server_omit_timer(struct iperf_test * test)
385: {
386: struct timeval now;
387: TimerClientData cd;
388:
389: if (test->omit == 0) {
390: test->omit_timer = NULL;
391: test->omitting = 0;
392: } else {
393: if (gettimeofday(&now, NULL) < 0) {
394: i_errno = IEINITTEST;
395: return -1;
396: }
397: test->omitting = 1;
398: cd.p = test;
399: test->omit_timer = tmr_create(&now, server_omit_timer_proc, cd, test->omit * SEC_TO_US, 0);
400: if (test->omit_timer == NULL) {
401: i_errno = IEINITTEST;
402: return -1;
403: }
404: }
405:
406: return 0;
407: }
408:
409: static void
410: cleanup_server(struct iperf_test *test)
411: {
412: /* Close open test sockets */
413: close(test->ctrl_sck);
414: close(test->listener);
415:
416: /* Cancel any remaining timers. */
417: if (test->stats_timer != NULL) {
418: tmr_cancel(test->stats_timer);
419: test->stats_timer = NULL;
420: }
421: if (test->reporter_timer != NULL) {
422: tmr_cancel(test->reporter_timer);
423: test->reporter_timer = NULL;
424: }
425: if (test->omit_timer != NULL) {
426: tmr_cancel(test->omit_timer);
427: test->omit_timer = NULL;
428: }
429: }
430:
431:
432: int
433: iperf_run_server(struct iperf_test *test)
434: {
435: int result, s, streams_accepted;
436: fd_set read_set, write_set;
437: struct iperf_stream *sp;
438: struct timeval now;
439: struct timeval* timeout;
440:
441: if (test->affinity != -1)
442: if (iperf_setaffinity(test, test->affinity) != 0)
443: return -2;
444:
445: if (test->json_output)
446: if (iperf_json_start(test) < 0)
447: return -2;
448:
449: if (test->json_output) {
450: cJSON_AddItemToObject(test->json_start, "version", cJSON_CreateString(version));
451: cJSON_AddItemToObject(test->json_start, "system_info", cJSON_CreateString(get_system_info()));
452: } else if (test->verbose) {
453: iprintf(test, "%s\n", version);
454: iprintf(test, "%s", "");
455: iprintf(test, "%s\n", get_system_info());
456: iflush(test);
457: }
458:
459: // Open socket and listen
460: if (iperf_server_listen(test) < 0) {
461: return -2;
462: }
463:
464: // Begin calculating CPU utilization
465: cpu_util(NULL);
466:
467: test->state = IPERF_START;
468: streams_accepted = 0;
469:
470: while (test->state != IPERF_DONE) {
471:
472: memcpy(&read_set, &test->read_set, sizeof(fd_set));
473: memcpy(&write_set, &test->write_set, sizeof(fd_set));
474:
475: (void) gettimeofday(&now, NULL);
476: timeout = tmr_timeout(&now);
477: result = select(test->max_fd + 1, &read_set, &write_set, NULL, timeout);
478: if (result < 0 && errno != EINTR) {
479: cleanup_server(test);
480: i_errno = IESELECT;
481: return -1;
482: }
483: if (result > 0) {
484: if (FD_ISSET(test->listener, &read_set)) {
485: if (test->state != CREATE_STREAMS) {
486: if (iperf_accept(test) < 0) {
487: cleanup_server(test);
488: return -1;
489: }
490: FD_CLR(test->listener, &read_set);
491: }
492: }
493: if (FD_ISSET(test->ctrl_sck, &read_set)) {
494: if (iperf_handle_message_server(test) < 0) {
495: cleanup_server(test);
496: return -1;
497: }
498: FD_CLR(test->ctrl_sck, &read_set);
499: }
500:
501: if (test->state == CREATE_STREAMS) {
502: if (FD_ISSET(test->prot_listener, &read_set)) {
503:
504: if ((s = test->protocol->accept(test)) < 0) {
505: cleanup_server(test);
506: return -1;
507: }
508:
509: if (!is_closed(s)) {
510: sp = iperf_new_stream(test, s);
511: if (!sp) {
512: cleanup_server(test);
513: return -1;
514: }
515:
516: if (test->sender)
517: FD_SET(s, &test->write_set);
518: else
519: FD_SET(s, &test->read_set);
520: if (s > test->max_fd) test->max_fd = s;
521:
522: /*
523: * If the protocol isn't UDP, or even if it is but
524: * we're the receiver, set nonblocking sockets.
525: * We need this to allow a server receiver to
526: * maintain interactivity with the control channel.
527: */
528: if (test->protocol->id != Pudp ||
529: !test->sender) {
530: setnonblocking(s, 1);
531: }
532:
533: streams_accepted++;
534: if (test->on_new_stream)
535: test->on_new_stream(sp);
536: }
537: FD_CLR(test->prot_listener, &read_set);
538: }
539:
540: if (streams_accepted == test->num_streams) {
541: if (test->protocol->id != Ptcp) {
542: FD_CLR(test->prot_listener, &test->read_set);
543: close(test->prot_listener);
544: } else {
545: if (test->no_delay || test->settings->mss || test->settings->socket_bufsize) {
546: FD_CLR(test->listener, &test->read_set);
547: close(test->listener);
548: if ((s = netannounce(test->settings->domain, Ptcp, test->bind_address, test->server_port)) < 0) {
549: cleanup_server(test);
550: i_errno = IELISTEN;
551: return -1;
552: }
553: test->listener = s;
554: FD_SET(test->listener, &test->read_set);
555: if (test->listener > test->max_fd) test->max_fd = test->listener;
556: }
557: }
558: test->prot_listener = -1;
559: if (iperf_set_send_state(test, TEST_START) != 0) {
560: cleanup_server(test);
561: return -1;
562: }
563: if (iperf_init_test(test) < 0) {
564: cleanup_server(test);
565: return -1;
566: }
567: if (create_server_timers(test) < 0) {
568: cleanup_server(test);
569: return -1;
570: }
571: if (create_server_omit_timer(test) < 0) {
572: cleanup_server(test);
573: return -1;
574: }
575: if (test->reverse)
576: if (iperf_create_send_timers(test) < 0) {
577: cleanup_server(test);
578: return -1;
579: }
580: if (iperf_set_send_state(test, TEST_RUNNING) != 0) {
581: cleanup_server(test);
582: return -1;
583: }
584: }
585: }
586:
587: if (test->state == TEST_RUNNING) {
588: if (test->reverse) {
589: // Reverse mode. Server sends.
590: if (iperf_send(test, &write_set) < 0) {
591: cleanup_server(test);
592: return -1;
593: }
594: } else {
595: // Regular mode. Server receives.
596: if (iperf_recv(test, &read_set) < 0) {
597: cleanup_server(test);
598: return -1;
599: }
600: }
601: }
602: }
603:
604: if (result == 0 ||
605: (timeout != NULL && timeout->tv_sec == 0 && timeout->tv_usec == 0)) {
606: /* Run the timers. */
607: (void) gettimeofday(&now, NULL);
608: tmr_run(&now);
609: }
610: }
611:
612: cleanup_server(test);
613:
614: if (test->json_output) {
615: if (iperf_json_finish(test) < 0)
616: return -1;
617: }
618:
619: iflush(test);
620:
621: if (test->server_affinity != -1)
622: if (iperf_clearaffinity(test) != 0)
623: return -1;
624:
625: return 0;
626: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to iperf_server_api.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / iperf / src