/*
 * Copyright 2014 Google Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 *
 * Like ping, but sends packets isochronously (equally spaced in time) in
 * each direction.  By being clever, we can use the known timing of each
 * packet to determine, on a noisy network, which direction is dropping or
 * delaying packets and by how much.
 *
 * Also unlike ping, this requires a server (ie. another copy of this
 * program) to be running on the remote end.
 */
#include <arpa/inet.h>
#include <errno.h>
#include <math.h>
#include <memory.h>
#include <netdb.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>

#ifndef CLOCK_MONOTONIC_RAW
#define CLOCK_MONOTONIC_RAW 4
#endif

#define MAGIC 0x424c4950
#define SERVER_PORT 4948
#define DEFAULT_PACKETS_PER_SEC 10.0

// A 'cycle' is the amount of time we can assume our calibration between
// the local and remote monotonic clocks is reasonably valid.  It seems
// some of our devices have *very* fast clock skew (> 1 msec/minute) so
// this unfortunately has to be much shorter than I'd like.  This may
// reflect actual bugs in our ntpd and/or the kernel's adjtime()
// implementation.  In particular, we shouldn't have to do this kind of
// periodic correction, because that's what adjtime() *is*.  But the results
// are way off without this.
#define USEC_PER_CYCLE (10*1000*1000)

#define ARRAY_LEN(a) (sizeof(a) / sizeof((a)[0]))
#define DIFF(x, y) ((int32_t)((uint32_t)(x) - (uint32_t)(y)))
#define DIV(x, y) ((y) ? ((double)(x)/(y)) : 0)
#define _STR(n) #n
#define STR(n) _STR(n)


// Layout of the UDP packets exchanged between client and server.
// All integers are in network byte order.
// Packets have exactly the same structure in both directions.
struct Packet {
  uint32_t magic;     // magic number to reject bogus packets
  uint32_t id;        // sequential packet id number
  uint32_t txtime;    // transmitter's monotonic time when pkt was sent
  uint32_t clockdiff; // estimate of (transmitter's clk) - (receiver's clk)
  uint32_t usec_per_pkt; // microseconds of delay between packets
  uint32_t num_lost;  // number of pkts transmitter expected to get but didn't
  uint32_t first_ack; // starting index in acks[] circular buffer
  struct {
    // txtime==0 for empty elements in this array.
    uint32_t id;      // id field from a received packet
    uint32_t rxtime;  // receiver's monotonic time when pkt arrived
  } acks[64];
};


int want_to_die;


static void sighandler(int sig) {
  want_to_die = 1;
}


// Returns the kernel monotonic timestamp in microseconds, truncated to
// 32 bits.  That will wrap around every ~4000 seconds, which is okay
// for our purposes.  We use 32 bits to save space in our packets.
// This function never returns the value 0; it returns 1 instead, so that
// 0 can be used as a magic value.
#ifdef __MACH__  // MacOS X doesn't have clock_gettime()
#include <mach/mach.h>
#include <mach/mach_time.h>

static uint64_t ustime64(void) {
  static mach_timebase_info_data_t timebase;
  if (!timebase.denom) mach_timebase_info(&timebase);
  uint64_t result = (mach_absolute_time() * timebase.numer /
                     timebase.denom / 1000);
  return !result ? 1 : result;
}
#else
static uint64_t ustime64(void) {
  // CLOCK_MONOTONIC_RAW, when available, is not subject to NTP speed
  // adjustments while CLOCK_MONOTONIC is.  You might expect NTP speed
  // adjustments to make things better if we're trying to sync timings
  // between two machines, but at least our ntpd is pretty bad at making
  // adjustments, so it tends the vary the speed wildly in order to kind
  // of oscillate around the right time.  Experimentally, CLOCK_MONOTONIC_RAW
  // creates less trouble for isoping's use case.
  struct timespec ts;
  if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts) < 0) {
    if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0) {
      perror("clock_gettime");
      exit(98); // really should never happen, so don't try to recover
    }
  }
  uint64_t result = ts.tv_sec * 1000000LL + ts.tv_nsec / 1000;
  return !result ? 1 : result;
}
#endif


static uint32_t ustime(void) {
  return (uint32_t)ustime64();
}


