1: /*
2: * iperf, Copyright (c) 2014, 2016, The Regents of the University of
3: * California, through Lawrence Berkeley National Laboratory (subject
4: * to receipt of any required approvals from the U.S. Dept. of
5: * Energy). All rights reserved.
6: *
7: * If you have questions about your rights to use or distribute this
8: * software, please contact Berkeley Lab's Technology Transfer
9: * Department at TTD@lbl.gov.
10: *
11: * NOTICE. This software is owned by the U.S. Department of Energy.
12: * As such, the U.S. Government has been granted for itself and others
13: * acting on its behalf a paid-up, nonexclusive, irrevocable,
14: * worldwide license in the Software to reproduce, prepare derivative
15: * works, and perform publicly and display publicly. Beginning five
16: * (5) years after the date permission to assert copyright is obtained
17: * from the U.S. Department of Energy, and subject to any subsequent
18: * five (5) year renewals, the U.S. Government is granted for itself
19: * and others acting on its behalf a paid-up, nonexclusive,
20: * irrevocable, worldwide license in the Software to reproduce,
21: * prepare derivative works, distribute copies to the public, perform
22: * publicly and display publicly, and to permit others to do so.
23: *
24: * This code is distributed under a BSD style license, see the LICENSE
25: * file for complete information.
26: */
27: #include <stdio.h>
28: #include <stdlib.h>
29: #include <string.h>
30: #include <errno.h>
31: #include <unistd.h>
32: #include <assert.h>
33: #include <sys/socket.h>
34: #include <sys/types.h>
35: #include <netinet/in.h>
36: #ifdef HAVE_STDINT_H
37: #include <stdint.h>
38: #endif
39: #include <sys/time.h>
40: #include <sys/select.h>
41:
42: #include "iperf.h"
43: #include "iperf_api.h"
44: #include "iperf_util.h"
45: #include "iperf_udp.h"
46: #include "timer.h"
47: #include "net.h"
48: #include "portable_endian.h"
49:
50: /* iperf_udp_recv
51: *
52: * receives the data for UDP
53: */
54: int
55: iperf_udp_recv(struct iperf_stream *sp)
56: {
57: uint32_t sec, usec;
58: uint64_t pcount;
59: int r;
60: int size = sp->settings->blksize;
61: double transit = 0, d = 0;
62: struct timeval sent_time, arrival_time;
63:
64: r = Nread(sp->socket, sp->buffer, size, Pudp);
65:
66: /*
67: * If we got an error in the read, or if we didn't read anything
68: * because the underlying read(2) got a EAGAIN, then skip packet
69: * processing.
70: */
71: if (r <= 0)
72: return r;
73:
74: sp->result->bytes_received += r;
75: sp->result->bytes_received_this_interval += r;
76:
77: if (sp->test->udp_counters_64bit) {
78: memcpy(&sec, sp->buffer, sizeof(sec));
79: memcpy(&usec, sp->buffer+4, sizeof(usec));
80: memcpy(&pcount, sp->buffer+8, sizeof(pcount));
81: sec = ntohl(sec);
82: usec = ntohl(usec);
83: pcount = be64toh(pcount);
84: sent_time.tv_sec = sec;
85: sent_time.tv_usec = usec;
86: }
87: else {
88: uint32_t pc;
89: memcpy(&sec, sp->buffer, sizeof(sec));
90: memcpy(&usec, sp->buffer+4, sizeof(usec));
91: memcpy(&pc, sp->buffer+8, sizeof(pc));
92: sec = ntohl(sec);
93: usec = ntohl(usec);
94: pcount = ntohl(pc);
95: sent_time.tv_sec = sec;
96: sent_time.tv_usec = usec;
97: }
98:
99: /* Out of order packets */
100: if (pcount >= sp->packet_count + 1) {
101: if (pcount > sp->packet_count + 1) {
102: sp->cnt_error += (pcount - 1) - sp->packet_count;
103: }
104: sp->packet_count = pcount;
105: } else {
106: sp->outoforder_packets++;
107: iperf_err(sp->test, "OUT OF ORDER - incoming packet = %zu and received packet = %d AND SP = %d", pcount, sp->packet_count, sp->socket);
108: }
109:
110: /* jitter measurement */
111: gettimeofday(&arrival_time, NULL);
112:
113: transit = timeval_diff(&sent_time, &arrival_time);
114: d = transit - sp->prev_transit;
115: if (d < 0)
116: d = -d;
117: sp->prev_transit = transit;
118: // XXX: This is NOT the way to calculate jitter
119: // J = |(R1 - S1) - (R0 - S0)| [/ number of packets, for average]
120: sp->jitter += (d - sp->jitter) / 16.0;
121:
122: if (sp->test->debug) {
123: fprintf(stderr, "packet_count %d\n", sp->packet_count);
124: }
125:
126: return r;
127: }
128:
129:
130: /* iperf_udp_send
131: *
132: * sends the data for UDP
133: */
134: int
135: iperf_udp_send(struct iperf_stream *sp)
136: {
137: int r;
138: int size = sp->settings->blksize;
139: struct timeval before;
140:
141: gettimeofday(&before, 0);
142:
143: ++sp->packet_count;
144:
145: if (sp->test->udp_counters_64bit) {
146:
147: uint32_t sec, usec;
148: uint64_t pcount;
149:
150: sec = htonl(before.tv_sec);
151: usec = htonl(before.tv_usec);
152: pcount = htobe64(sp->packet_count);
153:
154: memcpy(sp->buffer, &sec, sizeof(sec));
155: memcpy(sp->buffer+4, &usec, sizeof(usec));
156: memcpy(sp->buffer+8, &pcount, sizeof(pcount));
157:
158: }
159: else {
160:
161: uint32_t sec, usec, pcount;
162:
163: sec = htonl(before.tv_sec);
164: usec = htonl(before.tv_usec);
165: pcount = htonl(sp->packet_count);
166:
167: memcpy(sp->buffer, &sec, sizeof(sec));
168: memcpy(sp->buffer+4, &usec, sizeof(usec));
169: memcpy(sp->buffer+8, &pcount, sizeof(pcount));
170:
171: }
172:
173: r = Nwrite(sp->socket, sp->buffer, size, Pudp);
174:
175: if (r < 0)
176: return r;
177:
178: sp->result->bytes_sent += r;
179: sp->result->bytes_sent_this_interval += r;
180:
181: return r;
182: }
183:
184:
185: /**************************************************************************/
186:
187: /*
188: * The following functions all have to do with managing UDP data sockets.
189: * UDP of course is connectionless, so there isn't really a concept of
190: * setting up a connection, although connect(2) can (and is) used to
191: * bind the remote end of sockets. We need to simulate some of the
192: * connection management that is built-in to TCP so that each side of the
193: * connection knows about each other before the real data transfers begin.
194: */
195:
196: /*
197: * iperf_udp_accept
198: *
199: * Accepts a new UDP "connection"
200: */
201: int
202: iperf_udp_accept(struct iperf_test *test)
203: {
204: struct sockaddr_storage sa_peer;
205: int buf;
206: socklen_t len;
207: int sz, s;
208:
209: /*
210: * Get the current outstanding socket. This socket will be used to handle
211: * data transfers and a new "listening" socket will be created.
212: */
213: s = test->prot_listener;
214:
215: /*
216: * Grab the UDP packet sent by the client. From that we can extract the
217: * client's address, and then use that information to bind the remote side
218: * of the socket to the client.
219: */
220: len = sizeof(sa_peer);
221: if ((sz = recvfrom(test->prot_listener, &buf, sizeof(buf), 0, (struct sockaddr *) &sa_peer, &len)) < 0) {
222: i_errno = IESTREAMACCEPT;
223: return -1;
224: }
225:
226: if (connect(s, (struct sockaddr *) &sa_peer, len) < 0) {
227: i_errno = IESTREAMACCEPT;
228: return -1;
229: }
230:
231: /*
232: * Set socket buffer size if requested. Do this for both sending and
233: * receiving so that we can cover both normal and --reverse operation.
234: */
235: int opt;
236: if ((opt = test->settings->socket_bufsize)) {
237: if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) < 0) {
238: i_errno = IESETBUF;
239: return -1;
240: }
241: if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) < 0) {
242: i_errno = IESETBUF;
243: return -1;
244: }
245: }
246:
247: #if defined(HAVE_SO_MAX_PACING_RATE)
248: /* If socket pacing is available and not disabled, try it. */
249: if (! test->no_fq_socket_pacing) {
250: /* Convert bits per second to bytes per second */
251: unsigned int rate = test->settings->rate / 8;
252: if (rate > 0) {
253: if (test->debug) {
254: printf("Setting fair-queue socket pacing to %u\n", rate);
255: }
256: if (setsockopt(s, SOL_SOCKET, SO_MAX_PACING_RATE, &rate, sizeof(rate)) < 0) {
257: warning("Unable to set socket pacing, using application pacing instead");
258: test->no_fq_socket_pacing = 1;
259: }
260: }
261: }
262: #endif /* HAVE_SO_MAX_PACING_RATE */
263:
264: /*
265: * Create a new "listening" socket to replace the one we were using before.
266: */
267: test->prot_listener = netannounce(test->settings->domain, Pudp, test->bind_address, test->server_port);
268: if (test->prot_listener < 0) {
269: i_errno = IESTREAMLISTEN;
270: return -1;
271: }
272:
273: FD_SET(test->prot_listener, &test->read_set);
274: test->max_fd = (test->max_fd < test->prot_listener) ? test->prot_listener : test->max_fd;
275:
276: /* Let the client know we're ready "accept" another UDP "stream" */
277: buf = 987654321; /* any content will work here */
278: if (write(s, &buf, sizeof(buf)) < 0) {
279: i_errno = IESTREAMWRITE;
280: return -1;
281: }
282:
283: return s;
284: }
285:
286:
287: /*
288: * iperf_udp_listen
289: *
290: * Start up a listener for UDP stream connections. Unlike for TCP,
291: * there is no listen(2) for UDP. This socket will however accept
292: * a UDP datagram from a client (indicating the client's presence).
293: */
294: int
295: iperf_udp_listen(struct iperf_test *test)
296: {
297: int s;
298:
299: if ((s = netannounce(test->settings->domain, Pudp, test->bind_address, test->server_port)) < 0) {
300: i_errno = IESTREAMLISTEN;
301: return -1;
302: }
303:
304: /*
305: * The caller will put this value into test->prot_listener.
306: */
307: return s;
308: }
309:
310:
311: /*
312: * iperf_udp_connect
313: *
314: * "Connect" to a UDP stream listener.
315: */
316: int
317: iperf_udp_connect(struct iperf_test *test)
318: {
319: int s, buf, sz;
320: #ifdef SO_RCVTIMEO
321: struct timeval tv;
322: #endif
323:
324: /* Create and bind our local socket. */
325: if ((s = netdial(test->settings->domain, Pudp, test->bind_address, test->bind_port, test->server_hostname, test->server_port)) < 0) {
326: i_errno = IESTREAMCONNECT;
327: return -1;
328: }
329:
330: /*
331: * Set socket buffer size if requested. Do this for both sending and
332: * receiving so that we can cover both normal and --reverse operation.
333: */
334: int opt;
335: if ((opt = test->settings->socket_bufsize)) {
336: if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) < 0) {
337: i_errno = IESETBUF;
338: return -1;
339: }
340: if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) < 0) {
341: i_errno = IESETBUF;
342: return -1;
343: }
344: }
345:
346: #if defined(HAVE_SO_MAX_PACING_RATE)
347: /* If socket pacing is available and not disabled, try it. */
348: if (! test->no_fq_socket_pacing) {
349: /* Convert bits per second to bytes per second */
350: unsigned int rate = test->settings->rate / 8;
351: if (rate > 0) {
352: if (test->debug) {
353: printf("Setting fair-queue socket pacing to %u\n", rate);
354: }
355: if (setsockopt(s, SOL_SOCKET, SO_MAX_PACING_RATE, &rate, sizeof(rate)) < 0) {
356: warning("Unable to set socket pacing, using application pacing instead");
357: test->no_fq_socket_pacing = 1;
358: }
359: }
360: }
361: #endif /* HAVE_SO_MAX_PACING_RATE */
362:
363: #ifdef SO_RCVTIMEO
364: /* 30 sec timeout for a case when there is a network problem. */
365: tv.tv_sec = 30;
366: tv.tv_usec = 0;
367: setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (struct timeval *)&tv, sizeof(struct timeval));
368: #endif
369:
370: /*
371: * Write a datagram to the UDP stream to let the server know we're here.
372: * The server learns our address by obtaining its peer's address.
373: */
374: buf = 123456789; /* this can be pretty much anything */
375: if (write(s, &buf, sizeof(buf)) < 0) {
376: // XXX: Should this be changed to IESTREAMCONNECT?
377: i_errno = IESTREAMWRITE;
378: return -1;
379: }
380:
381: /*
382: * Wait until the server replies back to us.
383: */
384: if ((sz = recv(s, &buf, sizeof(buf), 0)) < 0) {
385: i_errno = IESTREAMREAD;
386: return -1;
387: }
388:
389: return s;
390: }
391:
392:
393: /* iperf_udp_init
394: *
395: * initializer for UDP streams in TEST_START
396: */
397: int
398: iperf_udp_init(struct iperf_test *test)
399: {
400: return 0;
401: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to iperf_udp.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