Code

Merge branches 'mark' and 'timeout'
[liboping.git] / src / oping.c
index 6496331d63994545786687048ad7869874c77113..6263a4def36459c7d94c8dbbb362cc89b56a9f6e 100644 (file)
@@ -95,6 +95,9 @@
 # define OPING_YELLOW_HIST 5
 # define OPING_RED_HIST 6
 
+double const threshold_green = 0.8;
+double const threshold_yellow = 0.95;
+
 static char const * const hist_symbols_utf8[] = {
        "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█" };
 static size_t const hist_symbols_utf8_num = sizeof (hist_symbols_utf8)
@@ -157,17 +160,31 @@ typedef struct ping_context
        int req_sent;
        int req_rcvd;
 
-       double latency_min;
-       double latency_max;
        double latency_total;
-       double latency_total_square;
 
-/* 1000 + one "infinity" bucket. */
-#define OPING_HISTOGRAM_BUCKETS 1001
-       uint32_t *histogram_counters;
-       uint32_t *histogram_accumulated;
-       double *histogram_ratio;
-       size_t latency_histogram_size;
+#ifndef HISTORY_SIZE_MAX
+# define HISTORY_SIZE_MAX 900
+#endif
+       /* The last n RTTs in the order they were sent. */
+       double history_by_time[HISTORY_SIZE_MAX];
+
+       /* Current number of entries in the history. This is a value between 0
+        * and HISTORY_SIZE_MAX. */
+       size_t history_size;
+
+       /* Number "received" entries in the history, i.e. non-NAN entries. */
+       size_t history_received;
+
+       /* Index of the next RTT to be written to history_by_time. This wraps
+        * around to 0 once the histroty has grown to HISTORY_SIZE_MAX. */
+       size_t history_index;
+
+       /* The last history_size RTTs sorted by value. timed out packets (NAN
+        * entries) are sorted to the back. */
+       double history_by_value[HISTORY_SIZE_MAX];
+
+       /* If set to true, history_by_value has to be re-calculated. */
+       _Bool history_dirty;
 
 #if USE_NCURSES
        WINDOW *window;
@@ -175,9 +192,11 @@ typedef struct ping_context
 } ping_context_t;
 
 static double  opt_interval   = 1.0;
+static double  opt_timeout    = PING_DEF_TIMEOUT;
 static int     opt_addrfamily = PING_DEF_AF;
 static char   *opt_srcaddr    = NULL;
 static char   *opt_device     = NULL;
+static char   *opt_mark       = NULL;
 static char   *opt_filename   = NULL;
 static int     opt_count      = -1;
 static int     opt_send_ttl   = 64;
@@ -213,18 +232,7 @@ static ping_context_t *context_create (void) /* {{{ */
 
        memset (ret, '\0', sizeof (ping_context_t));
 
-       ret->latency_min   = -1.0;
-       ret->latency_max   = -1.0;
        ret->latency_total = 0.0;
-       ret->latency_total_square = 0.0;
-
-       ret->latency_histogram_size = (size_t) OPING_HISTOGRAM_BUCKETS;
-       ret->histogram_counters = calloc (ret->latency_histogram_size,
-                       sizeof (*ret->histogram_counters));
-       ret->histogram_accumulated = calloc (ret->latency_histogram_size,
-                       sizeof (*ret->histogram_accumulated));
-       ret->histogram_ratio = calloc (ret->latency_histogram_size,
-                       sizeof (*ret->histogram_ratio));
 
 #if USE_NCURSES
        ret->window = NULL;
@@ -246,75 +254,129 @@ static void context_destroy (ping_context_t *context) /* {{{ */
        }
 #endif
 
-       free (context->histogram_counters);
-       context->histogram_counters = NULL;
-
-       free (context->histogram_accumulated);
-       context->histogram_accumulated = NULL;
-
-       free (context->histogram_ratio);
-       context->histogram_ratio = NULL;
-
        free (context);
 } /* }}} void context_destroy */
 
