Annotation of embedaddon/iperf/src/iperf_util.c, revision 1.1
1.1 ! misho 1: /*
! 2: * iperf, Copyright (c) 2014, 2016, The Regents of the University of
! 3: * California, through Lawrence Berkeley National Laboratory (subject
! 4: * to receipt of any required approvals from the U.S. Dept. of
! 5: * Energy). All rights reserved.
! 6: *
! 7: * If you have questions about your rights to use or distribute this
! 8: * software, please contact Berkeley Lab's Technology Transfer
! 9: * Department at TTD@lbl.gov.
! 10: *
! 11: * NOTICE. This software is owned by the U.S. Department of Energy.
! 12: * As such, the U.S. Government has been granted for itself and others
! 13: * acting on its behalf a paid-up, nonexclusive, irrevocable,
! 14: * worldwide license in the Software to reproduce, prepare derivative
! 15: * works, and perform publicly and display publicly. Beginning five
! 16: * (5) years after the date permission to assert copyright is obtained
! 17: * from the U.S. Department of Energy, and subject to any subsequent
! 18: * five (5) year renewals, the U.S. Government is granted for itself
! 19: * and others acting on its behalf a paid-up, nonexclusive,
! 20: * irrevocable, worldwide license in the Software to reproduce,
! 21: * prepare derivative works, distribute copies to the public, perform
! 22: * publicly and display publicly, and to permit others to do so.
! 23: *
! 24: * This code is distributed under a BSD style license, see the LICENSE
! 25: * file for complete information.
! 26: */
! 27: /* iperf_util.c
! 28: *
! 29: * Iperf utility functions
! 30: *
! 31: */
! 32: #include "iperf_config.h"
! 33:
! 34: #include <stdio.h>
! 35: #include <stdlib.h>
! 36: #include <unistd.h>
! 37: #include <string.h>
! 38: #include <stdarg.h>
! 39: #include <sys/select.h>
! 40: #include <sys/types.h>
! 41: #include <sys/time.h>
! 42: #include <sys/resource.h>
! 43: #include <sys/utsname.h>
! 44: #include <time.h>
! 45: #include <errno.h>
! 46:
! 47: #include "cjson.h"
! 48:
! 49: /* make_cookie
! 50: *
! 51: * Generate and return a cookie string
! 52: *
! 53: * Iperf uses this function to create test "cookies" which
! 54: * server as unique test identifiers. These cookies are also
! 55: * used for the authentication of stream connections.
! 56: */
! 57:
! 58: void
! 59: make_cookie(char *cookie)
! 60: {
! 61: static int randomized = 0;
! 62: char hostname[500];
! 63: struct timeval tv;
! 64: char temp[1000];
! 65:
! 66: if ( ! randomized )
! 67: srandom((int) time(0) ^ getpid());
! 68:
! 69: /* Generate a string based on hostname, time, randomness, and filler. */
! 70: (void) gethostname(hostname, sizeof(hostname));
! 71: (void) gettimeofday(&tv, 0);
! 72: (void) snprintf(temp, sizeof(temp), "%s.%ld.%06ld.%08lx%08lx.%s", hostname, (unsigned long int) tv.tv_sec, (unsigned long int) tv.tv_usec, (unsigned long int) random(), (unsigned long int) random(), "1234567890123456789012345678901234567890");
! 73:
! 74: /* Now truncate it to 36 bytes and terminate. */
! 75: memcpy(cookie, temp, 36);
! 76: cookie[36] = '\0';
! 77: }
! 78:
! 79:
! 80: /* is_closed
! 81: *
! 82: * Test if the file descriptor fd is closed.
! 83: *
! 84: * Iperf uses this function to test whether a TCP stream socket
! 85: * is closed, because accepting and denying an invalid connection
! 86: * in iperf_tcp_accept is not considered an error.
! 87: */
! 88:
! 89: int
! 90: is_closed(int fd)
! 91: {
! 92: struct timeval tv;
! 93: fd_set readset;
! 94:
! 95: FD_ZERO(&readset);
! 96: FD_SET(fd, &readset);
! 97: tv.tv_sec = 0;
! 98: tv.tv_usec = 0;
! 99:
! 100: if (select(fd+1, &readset, NULL, NULL, &tv) < 0) {
! 101: if (errno == EBADF)
! 102: return 1;
! 103: }
! 104: return 0;
! 105: }
! 106:
! 107:
! 108: double
! 109: timeval_to_double(struct timeval * tv)
! 110: {
! 111: double d;
! 112:
! 113: d = tv->tv_sec + tv->tv_usec / 1000000;
! 114:
! 115: return d;
! 116: }
! 117:
! 118: int
! 119: timeval_equals(struct timeval * tv0, struct timeval * tv1)
! 120: {
! 121: if ( tv0->tv_sec == tv1->tv_sec && tv0->tv_usec == tv1->tv_usec )
! 122: return 1;
! 123: else
! 124: return 0;
! 125: }
! 126:
! 127: double
! 128: timeval_diff(struct timeval * tv0, struct timeval * tv1)
! 129: {
! 130: double time1, time2;
! 131:
! 132: time1 = tv0->tv_sec + (tv0->tv_usec / 1000000.0);
! 133: time2 = tv1->tv_sec + (tv1->tv_usec / 1000000.0);
! 134:
! 135: time1 = time1 - time2;
! 136: if (time1 < 0)
! 137: time1 = -time1;
! 138: return time1;
! 139: }
! 140:
! 141:
! 142: int
! 143: delay(int64_t ns)
! 144: {
! 145: struct timespec req, rem;
! 146:
! 147: req.tv_sec = 0;
! 148:
! 149: while (ns >= 1000000000L) {
! 150: ns -= 1000000000L;
! 151: req.tv_sec += 1;
! 152: }
! 153:
! 154: req.tv_nsec = ns;
! 155:
! 156: while (nanosleep(&req, &rem) == -1)
! 157: if (EINTR == errno)
! 158: memcpy(&req, &rem, sizeof(rem));
! 159: else
! 160: return -1;
! 161: return 0;
! 162: }
! 163:
! 164: # ifdef DELAY_SELECT_METHOD
! 165: int
! 166: delay(int us)
! 167: {
! 168: struct timeval tv;
! 169:
! 170: tv.tv_sec = 0;
! 171: tv.tv_usec = us;
! 172: (void) select(1, (fd_set *) 0, (fd_set *) 0, (fd_set *) 0, &tv);
! 173: return 1;
! 174: }
! 175: #endif
! 176:
! 177:
! 178: void
! 179: cpu_util(double pcpu[3])
! 180: {
! 181: static struct timeval last;
! 182: static clock_t clast;
! 183: static struct rusage rlast;
! 184: struct timeval temp;
! 185: clock_t ctemp;
! 186: struct rusage rtemp;
! 187: double timediff;
! 188: double userdiff;
! 189: double systemdiff;
! 190:
! 191: if (pcpu == NULL) {
! 192: gettimeofday(&last, NULL);
! 193: clast = clock();
! 194: getrusage(RUSAGE_SELF, &rlast);
! 195: return;
! 196: }
! 197:
! 198: gettimeofday(&temp, NULL);
! 199: ctemp = clock();
! 200: getrusage(RUSAGE_SELF, &rtemp);
! 201:
! 202: timediff = ((temp.tv_sec * 1000000.0 + temp.tv_usec) -
! 203: (last.tv_sec * 1000000.0 + last.tv_usec));
! 204: userdiff = ((rtemp.ru_utime.tv_sec * 1000000.0 + rtemp.ru_utime.tv_usec) -
! 205: (rlast.ru_utime.tv_sec * 1000000.0 + rlast.ru_utime.tv_usec));
! 206: systemdiff = ((rtemp.ru_stime.tv_sec * 1000000.0 + rtemp.ru_stime.tv_usec) -
! 207: (rlast.ru_stime.tv_sec * 1000000.0 + rlast.ru_stime.tv_usec));
! 208:
! 209: pcpu[0] = (((ctemp - clast) * 1000000.0 / CLOCKS_PER_SEC) / timediff) * 100;
! 210: pcpu[1] = (userdiff / timediff) * 100;
! 211: pcpu[2] = (systemdiff / timediff) * 100;
! 212: }
! 213:
! 214: const char *
! 215: get_system_info(void)
! 216: {
! 217: static char buf[1024];
! 218: struct utsname uts;
! 219:
! 220: memset(buf, 0, 1024);
! 221: uname(&uts);
! 222:
! 223: snprintf(buf, sizeof(buf), "%s %s %s %s %s", uts.sysname, uts.nodename,
! 224: uts.release, uts.version, uts.machine);
! 225:
! 226: return buf;
! 227: }
! 228:
! 229:
! 230: const char *
! 231: get_optional_features(void)
! 232: {
! 233: static char features[1024];
! 234: unsigned int numfeatures = 0;
! 235:
! 236: snprintf(features, sizeof(features), "Optional features available: ");
! 237:
! 238: #if defined(HAVE_CPU_AFFINITY)
! 239: if (numfeatures > 0) {
! 240: strncat(features, ", ",
! 241: sizeof(features) - strlen(features) - 1);
! 242: }
! 243: strncat(features, "CPU affinity setting",
! 244: sizeof(features) - strlen(features) - 1);
! 245: numfeatures++;
! 246: #endif /* HAVE_CPU_AFFINITY */
! 247:
! 248: #if defined(HAVE_FLOWLABEL)
! 249: if (numfeatures > 0) {
! 250: strncat(features, ", ",
! 251: sizeof(features) - strlen(features) - 1);
! 252: }
! 253: strncat(features, "IPv6 flow label",
! 254: sizeof(features) - strlen(features) - 1);
! 255: numfeatures++;
! 256: #endif /* HAVE_FLOWLABEL */
! 257:
! 258: #if defined(HAVE_SCTP)
! 259: if (numfeatures > 0) {
! 260: strncat(features, ", ",
! 261: sizeof(features) - strlen(features) - 1);
! 262: }
! 263: strncat(features, "SCTP",
! 264: sizeof(features) - strlen(features) - 1);
! 265: numfeatures++;
! 266: #endif /* HAVE_SCTP */
! 267:
! 268: #if defined(HAVE_TCP_CONGESTION)
! 269: if (numfeatures > 0) {
! 270: strncat(features, ", ",
! 271: sizeof(features) - strlen(features) - 1);
! 272: }
! 273: strncat(features, "TCP congestion algorithm setting",
! 274: sizeof(features) - strlen(features) - 1);
! 275: numfeatures++;
! 276: #endif /* HAVE_TCP_CONGESTION */
! 277:
! 278: #if defined(HAVE_SENDFILE)
! 279: if (numfeatures > 0) {
! 280: strncat(features, ", ",
! 281: sizeof(features) - strlen(features) - 1);
! 282: }
! 283: strncat(features, "sendfile / zerocopy",
! 284: sizeof(features) - strlen(features) - 1);
! 285: numfeatures++;
! 286: #endif /* HAVE_SENDFILE */
! 287:
! 288: #if defined(HAVE_SO_MAX_PACING_RATE)
! 289: if (numfeatures > 0) {
! 290: strncat(features, ", ",
! 291: sizeof(features) - strlen(features) - 1);
! 292: }
! 293: strncat(features, "socket pacing",
! 294: sizeof(features) - strlen(features) - 1);
! 295: numfeatures++;
! 296: #endif /* HAVE_SO_MAX_PACING_RATE */
! 297:
! 298: if (numfeatures == 0) {
! 299: strncat(features, "None",
! 300: sizeof(features) - strlen(features) - 1);
! 301: }
! 302:
! 303: return features;
! 304: }
! 305:
! 306: /* Helper routine for building cJSON objects in a printf-like manner.
! 307: **
! 308: ** Sample call:
! 309: ** j = iperf_json_printf("foo: %b bar: %d bletch: %f eep: %s", b, i, f, s);
! 310: **
! 311: ** The four formatting characters and the types they expect are:
! 312: ** %b boolean int
! 313: ** %d integer int64_t
! 314: ** %f floating point double
! 315: ** %s string char *
! 316: ** If the values you're passing in are not these exact types, you must
! 317: ** cast them, there is no automatic type coercion/widening here.
! 318: **
! 319: ** The colons mark the end of field names, and blanks are ignored.
! 320: **
! 321: ** This routine is not particularly robust, but it's not part of the API,
! 322: ** it's just for internal iperf3 use.
! 323: */
! 324: cJSON*
! 325: iperf_json_printf(const char *format, ...)
! 326: {
! 327: cJSON* o;
! 328: va_list argp;
! 329: const char *cp;
! 330: char name[100];
! 331: char* np;
! 332: cJSON* j;
! 333:
! 334: o = cJSON_CreateObject();
! 335: if (o == NULL)
! 336: return NULL;
! 337: va_start(argp, format);
! 338: np = name;
! 339: for (cp = format; *cp != '\0'; ++cp) {
! 340: switch (*cp) {
! 341: case ' ':
! 342: break;
! 343: case ':':
! 344: *np = '\0';
! 345: break;
! 346: case '%':
! 347: ++cp;
! 348: switch (*cp) {
! 349: case 'b':
! 350: j = cJSON_CreateBool(va_arg(argp, int));
! 351: break;
! 352: case 'd':
! 353: j = cJSON_CreateNumber(va_arg(argp, int64_t));
! 354: break;
! 355: case 'f':
! 356: j = cJSON_CreateNumber(va_arg(argp, double));
! 357: break;
! 358: case 's':
! 359: j = cJSON_CreateString(va_arg(argp, char *));
! 360: break;
! 361: default:
! 362: va_end(argp);
! 363: return NULL;
! 364: }
! 365: if (j == NULL) {
! 366: va_end(argp);
! 367: return NULL;
! 368: }
! 369: cJSON_AddItemToObject(o, name, j);
! 370: np = name;
! 371: break;
! 372: default:
! 373: *np++ = *cp;
! 374: break;
! 375: }
! 376: }
! 377: va_end(argp);
! 378: return o;
! 379: }
! 380:
! 381: /* Debugging routine to dump out an fd_set. */
! 382: void
! 383: iperf_dump_fdset(FILE *fp, char *str, int nfds, fd_set *fds)
! 384: {
! 385: int fd;
! 386: int comma;
! 387:
! 388: fprintf(fp, "%s: [", str);
! 389: comma = 0;
! 390: for (fd = 0; fd < nfds; ++fd) {
! 391: if (FD_ISSET(fd, fds)) {
! 392: if (comma)
! 393: fprintf(fp, ", ");
! 394: fprintf(fp, "%d", fd);
! 395: comma = 1;
! 396: }
! 397: }
! 398: fprintf(fp, "]\n");
! 399: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to iperf_util.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