static void usage_and_die(char *argv0) {
  fprintf(stderr,
          "\n"
          "Usage: %s                          (server mode)\n"
          "   or: %s <server-hostname-or-ip>  (client mode)\n"
          "\n"
          "      -f <lines/sec>  max output lines per second\n"
          "      -r <pps>        packets per second (default=%g)\n"
          "      -t <ttl>        packet ttl to use (default=2 for safety)\n"
          "      -q              quiet mode (don't print packets)\n"
          "      -T              print timestamps\n",
          argv0, argv0, (double)DEFAULT_PACKETS_PER_SEC);
  exit(99);
}


// Render the given sockaddr as a string.  (Uses a static internal buffer
// which is overwritten each time.)
static const char *sockaddr_to_str(struct sockaddr *sa) {
  static char addrbuf[128];
  void *aptr;

  switch (sa->sa_family) {
  case AF_INET:
    aptr = &((struct sockaddr_in *)sa)->sin_addr;
    break;
  case AF_INET6:
    aptr = &((struct sockaddr_in6 *)sa)->sin6_addr;
    break;
  default:
    return "unknown";
  }

  if (!inet_ntop(sa->sa_family, aptr, addrbuf, sizeof(addrbuf))) {
    perror("inet_ntop");
    exit(98);
  }
  return addrbuf;
}


// Print the timestamp corresponding to the current time.
// Deliberately the same format as tcpdump uses, so we can easily sort and
// correlate messages between isoping and tcpdump.
static void print_timestamp(uint32_t when) {
  uint64_t now = ustime64();
  int32_t nowdiff = DIFF(now, when);
  uint64_t when64 = now - nowdiff;
  time_t t = when64 / 1000000;
  struct tm tm;
  memset(&tm, 0, sizeof(tm));
  localtime_r(&t, &tm);
  printf("%02d:%02d:%02d.%06d ", tm.tm_hour, tm.tm_min, tm.tm_sec,
         (int)(when64 % 1000000));
}


static double onepass_stddev(long long sumsq, long long sum, long long count) {
  // Incremental standard deviation calculation, without needing to know the
  // mean in advance.  See:
  // http://mathcentral.uregina.ca/QQ/database/QQ.09.02/carlos1.html
  long long numer = (count * sumsq) - (sum * sum);
  long long denom = count * (count - 1);
  return sqrt(DIV(numer, denom));
}