-static double context_get_average (ping_context_t *ctx) /* {{{ */
+static int compare_double (void const *arg0, void const *arg1) /* {{{ */
 {
-       double num_total;
+       double dbl0 = *((double *) arg0);
+       double dbl1 = *((double *) arg1);
 
-       if (ctx == NULL)
-               return (-1.0);
+       if (isnan (dbl0))
+       {
+               if (isnan (dbl1))
+                       return 0;
+               else
+                       return 1;
+       }
+       else if (isnan (dbl1))
+               return -1;
+       else if (dbl0 < dbl1)
+               return -1;
+       else if (dbl0 > dbl1)
+               return 1;
+       else
+               return 0;
+} /* }}} int compare_double */
+
+static void clean_history (ping_context_t *ctx) /* {{{ */
+{
+       size_t i;
+
+       if (!ctx->history_dirty)
+               return;
+
+       /* Copy all values from by_time to by_value. */
+       memcpy (ctx->history_by_value, ctx->history_by_time,
+                       sizeof (ctx->history_by_time));
+
+       /* Sort all RTTs. */
+       qsort (ctx->history_by_value, ctx->history_size, sizeof
+                       (ctx->history_by_value[0]), compare_double);
 
-       if (ctx->req_rcvd < 1)
-               return (-0.0);
+       /* Update the number of received RTTs. */
+       ctx->history_received = 0;
+       for (i = 0; i < ctx->history_size; i++)
+               if (!isnan (ctx->history_by_value[i]))
+                       ctx->history_received++;
 
-       num_total = (double) ctx->req_rcvd;
-       return (ctx->latency_total / num_total);
-} /* }}} double context_get_average */
+       /* Mark as clean. */
+       ctx->history_dirty = 0;
+} /* }}} void clean_history */
 
-static double context_get_percentile (ping_context_t *ctx, /* {{{ */
+static double percentile_to_latency (ping_context_t *ctx, /* {{{ */
                double percentile)
 {
-       double threshold = percentile / 100.0;
-       double index_to_ms_factor;
-       size_t i;
-
-       if (ctx->histogram_ratio == NULL)
-               return (NAN);
+       size_t index;
 
-       for (i = 0; i < ctx->latency_histogram_size; i++)
-               if (ctx->histogram_ratio[i] >= threshold)
-                       break;
+       clean_history (ctx);
 
-       if (i >= ctx->latency_histogram_size)
-               return (NAN);
-       else if (i == (ctx->latency_histogram_size - 1))
-               return (INFINITY);
+       /* Not a single packet was received successfully. */
+       if (ctx->history_received == 0)
+               return NAN;
 
-       index_to_ms_factor = (1000.0 * opt_interval) / (ctx->latency_histogram_size - 1);
+       if (percentile <= 0.0)
+               index = 0;
+       else if (percentile >= 100.0)
+               index = ctx->history_received - 1;
+       else
+       {
+               index = (size_t) ceil ((percentile / 100.0) * ((double) ctx->history_received));
+               assert (index > 0);
+               index--;
+       }
 
-       /* Multiply with i+1, because we're interested in the _upper_ bound of
-        * each bucket. */
-       return (index_to_ms_factor * ((double) (i + 1)));
-} /* }}} double context_get_percentile */
+       return (ctx->history_by_value[index]);
+} /* }}} double percentile_to_latency */
 
