Annotation of embedaddon/mtr/packet/probe_unix.c, revision 1.1
1.1 ! misho 1: /*
! 2: mtr -- a network diagnostic tool
! 3: Copyright (C) 2016 Matt Kimball
! 4:
! 5: This program is free software; you can redistribute it and/or modify
! 6: it under the terms of the GNU General Public License version 2 as
! 7: published by the Free Software Foundation.
! 8:
! 9: This program is distributed in the hope that it will be useful,
! 10: but WITHOUT ANY WARRANTY; without even the implied warranty of
! 11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 12: GNU General Public License for more details.
! 13:
! 14: You should have received a copy of the GNU General Public License
! 15: along with this program; if not, write to the Free Software
! 16: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
! 17: */
! 18:
! 19: #include "probe.h"
! 20:
! 21: #include <assert.h>
! 22: #include <errno.h>
! 23: #include <fcntl.h>
! 24: #include <stdio.h>
! 25: #include <stdlib.h>
! 26: #include <string.h>
! 27: #include <sys/socket.h>
! 28: #include <unistd.h>
! 29:
! 30: #include "platform.h"
! 31: #include "protocols.h"
! 32: #include "construct_unix.h"
! 33: #include "deconstruct_unix.h"
! 34: #include "timeval.h"
! 35:
! 36: /* A wrapper around sendto for mixed IPv4 and IPv6 sending */
! 37: static
! 38: int send_packet(
! 39: const struct net_state_t *net_state,
! 40: const struct probe_param_t *param,
! 41: const char *packet,
! 42: int packet_size,
! 43: const struct sockaddr_storage *sockaddr)
! 44: {
! 45: int send_socket = 0;
! 46: int sockaddr_length;
! 47:
! 48: if (sockaddr->ss_family == AF_INET6) {
! 49: sockaddr_length = sizeof(struct sockaddr_in6);
! 50:
! 51: if (param->protocol == IPPROTO_ICMP) {
! 52: send_socket = net_state->platform.icmp6_send_socket;
! 53: } else if (param->protocol == IPPROTO_UDP) {
! 54: send_socket = net_state->platform.udp6_send_socket;
! 55: }
! 56: } else if (sockaddr->ss_family == AF_INET) {
! 57: sockaddr_length = sizeof(struct sockaddr_in);
! 58:
! 59: send_socket = net_state->platform.ip4_send_socket;
! 60: }
! 61:
! 62: if (send_socket == 0) {
! 63: errno = EINVAL;
! 64: return -1;
! 65: }
! 66:
! 67: return sendto(send_socket, packet, packet_size, 0,
! 68: (struct sockaddr *) sockaddr, sockaddr_length);
! 69: }
! 70:
! 71: /*
! 72: Nearly all fields in the IP header should be encoded in network byte
! 73: order prior to passing to send(). However, the required byte order of
! 74: the length field of the IP header is inconsistent between operating
! 75: systems and operating system versions. FreeBSD 11 requires the length
! 76: field in network byte order, but some older versions of FreeBSD
! 77: require host byte order. OS X requires the length field in host
! 78: byte order. Linux will accept either byte order.
! 79:
! 80: Test for a byte order which works by sending a ping to localhost.
! 81: */
! 82: static
! 83: void check_length_order(
! 84: struct net_state_t *net_state)
! 85: {
! 86: char packet[PACKET_BUFFER_SIZE];
! 87: struct probe_param_t param;
! 88: struct sockaddr_storage dest_sockaddr;
! 89: struct sockaddr_storage src_sockaddr;
! 90: ssize_t bytes_sent;
! 91: int packet_size;
! 92:
! 93: memset(¶m, 0, sizeof(struct probe_param_t));
! 94: param.ip_version = 4;
! 95: param.protocol = IPPROTO_ICMP;
! 96: param.ttl = 255;
! 97: param.remote_address = "127.0.0.1";
! 98:
! 99: if (resolve_probe_addresses(¶m, &dest_sockaddr, &src_sockaddr)) {
! 100: fprintf(stderr, "Error decoding localhost address\n");
! 101: exit(EXIT_FAILURE);
! 102: }
! 103:
! 104: /* First attempt to ping the localhost with network byte order */
! 105: net_state->platform.ip_length_host_order = false;
! 106:
! 107: packet_size = construct_packet(net_state, NULL, MIN_PORT,
! 108: packet, PACKET_BUFFER_SIZE,
! 109: &dest_sockaddr, &src_sockaddr, ¶m);
! 110: if (packet_size < 0) {
! 111: perror("Unable to send to localhost");
! 112: exit(EXIT_FAILURE);
! 113: }
! 114:
! 115: bytes_sent =
! 116: send_packet(net_state, ¶m, packet, packet_size,
! 117: &dest_sockaddr);
! 118: if (bytes_sent > 0) {
! 119: return;
! 120: }
! 121:
! 122: /* Since network byte order failed, try host byte order */
! 123: net_state->platform.ip_length_host_order = true;
! 124:
! 125: packet_size = construct_packet(net_state, NULL, MIN_PORT,
! 126: packet, PACKET_BUFFER_SIZE,
! 127: &dest_sockaddr, &src_sockaddr, ¶m);
! 128: if (packet_size < 0) {
! 129: perror("Unable to send to localhost");
! 130: exit(EXIT_FAILURE);
! 131: }
! 132:
! 133: bytes_sent =
! 134: send_packet(net_state, ¶m, packet, packet_size,
! 135: &dest_sockaddr);
! 136: if (bytes_sent < 0) {
! 137: perror("Unable to send with swapped length");
! 138: exit(EXIT_FAILURE);
! 139: }
! 140: }
! 141:
! 142: /*
! 143: Check to see if SCTP is support. We can't just rely on checking
! 144: if IPPROTO_SCTP is defined, because while that is necessary,
! 145: MacOS as of "Sierra" defines IPPROTO_SCTP, but creating an SCTP
! 146: socket results in an error.
! 147: */
! 148: static
! 149: void check_sctp_support(
! 150: struct net_state_t *net_state)
! 151: {
! 152: #ifdef IPPROTO_SCTP
! 153: int sctp_socket;
! 154:
! 155: sctp_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP);
! 156: if (sctp_socket != -1) {
! 157: close(sctp_socket);
! 158:
! 159: net_state->platform.sctp_support = true;
! 160: }
! 161: #endif
! 162: }
! 163:
! 164: /* Set a socket to non-blocking mode */
! 165: void set_socket_nonblocking(
! 166: int socket)
! 167: {
! 168: int flags;
! 169:
! 170: flags = fcntl(socket, F_GETFL, 0);
! 171: if (flags == -1) {
! 172: perror("Unexpected socket F_GETFL error");
! 173: exit(EXIT_FAILURE);
! 174: }
! 175:
! 176: if (fcntl(socket, F_SETFL, flags | O_NONBLOCK)) {
! 177: perror("Unexpected socket F_SETFL O_NONBLOCK error");
! 178: exit(EXIT_FAILURE);
! 179: }
! 180: }
! 181:
! 182: /* Open the raw sockets for sending/receiving IPv4 packets */
! 183: static
! 184: int open_ip4_sockets(
! 185: struct net_state_t *net_state)
! 186: {
! 187: int send_socket;
! 188: int recv_socket;
! 189: int trueopt = 1;
! 190:
! 191: send_socket = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
! 192: if (send_socket == -1) {
! 193: return -1;
! 194: }
! 195:
! 196: /*
! 197: We will be including the IP header in transmitted packets.
! 198: Linux doesn't require this, but BSD derived network stacks do.
! 199: */
! 200: if (setsockopt
! 201: (send_socket, IPPROTO_IP, IP_HDRINCL, &trueopt, sizeof(int))) {
! 202:
! 203: close(send_socket);
! 204: return -1;
! 205: }
! 206:
! 207: /*
! 208: Open a second socket with IPPROTO_ICMP because we are only
! 209: interested in receiving ICMP packets, not all packets.
! 210: */
! 211: recv_socket = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
! 212: if (recv_socket == -1) {
! 213: close(send_socket);
! 214: return -1;
! 215: }
! 216:
! 217: net_state->platform.ip4_present = true;
! 218: net_state->platform.ip4_send_socket = send_socket;
! 219: net_state->platform.ip4_recv_socket = recv_socket;
! 220:
! 221: return 0;
! 222: }
! 223:
! 224: /* Open the raw sockets for sending/receiving IPv6 packets */
! 225: static
! 226: int open_ip6_sockets(
! 227: struct net_state_t *net_state)
! 228: {
! 229: int send_socket_icmp;
! 230: int send_socket_udp;
! 231: int recv_socket;
! 232:
! 233: send_socket_icmp = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
! 234: if (send_socket_icmp == -1) {
! 235: return -1;
! 236: }
! 237:
! 238: send_socket_udp = socket(AF_INET6, SOCK_RAW, IPPROTO_UDP);
! 239: if (send_socket_udp == -1) {
! 240: close(send_socket_icmp);
! 241:
! 242: return -1;
! 243: }
! 244:
! 245: recv_socket = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
! 246: if (recv_socket == -1) {
! 247: close(send_socket_icmp);
! 248: close(send_socket_udp);
! 249:
! 250: return -1;
! 251: }
! 252:
! 253: net_state->platform.ip6_present = true;
! 254: net_state->platform.icmp6_send_socket = send_socket_icmp;
! 255: net_state->platform.udp6_send_socket = send_socket_udp;
! 256: net_state->platform.ip6_recv_socket = recv_socket;
! 257:
! 258: return 0;
! 259: }
! 260:
! 261: /*
! 262: The first half of the net state initialization. Since this
! 263: happens with elevated privileges, this is kept as minimal
! 264: as possible to minimize security risk.
! 265: */
! 266: void init_net_state_privileged(
! 267: struct net_state_t *net_state)
! 268: {
! 269: int ip4_err = 0;
! 270: int ip6_err = 0;
! 271:
! 272: memset(net_state, 0, sizeof(struct net_state_t));
! 273:
! 274: net_state->platform.next_sequence = MIN_PORT;
! 275:
! 276: if (open_ip4_sockets(net_state)) {
! 277: ip4_err = errno;
! 278: }
! 279: if (open_ip6_sockets(net_state)) {
! 280: ip6_err = errno;
! 281: }
! 282:
! 283: /*
! 284: If we couldn't open either IPv4 or IPv6 sockets, we can't do
! 285: much, so print errors and exit.
! 286: */
! 287: if (!net_state->platform.ip4_present
! 288: && !net_state->platform.ip6_present) {
! 289:
! 290: errno = ip4_err;
! 291: perror("Failure to open IPv4 sockets");
! 292:
! 293: errno = ip6_err;
! 294: perror("Failure to open IPv6 sockets");
! 295:
! 296: exit(EXIT_FAILURE);
! 297: }
! 298: }
! 299:
! 300: /*
! 301: The second half of net state initialization, which is run
! 302: at normal privilege levels.
! 303: */
! 304: void init_net_state(
! 305: struct net_state_t *net_state)
! 306: {
! 307: set_socket_nonblocking(net_state->platform.ip4_recv_socket);
! 308: set_socket_nonblocking(net_state->platform.ip6_recv_socket);
! 309:
! 310: if (net_state->platform.ip4_present) {
! 311: check_length_order(net_state);
! 312: }
! 313:
! 314: check_sctp_support(net_state);
! 315: }
! 316:
! 317: /*
! 318: Returns true if we were able to open sockets for a particular
! 319: IP protocol version.
! 320: */
! 321: bool is_ip_version_supported(
! 322: struct net_state_t *net_state,
! 323: int ip_version)
! 324: {
! 325: if (ip_version == 4) {
! 326: return net_state->platform.ip4_present;
! 327: } else if (ip_version == 6) {
! 328: return net_state->platform.ip6_present;
! 329: } else {
! 330: return false;
! 331: }
! 332: }
! 333:
! 334: /* Returns true if we can transmit probes using the specified protocol */
! 335: bool is_protocol_supported(
! 336: struct net_state_t * net_state,
! 337: int protocol)
! 338: {
! 339: if (protocol == IPPROTO_ICMP) {
! 340: return true;
! 341: }
! 342:
! 343: if (protocol == IPPROTO_UDP) {
! 344: return true;
! 345: }
! 346:
! 347: if (protocol == IPPROTO_TCP) {
! 348: return true;
! 349: }
! 350: #ifdef IPPROTO_SCTP
! 351: if (protocol == IPPROTO_SCTP) {
! 352: return net_state->platform.sctp_support;
! 353: }
! 354: #endif
! 355:
! 356: return false;
! 357: }
! 358:
! 359: /* Report an error during send_probe based on the errno value */
! 360: static
! 361: void report_packet_error(
! 362: int command_token)
! 363: {
! 364: if (errno == EINVAL) {
! 365: printf("%d invalid-argument\n", command_token);
! 366: } else if (errno == ENETDOWN) {
! 367: printf("%d network-down\n", command_token);
! 368: } else if (errno == ENETUNREACH) {
! 369: printf("%d no-route\n", command_token);
! 370: } else if (errno == EHOSTUNREACH) {
! 371: printf("%d no-route\n", command_token);
! 372: } else if (errno == EPERM) {
! 373: printf("%d permission-denied\n", command_token);
! 374: } else if (errno == EADDRINUSE) {
! 375: printf("%d address-in-use\n", command_token);
! 376: } else if (errno == EADDRNOTAVAIL) {
! 377: printf("%d address-not-available\n", command_token);
! 378: } else {
! 379: printf("%d unexpected-error errno %d\n", command_token, errno);
! 380: }
! 381: }
! 382:
! 383: /* Craft a custom ICMP packet for a network probe. */
! 384: void send_probe(
! 385: struct net_state_t *net_state,
! 386: const struct probe_param_t *param)
! 387: {
! 388: char packet[PACKET_BUFFER_SIZE];
! 389: struct probe_t *probe;
! 390: int packet_size;
! 391: struct sockaddr_storage src_sockaddr;
! 392:
! 393: probe = alloc_probe(net_state, param->command_token);
! 394: if (probe == NULL) {
! 395: printf("%d probes-exhausted\n", param->command_token);
! 396: return;
! 397: }
! 398:
! 399: if (resolve_probe_addresses(param, &probe->remote_addr, &src_sockaddr)) {
! 400: printf("%d invalid-argument\n", param->command_token);
! 401: free_probe(net_state, probe);
! 402: return;
! 403: }
! 404:
! 405: if (gettimeofday(&probe->platform.departure_time, NULL)) {
! 406: perror("gettimeofday failure");
! 407: exit(EXIT_FAILURE);
! 408: }
! 409:
! 410: packet_size =
! 411: construct_packet(net_state, &probe->platform.socket,
! 412: probe->sequence, packet, PACKET_BUFFER_SIZE,
! 413: &probe->remote_addr, &src_sockaddr, param);
! 414:
! 415: if (packet_size < 0) {
! 416: /*
! 417: When using a stream protocol, FreeBSD will return ECONNREFUSED
! 418: when connecting to localhost if the port doesn't exist,
! 419: even if the socket is non-blocking, so we should be
! 420: prepared for that.
! 421: */
! 422: if (errno == ECONNREFUSED) {
! 423: receive_probe(net_state, probe, ICMP_ECHOREPLY,
! 424: &probe->remote_addr, NULL, 0, NULL);
! 425: } else {
! 426: report_packet_error(param->command_token);
! 427: free_probe(net_state, probe);
! 428: }
! 429:
! 430: return;
! 431: }
! 432:
! 433: if (packet_size > 0) {
! 434: if (send_packet(net_state, param,
! 435: packet, packet_size, &probe->remote_addr) == -1) {
! 436:
! 437: report_packet_error(param->command_token);
! 438: free_probe(net_state, probe);
! 439: return;
! 440: }
! 441: }
! 442:
! 443: probe->platform.timeout_time = probe->platform.departure_time;
! 444: probe->platform.timeout_time.tv_sec += param->timeout;
! 445: }
! 446:
! 447: /* When allocating a probe, assign it a unique port number */
! 448: void platform_alloc_probe(
! 449: struct net_state_t *net_state,
! 450: struct probe_t *probe)
! 451: {
! 452: probe->sequence = net_state->platform.next_sequence++;
! 453:
! 454: if (net_state->platform.next_sequence > MAX_PORT) {
! 455: net_state->platform.next_sequence = MIN_PORT;
! 456: }
! 457: }
! 458:
! 459: /*
! 460: When freeing the probe, close the socket for the probe,
! 461: if one has been opened
! 462: */
! 463: void platform_free_probe(
! 464: struct probe_t *probe)
! 465: {
! 466: if (probe->platform.socket) {
! 467: close(probe->platform.socket);
! 468: probe->platform.socket = 0;
! 469: }
! 470: }
! 471:
! 472: /*
! 473: Compute the round trip time of a just-received probe and pass it
! 474: to the platform agnostic response handling.
! 475: */
! 476: void receive_probe(
! 477: struct net_state_t *net_state,
! 478: struct probe_t *probe,
! 479: int icmp_type,
! 480: const struct sockaddr_storage *remote_addr,
! 481: struct timeval *timestamp,
! 482: int mpls_count,
! 483: struct mpls_label_t *mpls)
! 484: {
! 485: unsigned int round_trip_us;
! 486: struct timeval *departure_time = &probe->platform.departure_time;
! 487: struct timeval now;
! 488:
! 489: if (timestamp == NULL) {
! 490: if (gettimeofday(&now, NULL)) {
! 491: perror("gettimeofday failure");
! 492: exit(EXIT_FAILURE);
! 493: }
! 494:
! 495: timestamp = &now;
! 496: }
! 497:
! 498: round_trip_us =
! 499: (timestamp->tv_sec - departure_time->tv_sec) * 1000000 +
! 500: timestamp->tv_usec - departure_time->tv_usec;
! 501:
! 502: respond_to_probe(net_state, probe, icmp_type,
! 503: remote_addr, round_trip_us, mpls_count, mpls);
! 504: }
! 505:
! 506: /*
! 507: Read all available packets through our receiving raw socket, and
! 508: handle any responses to probes we have preivously sent.
! 509: */
! 510: static
! 511: void receive_replies_from_icmp_socket(
! 512: struct net_state_t *net_state,
! 513: int socket,
! 514: received_packet_func_t handle_received_packet)
! 515: {
! 516: char packet[PACKET_BUFFER_SIZE];
! 517: int packet_length;
! 518: struct sockaddr_storage remote_addr;
! 519: socklen_t sockaddr_length;
! 520: struct timeval timestamp;
! 521:
! 522: /* Read until no more packets are available */
! 523: while (true) {
! 524: sockaddr_length = sizeof(struct sockaddr_storage);
! 525: packet_length = recvfrom(socket, packet, PACKET_BUFFER_SIZE, 0,
! 526: (struct sockaddr *) &remote_addr,
! 527: &sockaddr_length);
! 528:
! 529: /*
! 530: Get the time immediately after reading the packet to
! 531: keep the timing as precise as we can.
! 532: */
! 533: if (gettimeofday(×tamp, NULL)) {
! 534: perror("gettimeofday failure");
! 535: exit(EXIT_FAILURE);
! 536: }
! 537:
! 538: if (packet_length == -1) {
! 539: /*
! 540: EAGAIN will be returned if there is no current packet
! 541: available.
! 542: */
! 543: if (errno == EAGAIN) {
! 544: return;
! 545: }
! 546:
! 547: /*
! 548: EINTER will be returned if we received a signal during
! 549: receive.
! 550: */
! 551: if (errno == EINTR) {
! 552: continue;
! 553: }
! 554:
! 555: perror("Failure receiving replies");
! 556: exit(EXIT_FAILURE);
! 557: }
! 558:
! 559: handle_received_packet(net_state, &remote_addr, packet,
! 560: packet_length, ×tamp);
! 561: }
! 562: }
! 563:
! 564: /*
! 565: Attempt to send using the probe's socket, in order to check whether
! 566: the connection has completed, for stream oriented protocols such as
! 567: TCP.
! 568: */
! 569: static
! 570: void receive_replies_from_probe_socket(
! 571: struct net_state_t *net_state,
! 572: struct probe_t *probe)
! 573: {
! 574: int probe_socket;
! 575: struct timeval zero_time;
! 576: int err;
! 577: int err_length = sizeof(int);
! 578: fd_set write_set;
! 579:
! 580: probe_socket = probe->platform.socket;
! 581: if (!probe_socket) {
! 582: return;
! 583: }
! 584:
! 585: FD_ZERO(&write_set);
! 586: FD_SET(probe_socket, &write_set);
! 587:
! 588: zero_time.tv_sec = 0;
! 589: zero_time.tv_usec = 0;
! 590:
! 591: if (select(probe_socket + 1, NULL, &write_set, NULL, &zero_time) == -1) {
! 592: if (errno == EAGAIN) {
! 593: return;
! 594: } else {
! 595: perror("probe socket select error");
! 596: exit(EXIT_FAILURE);
! 597: }
! 598: }
! 599:
! 600: /*
! 601: If the socket is writable, the connection attempt has completed.
! 602: */
! 603: if (!FD_ISSET(probe_socket, &write_set)) {
! 604: return;
! 605: }
! 606:
! 607: if (getsockopt(probe_socket, SOL_SOCKET, SO_ERROR, &err, &err_length)) {
! 608: perror("probe socket SO_ERROR");
! 609: exit(EXIT_FAILURE);
! 610: }
! 611:
! 612: /*
! 613: If the connection complete successfully, or was refused, we can
! 614: assume our probe arrived at the destination.
! 615: */
! 616: if (!err || err == ECONNREFUSED) {
! 617: receive_probe(net_state, probe, ICMP_ECHOREPLY,
! 618: &probe->remote_addr, NULL, 0, NULL);
! 619: } else {
! 620: errno = err;
! 621: report_packet_error(probe->token);
! 622: free_probe(net_state, probe);
! 623: }
! 624: }
! 625:
! 626: /* Check both the IPv4 and IPv6 sockets for incoming packets */
! 627: void receive_replies(
! 628: struct net_state_t *net_state)
! 629: {
! 630: struct probe_t *probe;
! 631: struct probe_t *probe_safe_iter;
! 632:
! 633: if (net_state->platform.ip4_present) {
! 634: receive_replies_from_icmp_socket(net_state,
! 635: net_state->platform.
! 636: ip4_recv_socket,
! 637: handle_received_ip4_packet);
! 638: }
! 639:
! 640: if (net_state->platform.ip6_present) {
! 641: receive_replies_from_icmp_socket(net_state,
! 642: net_state->platform.
! 643: ip6_recv_socket,
! 644: handle_received_ip6_packet);
! 645: }
! 646:
! 647: LIST_FOREACH_SAFE(probe, &net_state->outstanding_probes,
! 648: probe_list_entry, probe_safe_iter) {
! 649:
! 650: receive_replies_from_probe_socket(net_state, probe);
! 651: }
! 652: }
! 653:
! 654: /*
! 655: Put all of our probe sockets in the read set used for an upcoming
! 656: select so we can wake when any of them become readable.
! 657: */
! 658: int gather_probe_sockets(
! 659: const struct net_state_t *net_state,
! 660: fd_set * write_set)
! 661: {
! 662: int probe_socket;
! 663: int nfds;
! 664: const struct probe_t *probe;
! 665:
! 666: nfds = 0;
! 667:
! 668: LIST_FOREACH(probe, &net_state->outstanding_probes, probe_list_entry) {
! 669: probe_socket = probe->platform.socket;
! 670:
! 671: if (probe_socket) {
! 672: FD_SET(probe_socket, write_set);
! 673: if (probe_socket >= nfds) {
! 674: nfds = probe_socket + 1;
! 675: }
! 676: }
! 677: }
! 678:
! 679: return nfds;
! 680: }
! 681:
! 682: /*
! 683: Check for any probes for which we have not received a response
! 684: for some time, and report a time-out, assuming that we won't
! 685: receive a future reply.
! 686: */
! 687: void check_probe_timeouts(
! 688: struct net_state_t *net_state)
! 689: {
! 690: struct timeval now;
! 691: struct probe_t *probe;
! 692: struct probe_t *probe_safe_iter;
! 693:
! 694: if (gettimeofday(&now, NULL)) {
! 695: perror("gettimeofday failure");
! 696: exit(EXIT_FAILURE);
! 697: }
! 698:
! 699: LIST_FOREACH_SAFE(probe, &net_state->outstanding_probes,
! 700: probe_list_entry, probe_safe_iter) {
! 701:
! 702: if (compare_timeval(probe->platform.timeout_time, now) < 0) {
! 703: /* Report timeout to the command stream */
! 704: printf("%d no-reply\n", probe->token);
! 705:
! 706: free_probe(net_state, probe);
! 707: }
! 708: }
! 709: }
! 710:
! 711: /*
! 712: Find the remaining time until the next probe times out.
! 713: This may be a negative value if the next probe timeout has
! 714: already elapsed.
! 715:
! 716: Returns false if no probes are currently outstanding, and true
! 717: if a timeout value for the next probe exists.
! 718: */
! 719: bool get_next_probe_timeout(
! 720: const struct net_state_t *net_state,
! 721: struct timeval *timeout)
! 722: {
! 723: bool have_timeout;
! 724: const struct probe_t *probe;
! 725: struct timeval now;
! 726: struct timeval probe_timeout;
! 727:
! 728: if (gettimeofday(&now, NULL)) {
! 729: perror("gettimeofday failure");
! 730: exit(EXIT_FAILURE);
! 731: }
! 732:
! 733: have_timeout = false;
! 734: LIST_FOREACH(probe, &net_state->outstanding_probes, probe_list_entry) {
! 735: probe_timeout.tv_sec =
! 736: probe->platform.timeout_time.tv_sec - now.tv_sec;
! 737: probe_timeout.tv_usec =
! 738: probe->platform.timeout_time.tv_usec - now.tv_usec;
! 739:
! 740: normalize_timeval(&probe_timeout);
! 741: if (have_timeout) {
! 742: if (compare_timeval(probe_timeout, *timeout) < 0) {
! 743: /* If this probe has a sooner timeout, store it instead */
! 744: *timeout = probe_timeout;
! 745: }
! 746: } else {
! 747: *timeout = probe_timeout;
! 748: have_timeout = true;
! 749: }
! 750: }
! 751:
! 752: return have_timeout;
! 753: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to probe_unix.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr / packet