int main(int argc, char **argv) {
  int is_server = 1;
  struct sockaddr_in6 listenaddr, rxaddr, last_rxaddr;
  struct sockaddr *remoteaddr = NULL;
  socklen_t remoteaddr_len = 0, rxaddr_len = 0;
  struct addrinfo *ai = NULL;
  int sock = -1, want_timestamps = 0, quiet = 0, ttl = 2;
  double packets_per_sec = DEFAULT_PACKETS_PER_SEC, prints_per_sec = -1;

  setvbuf(stdout, NULL, _IOLBF, 0);

  int c;
  while ((c = getopt(argc, argv, "f:r:t:qTh?")) >= 0) {
    switch (c) {
    case 'f':
      prints_per_sec = atof(optarg);
      if (prints_per_sec <= 0) {
        fprintf(stderr, "%s: lines per second must be >= 0\n", argv[0]);
        return 99;
      }
      break;
    case 'r':
      packets_per_sec = atof(optarg);
      if (packets_per_sec < 0.001 || packets_per_sec > 1e6) {
        fprintf(stderr, "%s: packets per sec (-r) must be 0.001..1000000\n",
                argv[0]);
        return 99;
      }
      break;
    case 't':
      ttl = atoi(optarg);
      if (ttl < 1) {
        fprintf(stderr, "%s: ttl must be >= 1\n", argv[0]);
        return 99;
      }
      break;
    case 'q':
      quiet = 1;
      break;
    case 'T':
      want_timestamps = 1;
      break;
    case 'h':
    case '?':
    default:
      usage_and_die(argv[0]);
      break;
    }
  }

  sock = socket(PF_INET6, SOCK_DGRAM, 0);
  if (sock < 0) {
    perror("socket");
    return 1;
  }

  if (argc - optind == 0) {
    is_server = 1;
    memset(&listenaddr, 0, sizeof(listenaddr));
    listenaddr.sin6_family = AF_INET6;
    listenaddr.sin6_port = htons(SERVER_PORT);
    if (bind(sock, (struct sockaddr *)&listenaddr, sizeof(listenaddr)) != 0) {
      perror("bind");
      return 1;
    }
    socklen_t addrlen = sizeof(listenaddr);
    if (getsockname(sock, (struct sockaddr *)&listenaddr, &addrlen) != 0) {
      perror("getsockname");
      return 1;
    }
    fprintf(stderr, "server listening at [%s]:%d\n",
           sockaddr_to_str((struct sockaddr *)&listenaddr),
           ntohs(listenaddr.sin6_port));
  } else if (argc - optind == 1) {
    const char *remotename = argv[optind];
    is_server = 0;
    struct addrinfo hints = {
      .ai_flags = AI_ADDRCONFIG | AI_V4MAPPED,
      .ai_family = AF_INET6,
      .ai_socktype = SOCK_DGRAM,
    };
    int err = getaddrinfo(remotename, STR(SERVER_PORT), &hints, &ai);
    if (err != 0 || !ai) {
      fprintf(stderr, "getaddrinfo(%s): %s\n", remotename, gai_strerror(err));
      return 1;
    }
    fprintf(stderr, "connecting to %s...\n", sockaddr_to_str(ai->ai_addr));
    if (connect(sock, ai->ai_addr, ai->ai_addrlen) != 0) {
      perror("connect");
      return 1;
    }
    remoteaddr = ai->ai_addr;
    remoteaddr_len = ai->ai_addrlen;
  } else {
    usage_and_die(argv[0]);
  }

  fprintf(stderr, "using ttl=%d\n", ttl);
  // IPPROTO_IPV6 is the only one that works on MacOS, and is arguably the
  // technically correct thing to do since it's an AF_INET6 socket.
  if (setsockopt(sock, IPPROTO_IPV6, IP_TTL, &ttl, sizeof(ttl))) {
    perror("setsockopt(TTLv6)");
    return 1;
  }
  // ...but in Linux (at least 3.13), IPPROTO_IPV6 does not actually
  // set the TTL if the IPv6 socket ends up going over IPv4.  We have to
  // set that separately.  On MacOS, that always returns EINVAL, so ignore
  // the error if that happens.
  if (setsockopt(sock, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl))) {
    if (errno != EINVAL) {
      perror("setsockopt(TTLv4)");
      return 1;
    }
  }

  int32_t usec_per_pkt = 1e6 / packets_per_sec;
  int32_t usec_per_print = prints_per_sec > 0 ? 1e6 / prints_per_sec : 0;

  // WARNING: lots of math below relies on well-defined uint32/int32
  // arithmetic overflow behaviour, plus the fact that when we subtract
  // two successive timestamps (for example) they will be less than 2^31
  // microseconds apart.  It would be safer to just use 64-bit values
  // everywhere, but that would cut the number of acks-per-packet in half,
  // which would be unfortunate.
  uint32_t next_tx_id = 1;       // id field for next transmit
  uint32_t next_rx_id = 0;       // expected id field for next receive
  uint32_t next_rxack_id = 0;    // expected ack.id field in next received ack
  uint32_t start_rtxtime = 0;    // remote's txtime at startup
  uint32_t start_rxtime = 0;     // local rxtime at startup
  uint32_t last_rxtime = 0;      // local rxtime of last received packet
  int32_t min_cycle_rxdiff = 0;  // smallest packet delay seen this cycle
  uint32_t next_cycle = 0;       // time when next cycle begins
  uint32_t now = ustime();       // current time
  uint32_t next_send = now + usec_per_pkt;  // time when we'll send next pkt
  uint32_t num_lost = 0;         // number of rx packets not received
  int next_txack_index = 0;      // next array item to fill in tx.acks
  struct Packet tx, rx;          // transmit and received packet buffers
  char last_ackinfo[128] = "";   // human readable format of latest ack
  uint32_t last_print = now - usec_per_pkt;  // time of last packet printout
  // Packet statistics counters for transmit and receive directions.
  long long lat_tx = 0, lat_tx_min = 0x7fffffff, lat_tx_max = 0,
      lat_tx_count = 0, lat_tx_sum = 0, lat_tx_var_sum = 0;
  long long lat_rx = 0, lat_rx_min = 0x7fffffff, lat_rx_max = 0,
      lat_rx_count = 0, lat_rx_sum = 0, lat_rx_var_sum = 0;

  memset(&tx, 0, sizeof(tx));

  struct sigaction act = {
    .sa_handler = sighandler,
    .sa_flags = SA_RESETHAND,
  };
  sigaction(SIGINT, &act, NULL);

  while (!want_to_die) {
    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(sock, &rfds);
    struct timeval tv;
    tv.tv_sec = 0;

    now = ustime();
    if (DIFF(next_send, now) < 0) {
      tv.tv_usec = 0;
    } else {
      tv.tv_usec = DIFF(next_send, now);
    }
    int nfds = select(sock + 1, &rfds, NULL, NULL, remoteaddr ? &tv : NULL);
    now = ustime();
    if (nfds < 0 && errno != EINTR) {
      perror("select");
      return 1;
    }

    // time to send the next packet?
    if (remoteaddr && DIFF(now, next_send) >= 0) {
      tx.magic = htonl(MAGIC);
      tx.id = htonl(next_tx_id++);
      tx.usec_per_pkt = htonl(usec_per_pkt);
      tx.txtime = htonl(next_send);
      tx.clockdiff = start_rtxtime ? htonl(start_rxtime - start_rtxtime) : 0;
      tx.num_lost = htonl(num_lost);
      tx.first_ack = htonl(next_txack_index);
      // note: tx.acks[] is filled in incrementally; we just transmit the
      // current state of it here.  The reason we keep a list of the most
      // recent acks is in case our packet gets lost, so the receiver will
      // have more chances to receive the timing information for the packets
      // it sent us.
      if (is_server) {
        if (sendto(sock, &tx, sizeof(tx), 0,
                   remoteaddr, remoteaddr_len) < 0) {
          perror("sendto");
        }
      } else {
        if (send(sock, &tx, sizeof(tx), 0) < 0) {
          int e = errno;
          perror("send");
          if (e == ECONNREFUSED) return 2;
        }
      }
      if (is_server && DIFF(now, last_rxtime) > 60*1000*1000) {
        fprintf(stderr, "client disconnected.\n");
        remoteaddr = NULL;
      }
      next_send += usec_per_pkt;
    }

    if (nfds > 0) {
      // incoming packet
      rxaddr_len = sizeof(rxaddr);
      ssize_t got = recvfrom(sock, &rx, sizeof(rx), 0,
                             (struct sockaddr *)&rxaddr, &rxaddr_len);
      if (got < 0) {
        int e = errno;
        perror("recvfrom");
        if (!is_server && e == ECONNREFUSED) return 2;
        continue;
      }
      if (got != sizeof(rx) || rx.magic != htonl(MAGIC)) {
        fprintf(stderr, "got invalid packet of length %ld\n", (long)got);
        continue;
      }

      // is it a new client?
      if (is_server) {
        // TODO(apenwarr): fork() for each newly connected client.
        //  The way the code is right now, it won't work right at all
        //  if there are two clients sending us packets at once.
        //  That's okay for a first round of controlled tests.
        if (!remoteaddr ||
            memcmp(&rxaddr, &last_rxaddr, sizeof(rxaddr)) != 0) {
          fprintf(stderr, "new client connected: %s\n",
                  sockaddr_to_str((struct sockaddr *)&rxaddr));
          memcpy(&last_rxaddr, &rxaddr, sizeof(rxaddr));
          remoteaddr = (struct sockaddr *)&last_rxaddr;
          remoteaddr_len = rxaddr_len;

          next_send = now + 10*1000;
          next_tx_id = 1;
          next_rx_id = next_rxack_id = 0;
          start_rtxtime = start_rxtime = 0;
          num_lost = 0;
          next_txack_index = 0;
          usec_per_pkt = ntohl(rx.usec_per_pkt);
          memset(&tx, 0, sizeof(tx));
        }
      }

      // process the incoming packet header.
      // Most of the complexity here comes from the fact that the remote
      // system's clock will be skewed vs. ours.  (We use CLOCK_MONOTONIC
      // instead of CLOCK_REALTIME, so unless we figure out the skew offset,
      // it's essentially meaningless to compare the two values.)  We can
      // however assume that both clocks are ticking at 1 microsecond per
      // tick... except for inevitable clock rate errors, which we have to
      // account for occasionally.

      uint32_t txtime = ntohl(rx.txtime), rxtime = now;
      uint32_t id = ntohl(rx.id);
      if (!next_rx_id) {
        // The remote txtime is told to us by the sender, so it is always
        // perfectly correct... but it uses the sender's clock.
        start_rtxtime = txtime - id * usec_per_pkt;

        // The receive time uses our own clock and is estimated by us, so
        // it needs to be corrected over time because:
        //   a) the two clocks inevitably run at slightly different speeds;
        //   b) there's an unknown, variable, network delay between tx and rx.
        // Here, we're just assigning an initial estimate.
        start_rxtime = rxtime - id * usec_per_pkt;

        min_cycle_rxdiff = 0;
        next_rx_id = id;
        next_cycle = now + USEC_PER_CYCLE;
      }

      // see if we missed receiving any previous packets.
      int32_t tmpdiff = DIFF(id, next_rx_id);
      if (tmpdiff > 0) {
        // arriving packet has id > expected, so something was lost.
        // Note that we don't use the rx.acks[] structure to determine packet
        // loss; that's because the limited size of the array means that,
        // during a longer outage, we might not see an ack for a packet
        // *even if that packet arrived safely* at the remote.  So we count
        // on the remote end to count its own packet losses using sequence
        // numbers, and send that count back to us.  We do the same here
        // for incoming packets from the remote, and send the error count
        // back to them next time we're ready to transmit.
        fprintf(stderr, "lost %ld  expected=%ld  got=%ld\n",
                (long)tmpdiff, (long)next_rx_id, (long)id);
        num_lost += tmpdiff;
        next_rx_id += tmpdiff + 1;
      } else if (!tmpdiff) {
        // exactly as expected; good.
        next_rx_id++;
      } else if (tmpdiff < 0) {
        // packet before the expected one? weird.
        fprintf(stderr, "out-of-order packets? %ld\n", (long)tmpdiff);
      }

      // fix up the clock offset if there's any drift.
      tmpdiff = DIFF(rxtime, start_rxtime + id * usec_per_pkt);
      if (tmpdiff < -20) {
        // packet arrived before predicted time, so prediction was based on
        // a packet that was "slow" before, or else one of our clocks is
        // drifting. Use earliest legitimate start time.
        fprintf(stderr, "time paradox: backsliding start by %ld usec\n",
                (long)tmpdiff);
        start_rxtime = rxtime - id * usec_per_pkt;
      }
      int32_t rxdiff = DIFF(rxtime, start_rxtime + id * usec_per_pkt);

      // Figure out the offset between our clock and the remote's clock, so
      // we can calculate the minimum round trip time (rtt). Then, because
      // the consecutive packets sent in both directions are equally spaced
      // in time, we can figure out how much a particular packet was delayed
      // in transit - independently in each direction! This is an advantage
      // over the normal "ping" program which has no way to tell which
      // direction caused the delay, or which direction dropped the packet.

      // Our clockdiff is
      //   (our rx time) - (their tx time)
      //   == (their rx time + offset) - (their tx time)
      //   == (their tx time + offset + 1/2 rtt) - (their tx time)
      //   == offset + 1/2 rtt
      // and theirs (rx.clockdiff) is:
      //   (their rx time) - (our tx time)
      //   == (their rx time) - (their tx time + offset)
      //   == (their tx time + 1/2 rtt) - (their tx time + offset)
      //   == 1/2 rtt - offset
      // So add them together and we get:
      //   offset + 1/2 rtt + 1/2 rtt - offset
      //   == rtt
      // Subtract them and we get:
      //   offset + 1/2 rtt - 1/2 rtt + offset
      //   == 2 * offset
      // ...but that last subtraction is dangerous because if we divide by
      // 2 to get offset, it doesn't work with 32-bit math, which may have
      // discarded a high-order bit somewhere along the way.  Instead,
      // we can extract offset once we have rtt by substituting it into
      //   clockdiff = offset + 1/2 rtt
      //   offset = clockdiff - 1/2 rtt
      // (Dividing rtt by 2 is safe since it's always small and positive.)
      //
      // (This example assumes 1/2 rtt in each direction. There's no way to
      // determine it more accurately than that.)
      int32_t clockdiff = DIFF(start_rxtime, start_rtxtime);
      int32_t rtt = clockdiff + ntohl(rx.clockdiff);
      int32_t offset = DIFF(clockdiff, rtt / 2);
      if (!ntohl(rx.clockdiff)) {
        // don't print the first packet: it has an invalid clockdiff since
        // the client can't calculate the clockdiff until it receives
        // at least one packet from us.
        last_print = now - usec_per_print + 1;
      } else {
        // not the first packet, so statistics are valid.
        lat_rx_count++;
        lat_rx = rxdiff + rtt/2;
        lat_rx_min = lat_rx_min > lat_rx ? lat_rx : lat_rx_min;
        lat_rx_max = lat_rx_max < lat_rx ? lat_rx : lat_rx_max;
        lat_rx_sum += lat_rx;
        lat_rx_var_sum += lat_rx * lat_rx;
      }

      // Note: the way ok_to_print is structured, if there is a dropout in
      // the connection for more than usec_per_print, we will statistically
      // end up printing the first packet after the dropout ends.  That one
      // should have the longest timeout, ie. a "worst case" packet, which is
      // usually the information you want to see.
      int ok_to_print = !quiet && DIFF(now, last_print) >= usec_per_print;
      if (ok_to_print) {
        if (want_timestamps) print_timestamp(rxtime);
        printf("%12s  %6.1f ms rx  (min=%.1f)  loss: %ld/%ld tx  %ld/%ld rx\n",
               last_ackinfo,
               (rxdiff + rtt/2) / 1000.0,
               (rtt/2) / 1000.0,
               (long)ntohl(rx.num_lost),
               (long)next_tx_id - 1,
               (long)num_lost,
               (long)next_rx_id - 1);
        last_ackinfo[0] = '\0';
        last_print = now;
      }

      if (rxdiff < min_cycle_rxdiff) min_cycle_rxdiff = rxdiff;
      if (DIFF(now, next_cycle) >= 0) {
        if (min_cycle_rxdiff > 0) {
          fprintf(stderr, "clock skew: sliding start by %ld usec\n",
                  (long)min_cycle_rxdiff);
          start_rxtime += min_cycle_rxdiff;
        }
        min_cycle_rxdiff = 0x7fffffff;
        next_cycle += USEC_PER_CYCLE;
      }

      // schedule this for an ack next time we send the packet
      tx.acks[next_txack_index].id = htonl(id);
      tx.acks[next_txack_index].rxtime = htonl(rxtime);
      next_txack_index = (next_txack_index + 1) % ARRAY_LEN(tx.acks);

      // see which of our own transmitted packets have been acked
      uint32_t first_ack = ntohl(rx.first_ack);
      for (uint32_t i = 0; i < ARRAY_LEN(rx.acks); i++) {
        uint32_t acki = (first_ack + i) % ARRAY_LEN(rx.acks);
        uint32_t ackid = ntohl(rx.acks[acki].id);
        if (!ackid) continue;  // empty slot
        if (DIFF(ackid, next_rxack_id) >= 0) {
          // an expected ack
          uint32_t start_txtime = next_send - next_tx_id * usec_per_pkt;
          uint32_t txtime = start_txtime + ackid * usec_per_pkt;
          uint32_t rrxtime = ntohl(rx.acks[acki].rxtime);
          uint32_t rxtime = rrxtime + offset;
          // note: already contains 1/2 rtt, unlike rxdiff
          int32_t txdiff = DIFF(rxtime, txtime);
          if (usec_per_print <= 0 && last_ackinfo[0]) {
            // only print multiple acks per rx if no usec_per_print limit
            if (want_timestamps) print_timestamp(rxtime);
            printf("%12s\n", last_ackinfo);
            last_ackinfo[0] = '\0';
          }
          if (!last_ackinfo[0]) {
            snprintf(last_ackinfo, sizeof(last_ackinfo), "%6.1f ms tx",
                     txdiff / 1000.0);
          }
          next_rxack_id = ackid + 1;
          lat_tx_count++;
          lat_tx = txdiff;
          lat_tx_min = lat_tx_min > lat_tx ? lat_tx : lat_tx_min;
          lat_tx_max = lat_tx_max < lat_tx ? lat_tx : lat_tx_max;
          lat_tx_sum += lat_tx;
          lat_tx_var_sum += lat_tx * lat_tx;
        }
      }

      last_rxtime = rxtime;
    }
  }

  printf("\n---\n");
  printf("tx: min/avg/max/mdev = %.2f/%.2f/%.2f/%.2f ms\n",
         lat_tx_min / 1000.0,
         DIV(lat_tx_sum, lat_tx_count) / 1000.0,
         lat_tx_max / 1000.0,
         onepass_stddev(lat_tx_var_sum, lat_tx_sum, lat_tx_count) / 1000.0);
  printf("rx: min/avg/max/mdev = %.2f/%.2f/%.2f/%.2f ms\n",
         lat_rx_min / 1000.0,
         DIV(lat_rx_sum, lat_rx_count) / 1000.0,
         lat_rx_max / 1000.0,
         onepass_stddev(lat_rx_var_sum, lat_rx_sum, lat_rx_count) / 1000.0);
  printf("\n");

  if (ai) freeaddrinfo(ai);
  if (sock >= 0) close(sock);
  return 0;
}