-static double context_get_stddev (ping_context_t *ctx) /* {{{ */
+#if USE_NCURSES
+static double latency_to_ratio (ping_context_t *ctx, /* {{{ */
+               double latency)
 {
-       double num_total;
+       size_t low;
+       size_t high;
+       size_t index;
+
+       clean_history (ctx);
+
+       /* Not a single packet was received successfully. */
+       if (ctx->history_received == 0)
+               return NAN;
+
+       low = 0;
+       high = ctx->history_received - 1;
+
+       if (latency < ctx->history_by_value[low])
+               return 0.0;
+       else if (latency >= ctx->history_by_value[high])
+               return 100.0;
+
+       /* Do a binary search for the latency. This will work even when the
+        * exact latency is not in the array. If the latency is in the array
+        * multiple times, "low" will be set to the index of the last
+        * occurrence. The value at index "high" will be larger than the
+        * searched for latency (assured by the above "if" block. */
+       while ((high - low) > 1)
+       {
+               index = (high + low) / 2;
 
-       if (ctx == NULL)
-               return (-1.0);
+               if (ctx->history_by_value[index] > latency)
+                       high = index;
+               else
+                       low = index;
+       }
 
-       if (ctx->req_rcvd < 1)
-               return (-0.0);
-       else if (ctx->req_rcvd < 2)
-               return (0.0);
+       assert (ctx->history_by_value[high] > latency);
+       assert (ctx->history_by_value[low] <= latency);
 
-       num_total = (double) ctx->req_rcvd;
-       return (sqrt (((num_total * ctx->latency_total_square)
-                                       - (ctx->latency_total * ctx->latency_total))
-                               / (num_total * (num_total - 1.0))));
-} /* }}} double context_get_stddev */
+       if (ctx->history_by_value[low] == latency)
+               index = low;
+       else
+               index = high;
+
+       return (((double) (index + 1)) / ((double) ctx->history_received));
+} /* }}} double latency_to_ratio */
+#endif
 
 static double context_get_packet_loss (const ping_context_t *ctx) /* {{{ */
 {
@@ -370,11 +432,13 @@ static void usage_exit (const char *name, int status) /* {{{ */
                        "  -4|-6        force the use of IPv4 or IPv6\n"
                        "  -c count     number of ICMP packets to send\n"
                        "  -i interval  interval with which to send ICMP packets\n"
+                       "  -w timeout   time to wait for replies, in seconds\n"
                        "  -t ttl       time to live for each ICMP packet\n"
                        "  -Q qos       Quality of Service (QoS) of outgoing packets\n"
                        "               Use \"-Q help\" for a list of valid options.\n"
                        "  -I srcaddr   source address\n"
                        "  -D device    outgoing interface name\n"
+                       "  -m mark      mark to set on outgoing packets\n"
                        "  -f filename  filename to read hosts from\n"
 #if USE_NCURSES
                        "  -u / -U      force / disable UTF-8 output\n"
@@ -384,8 +448,8 @@ static void usage_exit (const char *name, int status) /* {{{ */
                        "  -Z percent   Exit with non-zero exit status if more than this percentage of\n"
                        "               probes timed out. (default: never)\n"
 
-                       "\noping "PACKAGE_VERSION", http://verplant.org/liboping/\n"
-                       "by Florian octo Forster <octo@verplant.org>\n"
+                       "\noping "PACKAGE_VERSION", http://noping.cc/\n"
+                       "by Florian octo Forster <ff@octo.it>\n"
                        "for contributions see `AUTHORS'\n",
                        name);
        exit (status);
@@ -585,7 +649,7 @@ static int read_options (int argc, char **argv) /* {{{ */
 
        while (1)
        {
-               optchar = getopt (argc, argv, "46c:hi:I:t:Q:f:D:Z:P:"
+               optchar = getopt (argc, argv, "46c:hi:I:t:Q:f:D:Z:P:m:w:"
 #if USE_NCURSES
                                "uUg:"
 #endif
@@ -638,6 +702,18 @@ static int read_options (int argc, char **argv) /* {{{ */
                                }
                                break;
 
+                       case 'w':
+                               {
+                                       char *endp = NULL;
+                                       double t = strtod (optarg, &endp);
+                                       if ((optarg[0] != 0) && (endp != NULL) && (*endp == 0))
+                                               opt_timeout = t;
+                                       else
+                                               fprintf (stderr, "Ignoring invalid timeout: %s\n",
+                                                               optarg);
+                               }
+                               break;
+
                        case 'I':
                                {
                                        if (opt_srcaddr != NULL)
@@ -650,6 +726,10 @@ static int read_options (int argc, char **argv) /* {{{ */
                                opt_device = optarg;
                                break;
 
+                       case 'm':
+                               opt_mark = optarg;
+                               break;
+
                        case 't':
                        {
                                int new_send_ttl;
@@ -686,9 +766,9 @@ static int read_options (int argc, char **argv) /* {{{ */
                                        opt_show_graph = 0;
                                else if (strcasecmp ("prettyping", optarg) == 0)
                                        opt_show_graph = 1;
-                               else if (strcasecmp ("boxplot", optarg) == 0)
-                                       opt_show_graph = 2;
                                else if (strcasecmp ("histogram", optarg) == 0)
+                                       opt_show_graph = 2;
+                               else if (strcasecmp ("boxplot", optarg) == 0)
                                        opt_show_graph = 3;
                                else
                                        fprintf (stderr, "Unknown graph option: %s\n", optarg);
@@ -802,23 +882,43 @@ static _Bool has_utf8() /* {{{ */
 
 static int update_graph_boxplot (ping_context_t *ctx) /* {{{ */
 {
+       uint32_t *counters;
        double *ratios;
        size_t i;
        size_t x_max;
        size_t x;
 
+       clean_history (ctx);
+
+       if (ctx->history_received == 0)
+               return (ENOENT);
+
        x_max = (size_t) getmaxx (ctx->window);
        if (x_max <= 8)
                return (EINVAL);
        x_max -= 4;
 
+       counters = calloc (x_max, sizeof (*counters));
        ratios = calloc (x_max, sizeof (*ratios));
 
-       /* Downsample */
-       for (i = 0; i < ctx->latency_histogram_size; i++)
+       /* Bucketize */
+       for (i = 0; i < ctx->history_received; i++)
        {
-               x = i * x_max / ctx->latency_histogram_size;
-               ratios[x] = ctx->histogram_ratio[i];
+               double latency = ctx->history_by_value[i] / 1000.0;
+               size_t index = (size_t) (((double) x_max) * latency / opt_interval);
+
+               if (index >= x_max)
+                       index = x_max - 1;
+
+               counters[index]++;
+       }
+
+       /* Sum and calc ratios */
+       ratios[0] = ((double) counters[0]) / ((double) ctx->history_received);
+       for (x = 1; x < x_max; x++)
+       {
+               counters[x] += counters[x - 1];
+               ratios[x] = ((double) counters[x]) / ((double) ctx->history_received);
        }
 
        for (x = 0; x < x_max; x++)
@@ -879,6 +979,7 @@ static int update_graph_boxplot (ping_context_t *ctx) /* {{{ */
                        wattroff (ctx->window, A_REVERSE);
        }
 
+       free (counters);
        free (ratios);
        return (0);
 } /* }}} int update_graph_boxplot */
@@ -886,79 +987,114 @@ static int update_graph_boxplot (ping_context_t *ctx) /* {{{ */
 static int update_graph_prettyping (ping_context_t *ctx, /* {{{ */
                double latency, unsigned int sequence)
 {
-       int color = OPING_RED;
-       char const *symbol = "!";
-       int symbolc = '!';
-
-       int x_max;
-       int x_pos;
+       size_t x;
+       size_t x_max;
+       size_t history_offset;
 
-       x_max = getmaxx (ctx->window);
-       x_pos = ((sequence - 1) % (x_max - 4)) + 2;
+       x_max = (size_t) getmaxx (ctx->window);
+       if (x_max <= 4)
+               return (EINVAL);
+       x_max -= 4;
 
-       if (latency >= 0.0)
+       /* Determine the first index in the history we need to draw
+        * the graph. */
+       history_offset = 0;
+       if (((size_t) x_max) < ctx->history_size) /* window is smaller than history */
        {
-               double ratio;
+               if (ctx->history_index > x_max)
+                       history_offset = ctx->history_index - x_max;
+               else /* wrap around */
+                       history_offset = ctx->history_index + ctx->history_size - x_max;
+       }
+       else /* window is larger than history */
+       {
+               if (ctx->history_index != ctx->history_size) /* no longer growing. */
+                       history_offset = ctx->history_index;
+               else /* start-up */
+                       history_offset = 0;
+       }
 
-               size_t symbols_num = hist_symbols_acs_num;
-               size_t colors_num = 1;
+       for (x = 0; x < x_max; x++)
+       {
+               size_t index;
+               double latency;
 
-               size_t index_symbols;
-               size_t index_colors;
-               size_t intensity;
+               int color = OPING_RED;
+               char const *symbol = "!";
+               int symbolc = '!';
 
-               /* latency is in milliseconds, opt_interval is in seconds. */
-               ratio = (latency * 0.001) / opt_interval;
-               if (ratio > 1) {
-                       ratio = 1.0;
+               if (x >= ctx->history_size)
+               {
+                       mvwaddch (ctx->window, /* y = */ 3, /* x = */ x + 2, ' ');
+                       continue;
                }
 
-               if (has_utf8 ())
-                       symbols_num = hist_symbols_utf8_num;
+               index = (history_offset + x) % ctx->history_size;
+               latency = ctx->history_by_time[index];
 
-               if (has_colors () == TRUE)
-                       colors_num = hist_colors_num;
+               if (latency >= 0.0)
+               {
+                       double ratio;
 
-               intensity = (size_t) (ratio * ((double) (symbols_num * colors_num)));
-               if (intensity >= (symbols_num * colors_num))
-                       intensity = (symbols_num * colors_num) - 1;
+                       size_t symbols_num = hist_symbols_acs_num;
+                       size_t colors_num = 1;
 
-               index_symbols = intensity % symbols_num;
-               assert (index_symbols < symbols_num);
+                       size_t index_symbols;
+                       size_t index_colors;
+                       size_t intensity;
 
-               index_colors = intensity / symbols_num;
-               assert (index_colors < colors_num);
+                       /* latency is in milliseconds, opt_interval is in seconds. */
+                       ratio = (latency * 0.001) / opt_interval;
+                       if (ratio > 1) {
+                               ratio = 1.0;
+                       }
 
-               if (has_utf8())
-               {
-                       color = hist_colors_utf8[index_colors];
-                       symbol = hist_symbols_utf8[index_symbols];
-               }
-               else
-               {
-                       color = hist_colors_acs[index_colors];
-                       symbolc = hist_symbols_acs[index_symbols] | A_ALTCHARSET;
+                       if (has_utf8 ())
+                               symbols_num = hist_symbols_utf8_num;
+
+                       if (has_colors () == TRUE)
+                               colors_num = hist_colors_num;
+
+                       intensity = (size_t) (ratio * ((double) (symbols_num * colors_num)));
+                       if (intensity >= (symbols_num * colors_num))
+                               intensity = (symbols_num * colors_num) - 1;
+
+                       index_symbols = intensity % symbols_num;
+                       assert (index_symbols < symbols_num);
+
+                       index_colors = intensity / symbols_num;
+                       assert (index_colors < colors_num);
+
+                       if (has_utf8())
+                       {
+                               color = hist_colors_utf8[index_colors];
+                               symbol = hist_symbols_utf8[index_symbols];
+                       }
+                       else
+                       {
+                               color = hist_colors_acs[index_colors];
+                               symbolc = hist_symbols_acs[index_symbols] | A_ALTCHARSET;
+                       }
                }
-       }
-       else /* if (!(latency >= 0.0)) */
-               wattron (ctx->window, A_BOLD);
+               else /* if (!(latency >= 0.0)) */
+                       wattron (ctx->window, A_BOLD);
 
-       if (has_colors () == TRUE)
-               wattron (ctx->window, COLOR_PAIR(color));
+               if (has_colors () == TRUE)
+                       wattron (ctx->window, COLOR_PAIR(color));
 
-       if (has_utf8())
-               mvwprintw (ctx->window, /* y = */ 3, /* x = */ x_pos, symbol);
-       else
-               mvwaddch (ctx->window, /* y = */ 3, /* x = */ x_pos, symbolc);
+               if (has_utf8())
+                       mvwprintw (ctx->window, /* y = */ 3, /* x = */ x + 2, symbol);
+               else
+                       mvwaddch (ctx->window, /* y = */ 3, /* x = */ x + 2, symbolc);
 
-       if (has_colors () == TRUE)
-               wattroff (ctx->window, COLOR_PAIR(color));
+               if (has_colors () == TRUE)
+                       wattroff (ctx->window, COLOR_PAIR(color));
 
-       /* Use negation here to handle NaN correctly. */
-       if (!(latency >= 0.0))
-               wattroff (ctx->window, A_BOLD);
+               /* Use negation here to handle NaN correctly. */
+               if (!(latency >= 0.0))
+                       wattroff (ctx->window, A_BOLD);
+       } /* for (x) */
 
-       wprintw (ctx->window, " ");
        return (0);
 } /* }}} int update_graph_prettyping */
 
@@ -966,7 +1102,6 @@ static int update_graph_histogram (ping_context_t *ctx) /* {{{ */
 {
        uint32_t *counters;
        uint32_t *accumulated;
-       uint32_t num;
        uint32_t max;
        size_t i;
        size_t x_max;
@@ -974,6 +1109,11 @@ static int update_graph_histogram (ping_context_t *ctx) /* {{{ */
 
        size_t symbols_num = hist_symbols_acs_num;
 
+       clean_history (ctx);
+
+       if (ctx->history_received == 0)
+               return (ENOENT);
+
        if (has_utf8 ())
                symbols_num = hist_symbols_utf8_num;
 
@@ -985,28 +1125,31 @@ static int update_graph_histogram (ping_context_t *ctx) /* {{{ */
        counters = calloc (x_max, sizeof (*counters));
        accumulated = calloc (x_max, sizeof (*accumulated));
 
-       /* Downsample */
+       /* Bucketize */
        max = 0;
-       for (i = 0; i < ctx->latency_histogram_size; i++)
+       for (i = 0; i < ctx->history_received; i++)
        {
-               x = i * x_max / ctx->latency_histogram_size;
-               counters[x] += ctx->histogram_counters[i];
-               accumulated[x] = counters[x];
+               double latency = ctx->history_by_value[i] / 1000.0;
+               size_t index = (size_t) (((double) x_max) * latency / opt_interval);
 
-               if (max < counters[x])
-                       max = counters[x];
+               if (index >= x_max)
+                       index = x_max - 1;
+
+               counters[index]++;
+               if (max < counters[index])
+                       max = counters[index];
        }
 
        /* Sum */
+       accumulated[0] = counters[0];
        for (x = 1; x < x_max; x++)
-               accumulated[x] += accumulated[x - 1];
-       num = accumulated[x_max - 1];
+               accumulated[x] = counters[x] + accumulated[x - 1];
 
        /* Calculate ratios */
        for (x = 0; x < x_max; x++)
        {
                double height = ((double) counters[x]) / ((double) max);
-               double ratio_this = ((double) accumulated[x]) / ((double) num);
+               double ratio_this = ((double) accumulated[x]) / ((double) ctx->history_received);
                double ratio_prev = 0.0;
                size_t index;
                int color = 0;
@@ -1016,13 +1159,17 @@ static int update_graph_histogram (ping_context_t *ctx) /* {{{ */
                        index = symbols_num - 1;
 
                if (x > 0)
-                       ratio_prev = ((double) accumulated[x - 1]) / ((double) num);
+                       ratio_prev = ((double) accumulated[x - 1]) / ((double) ctx->history_received);
 
                if (has_colors () == TRUE)
                {
-                       if ((ratio_this <= 0.5) || ((ratio_prev < 0.5) && (ratio_this > 0.5)))
+                       if ((ratio_this <= threshold_green)
+                                       || ((ratio_prev < threshold_green)
+                                               && (ratio_this > threshold_green)))
                                color = OPING_GREEN;
-                       else if ((ratio_this <= 0.95) || ((ratio_prev < 0.95) && (ratio_this > 0.95)))
+                       else if ((ratio_this <= threshold_yellow)
+                                       || ((ratio_prev < threshold_yellow)
+                                               && (ratio_this > threshold_yellow)))
                                color = OPING_YELLOW;
                        else
                                color = OPING_RED;
@@ -1081,31 +1228,27 @@ static int update_stats_from_context (ping_context_t *ctx, pingobj_iter_t *iter)
                        ctx->latency_total);
        if (ctx->req_rcvd != 0)
        {
-               double average;
-               double deviation;
+               double min;
+               double median;
+               double max;
                double percentile;
 
-               average = context_get_average (ctx);
-               deviation = context_get_stddev (ctx);
-               percentile = context_get_percentile (ctx, opt_percentile);
+               min = percentile_to_latency (ctx, 0.0);
+               median = percentile_to_latency (ctx, 50.0);
+               max = percentile_to_latency (ctx, 100.0);
+               percentile = percentile_to_latency (ctx, opt_percentile);
 
                mvwprintw (ctx->window, /* y = */ 2, /* x = */ 2,
-                               "rtt min/avg/%.0f%%/max/sdev = "
-                               "%.3f/%.3f/%.0f/%.3f/%.3f ms\n",
-                               opt_percentile,
-                               ctx->latency_min,
-                               average,
-                               percentile,
-                               ctx->latency_max,
-                               deviation);
+                               "RTT[ms]: min = %.0f, median = %.0f, p(%.0f) = %.0f, max = %.0f  ",
+                               min, median, opt_percentile, percentile, max);
        }
 
        if (opt_show_graph == 1)
                update_graph_prettyping (ctx, latency, sequence);
        else if (opt_show_graph == 2)
-               update_graph_boxplot (ctx);
-       else if (opt_show_graph == 3)
                update_graph_histogram (ctx);
+       else if (opt_show_graph == 3)
+               update_graph_boxplot (ctx);
 
        wrefresh (ctx->window);
 
@@ -1168,6 +1311,13 @@ static int check_resize (pingobj_t *ping) /* {{{ */
                        break;
                else if (key == KEY_RESIZE)
                        need_resize = 1;
+               else if (key == 'g')
+               {
+                       if (opt_show_graph == 3)
+                               opt_show_graph = 1;
+                       else if (opt_show_graph > 0)
+                               opt_show_graph++;
+               }
        }
 
        if (need_resize)
@@ -1299,47 +1449,28 @@ static int post_sleep_hook (__attribute__((unused)) pingobj_t *ping) /* {{{ */
 } /* }}} int post_sleep_hook */
 #endif
 
-static size_t latency_to_bucket (ping_context_t *ctx, double latency) /* {{{ */
-{
-       size_t bucket;
-
-       /* latency is in ms, opt_interval is in s. */
-       bucket = (size_t) ((latency * (ctx->latency_histogram_size - 1))
-                       / (1000.0 * opt_interval));
-       if (bucket >= ctx->latency_histogram_size)
-               bucket = ctx->latency_histogram_size - 1;
-
-       return (bucket);
-} /* }}} size_t latency_to_bucket */
-
-static void update_context (ping_context_t *context, double latency) /* {{{ */
+static void update_context (ping_context_t *ctx, double latency) /* {{{ */
 {
-       size_t bucket;
-       size_t i;
-       double num;
+       ctx->req_sent++;
 
-       context->req_rcvd++;
-       context->latency_total += latency;
-       context->latency_total_square += (latency * latency);
-
-       if ((context->latency_max < 0.0) || (context->latency_max < latency))
-               context->latency_max = latency;
-       if ((context->latency_min < 0.0) || (context->latency_min > latency))
-               context->latency_min = latency;
+       if (latency > 0.0)
+       {
+               ctx->req_rcvd++;
+               ctx->latency_total += latency;
+       }
+       else
+       {
+               latency = NAN;
+       }
 
-       bucket = latency_to_bucket (context, latency);
-       num = (double) context->req_rcvd;
+       ctx->history_by_time[ctx->history_index] = latency;
 
-       context->histogram_counters[bucket]++;
+       ctx->history_dirty = 1;
 
-       context->histogram_accumulated[0] = context->histogram_counters[0];
-       context->histogram_ratio[0] = ((double) context->histogram_accumulated[0]) / num;
-       for (i = 1; i < context->latency_histogram_size; i++)
-       {
-               context->histogram_accumulated[i] = context->histogram_accumulated[i - 1]
-                       + context->histogram_counters[i];
-               context->histogram_ratio[i] = ((double) context->histogram_accumulated[i]) / num;
-       }
+       /* Update index and size. */
+       ctx->history_index = (ctx->history_index + 1) % HISTORY_SIZE_MAX;
+       if (ctx->history_size < HISTORY_SIZE_MAX)
+               ctx->history_size++;
 } /* }}} void update_context */
 
 static void update_host_hook (pingobj_iter_t *iter, /* {{{ */
@@ -1386,31 +1517,20 @@ static void update_host_hook (pingobj_iter_t *iter, /* {{{ */
 # define HOST_PRINTF(...) printf(__VA_ARGS__)
 #endif
 
-       context->req_sent++;
+       update_context (context, latency);
+
        if (latency > 0.0)
        {
-               update_context (context, latency);
-
 #if USE_NCURSES
                if (has_colors () == TRUE)
                {
-                       size_t bucket;
-                       double ratio_this;
-                       double ratio_prev;
+                       double ratio;
                        int color = OPING_GREEN;
 
-                       bucket = latency_to_bucket (context, latency);
-                       ratio_this = context->histogram_ratio[bucket];
-                       if (bucket > 0)
-                               ratio_prev = context->histogram_ratio[bucket - 1];
-                       else
-                               ratio_prev = 0.0;
-
-                       if ((ratio_this <= 0.5) ||
-                                       ((ratio_prev < 0.5) && (ratio_this > 0.5)))
+                       ratio = latency_to_ratio (context, latency);
+                       if (ratio < threshold_green)
                                color = OPING_GREEN;
-                       else if ((ratio_this <= 0.95) ||
-                                       ((ratio_prev < 0.95) && (ratio_this > 0.95)))
+                       else if (ratio < threshold_yellow)
                                color = OPING_YELLOW;
                        else
                                color = OPING_RED;
@@ -1447,7 +1567,7 @@ static void update_host_hook (pingobj_iter_t *iter, /* {{{ */
                }
 #endif
        }
-       else
+       else /* if (!(latency > 0.0)) */
        {
 #if USE_NCURSES
                if (has_colors () == TRUE)
@@ -1512,22 +1632,18 @@ static int post_loop_hook (pingobj_t *ping) /* {{{ */
 
                if (context->req_rcvd != 0)
                {
-                       double average;
-                       double deviation;
+                       double min;
+                       double median;
+                       double max;
                        double percentile;
 
-                       average = context_get_average (context);
-                       deviation = context_get_stddev (context);
-                       percentile = context_get_percentile (context, opt_percentile);
-
-                       printf ("rtt min/avg/%.0f%%/max/sdev = "
-                                       "%.3f/%.3f/%.0f/%.3f/%.3f ms\n",
-                                       opt_percentile,
-                                       context->latency_min,
-                                       average,
-                                       percentile,
-                                       context->latency_max,
-                                       deviation);
+                       min = percentile_to_latency (context, 0.0);
+                       median = percentile_to_latency (context, 50.0);
+                       max = percentile_to_latency (context, 100.0);
+                       percentile = percentile_to_latency (context, opt_percentile);
+
+                       printf ("RTT[ms]: min = %.0f, median = %.0f, p(%.0f) = %.0f, max = %.0f\n",
+                                       min, median, opt_percentile, percentile, max);
                }
 
                ping_iterator_set_context (iter, NULL);
@@ -1568,7 +1684,7 @@ int main (int argc, char **argv) /* {{{ */
        }
 #endif
 
-        setlocale(LC_ALL, "");
+       setlocale(LC_ALL, "");
        optind = read_options (argc, argv);
 
 #if !_POSIX_SAVED_IDS
@@ -1619,6 +1735,12 @@ int main (int argc, char **argv) /* {{{ */
                /* printf ("ts_int = %i.%09li\n", (int) ts_int.tv_sec, ts_int.tv_nsec); */
        }
 
+       if (ping_setopt (ping, PING_OPT_TIMEOUT, (void*)(&opt_timeout)) != 0)
+       {
+               fprintf (stderr, "Setting timeout failed: %s\n",
+                               ping_get_error (ping));
+       }
+
        if (opt_addrfamily != PING_DEF_AF)
                ping_setopt (ping, PING_OPT_AF, (void *) &opt_addrfamily);
 
@@ -1640,6 +1762,23 @@ int main (int argc, char **argv) /* {{{ */
                }
        }
 
+       if(opt_mark != NULL)
+       {
+               char *endp;
+               int mark = strtoul(opt_mark, &endp, 0);
+               if(opt_mark[0] != '\0' && *endp == '\0')
+               {
+                       if(ping_setopt(ping, PING_OPT_MARK, (void*)(&mark)) != 0)
+                       {
+                               fprintf (stderr, "Setting mark failed: %s\n",
+                                       ping_get_error (ping));
+                       }
+               }
+               else{
+                       fprintf(stderr, "Ignoring invalid mark: %s\n", optarg);
+               }
+       }
+
        if (opt_filename != NULL)
        {
                FILE *infile;
@@ -1743,6 +1882,9 @@ int main (int argc, char **argv) /* {{{ */
                exit (EXIT_FAILURE);
        }
 
+       if (host_num == 0)
+               exit (EXIT_FAILURE);
+
 #if _POSIX_SAVED_IDS
        saved_set_uid = (uid_t) -1;
 #endif