src/oping.c

   1 /**
   2  * Object oriented C module to send ICMP and ICMPv6 `echo's.
   3  * Copyright (C) 2006-2010  Florian octo Forster <octo at verplant.org>
   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 as published by
   7  * the Free Software Foundation; only version 2 of the License is
   8  * applicable.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  18  */
  19
  20 #if HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 #if STDC_HEADERS
  25 # include <stdlib.h>
  26 # include <stdio.h>
  27 # include <string.h>
  28 # include <errno.h>
  29 # include <assert.h>
  30 #else
  31 # error "You don't have the standard C99 header files installed"
  32 #endif /* STDC_HEADERS */
  33
  34 #if HAVE_UNISTD_H
  35 # include <unistd.h>
  36 #endif
  37
  38 #if HAVE_MATH_H
  39 # include <math.h>
  40 #endif
  41
  42 #if TIME_WITH_SYS_TIME
  43 # include <sys/time.h>
  44 # include <time.h>
  45 #else
  46 # if HAVE_SYS_TIME_H
  47 #  include <sys/time.h>
  48 # else
  49 #  include <time.h>
  50 # endif
  51 #endif
  52
  53 #if HAVE_NETDB_H
  54 # include <netdb.h> /* NI_MAXHOST */
  55 #endif
  56
  57 #if HAVE_SIGNAL_H
  58 # include <signal.h>
  59 #endif
  60
  61 #if HAVE_SYS_TYPES_H
  62 #include <sys/types.h>
  63 #endif
  64
  65 #if USE_NCURSES
  66 # include <ncurses.h>
  67 #endif
  68
  69 #include "oping.h"
  70
  71 #ifndef _POSIX_SAVED_IDS
  72 # define _POSIX_SAVED_IDS 0
  73 #endif
  74
  75 typedef struct ping_context
  76 {
  77         char host[NI_MAXHOST];
  78         char addr[NI_MAXHOST];
  79
  80         int req_sent;
  81         int req_rcvd;
  82
  83         double latency_min;
  84         double latency_max;
  85         double latency_total;
  86         double latency_total_square;
  87
  88 #if USE_NCURSES
  89         WINDOW *window;
  90 #endif
  91 } ping_context_t;
  92
  93 static double  opt_interval   = 1.0;
  94 static int     opt_addrfamily = PING_DEF_AF;
  95 static char   *opt_srcaddr    = NULL;
  96 static char   *opt_device     = NULL;
  97 static char   *opt_filename   = NULL;
  98 static int     opt_count      = -1;
  99 static int     opt_send_ttl   = 64;
 100
 101 #if USE_NCURSES
 102 static WINDOW *main_win = NULL;
 103 #endif
 104
 105 static void sigint_handler (int signal) /* {{{ */
 106 {
 107         /* Make compiler happy */
 108         signal = 0;
 109         /* Exit the loop */
 110         opt_count = 0;
 111 } /* }}} void sigint_handler */
 112
 113 static ping_context_t *context_create (void)
 114 {
 115         ping_context_t *ret;
 116
 117         if ((ret = malloc (sizeof (ping_context_t))) == NULL)
 118                 return (NULL);
 119
 120         memset (ret, '\0', sizeof (ping_context_t));
 121
 122         ret->latency_min   = -1.0;
 123         ret->latency_max   = -1.0;
 124         ret->latency_total = 0.0;
 125         ret->latency_total_square = 0.0;
 126
 127 #if USE_NCURSES
 128         ret->window = NULL;
 129 #endif
 130
 131         return (ret);
 132 }
 133
 134 static void context_destroy (ping_context_t *context)
 135 {
 136         if (context == NULL)
 137                 return;
 138
 139 #if USE_NCURSES
 140         if (context->window != NULL)
 141         {
 142                 delwin (context->window);
 143                 context->window = NULL;
 144         }
 145 #endif
 146
 147         free (context);
 148 }
 149
 150 static double context_get_average (ping_context_t *ctx) /* {{{ */
 151 {
 152         double num_total;
 153
 154         if (ctx == NULL)
 155                 return (-1.0);
 156
 157         if (ctx->req_rcvd < 1)
 158                 return (-0.0);
 159
 160         num_total = (double) ctx->req_rcvd;
 161         return (ctx->latency_total / num_total);
 162 } /* }}} double context_get_average */
 163
 164 static double context_get_stddev (ping_context_t *ctx) /* {{{ */
 165 {
 166         double num_total;
 167
 168         if (ctx == NULL)
 169                 return (-1.0);
 170
 171         if (ctx->req_rcvd < 1)
 172                 return (-0.0);
 173         else if (ctx->req_rcvd < 2)
 174                 return (0.0);
 175
 176         num_total = (double) ctx->req_rcvd;
 177         return (sqrt (((num_total * ctx->latency_total_square)
 178                                         - (ctx->latency_total * ctx->latency_total))
 179                                 / (num_total * (num_total - 1.0))));
 180 } /* }}} double context_get_stddev */
 181
 182 static double context_get_packet_loss (const ping_context_t *ctx) /* {{{ */
 183 {
 184         if (ctx == NULL)
 185                 return (-1.0);
 186
 187         if (ctx->req_sent < 1)
 188                 return (0.0);
 189
 190         return (100.0 * (ctx->req_sent - ctx->req_rcvd)
 191                         / ((double) ctx->req_sent));
 192 } /* }}} double context_get_packet_loss */
 193
 194 static void usage_exit (const char *name, int status)
 195 {
 196         int name_length;
 197
 198         name_length = (int) strlen (name);
 199
 200         fprintf (stderr, "Usage: %s [OPTIONS] "
 201                                 "-f filename | host [host [host ...]]\n"
 202
 203                         "\nAvailable options:\n"
 204                         "  -4|-6        force the use of IPv4 or IPv6\n"
 205                         "  -c count     number of ICMP packets to send\n"
 206                         "  -i interval  interval with which to send ICMP packets\n"
 207                         "  -t ttl       time to live for each ICMP packet\n"
 208                         "  -I srcaddr   source address\n"
 209                         "  -D device    outgoing interface name\n"
 210                         "  -f filename  filename to read hosts from\n"
 211
 212                         "\noping "PACKAGE_VERSION", http://verplant.org/liboping/\n"
 213                         "by Florian octo Forster <octo@verplant.org>\n"
 214                         "for contributions see `AUTHORS'\n",
 215                         name);
 216         exit (status);
 217 }
 218
 219 static int read_options (int argc, char **argv) /* {{{ */
 220 {
 221         int optchar;
 222
 223         while (1)
 224         {
 225                 optchar = getopt (argc, argv, "46c:hi:I:t:f:D:");
 226
 227                 if (optchar == -1)
 228                         break;
 229
 230                 switch (optchar)
 231                 {
 232                         case '4':
 233                         case '6':
 234                                 opt_addrfamily = (optchar == '4') ? AF_INET : AF_INET6;
 235                                 break;
 236
 237                         case 'c':
 238                                 {
 239                                         int new_count;
 240                                         new_count = atoi (optarg);
 241                                         if (new_count > 0)
 242                                                 opt_count = new_count;
 243                                         else
 244                                                 fprintf(stderr, "Ignoring invalid count: %s\n",
 245                                                                 optarg);
 246                                 }
 247                                 break;
 248
 249                         case 'f':
 250                                 {
 251                                         if (opt_filename != NULL)
 252                                                 free (opt_filename);
 253                                         opt_filename = strdup (optarg);
 254                                 }
 255                                 break;
 256
 257                         case 'i':
 258                                 {
 259                                         double new_interval;
 260                                         new_interval = atof (optarg);
 261                                         if (new_interval < 0.001)
 262                                                 fprintf (stderr, "Ignoring invalid interval: %s\n",
 263                                                                 optarg);
 264                                         else
 265                                                 opt_interval = new_interval;
 266                                 }
 267                                 break;
 268                         case 'I':
 269                                 {
 270                                         if (opt_srcaddr != NULL)
 271                                                 free (opt_srcaddr);
 272                                         opt_srcaddr = strdup (optarg);
 273                                 }
 274                                 break;
 275
 276                         case 'D':
 277                                 opt_device = optarg;
 278                                 break;
 279
 280                         case 't':
 281                         {
 282                                 int new_send_ttl;
 283                                 new_send_ttl = atoi (optarg);
 284                                 if ((new_send_ttl > 0) && (new_send_ttl < 256))
 285                                         opt_send_ttl = new_send_ttl;
 286                                 else
 287                                         fprintf (stderr, "Ignoring invalid TTL argument: %s\n",
 288                                                         optarg);
 289                                 break;
 290                         }
 291
 292                         case 'h':
 293                                 usage_exit (argv[0], 0);
 294                                 break;
 295                         default:
 296                                 usage_exit (argv[0], 1);
 297                 }
 298         }
 299
 300         return (optind);
 301 } /* }}} read_options */
 302
 303 static void print_host (pingobj_iter_t *iter)
 304 {
 305         double          latency;
 306         unsigned int    sequence;
 307         int             recv_ttl;
 308         size_t          buffer_len;
 309         size_t          data_len;
 310         ping_context_t *context;
 311
 312         latency = -1.0;
 313         buffer_len = sizeof (latency);
 314         ping_iterator_get_info (iter, PING_INFO_LATENCY,
 315                         &latency, &buffer_len);
 316
 317         sequence = 0;
 318         buffer_len = sizeof (sequence);
 319         ping_iterator_get_info (iter, PING_INFO_SEQUENCE,
 320                         &sequence, &buffer_len);
 321
 322         recv_ttl = -1;
 323         buffer_len = sizeof (recv_ttl);
 324         ping_iterator_get_info (iter, PING_INFO_RECV_TTL,
 325                         &recv_ttl, &buffer_len);
 326
 327         data_len = 0;
 328         ping_iterator_get_info (iter, PING_INFO_DATA,
 329                         NULL, &data_len);
 330
 331         context = (ping_context_t *) ping_iterator_get_context (iter);
 332
 333 #if USE_NCURSES
 334 # define HOST_PRINTF(...) wprintw(main_win, __VA_ARGS__)
 335 #else
 336 # define HOST_PRINTF(...) printf(__VA_ARGS__)
 337 #endif
 338
 339         context->req_sent++;
 340         if (latency > 0.0)
 341         {
 342                 context->req_rcvd++;
 343                 context->latency_total += latency;
 344                 context->latency_total_square += (latency * latency);
 345
 346                 if ((context->latency_max < 0.0) || (context->latency_max < latency))
 347                         context->latency_max = latency;
 348                 if ((context->latency_min < 0.0) || (context->latency_min > latency))
 349                         context->latency_min = latency;
 350
 351                 HOST_PRINTF ("%zu bytes from %s (%s): icmp_seq=%u ttl=%i "
 352                                 "time=%.2f ms\n",
 353                                 data_len,
 354                                 context->host, context->addr,
 355                                 sequence, recv_ttl, latency);
 356         }
 357         else
 358         {
 359                 HOST_PRINTF ("echo reply from %s (%s): icmp_seq=%u timeout\n",
 360                                 context->host, context->addr,
 361                                 sequence);
 362         }
 363
 364 #if USE_NCURSES
 365         wrefresh (main_win);
 366         werase (context->window);
 367         box (context->window, 0, 0);
 368         mvwprintw (context->window, /* y = */ 0, /* x = */ 5,
 369                         " %s ping statistics ",
 370                         context->host);
 371         mvwprintw (context->window, /* y = */ 1, /* x = */ 2,
 372                         "%i packets transmitted, %i received, %.2f%% packet "
 373                         "loss, time %.1fms",
 374                         context->req_sent, context->req_rcvd,
 375                         100.0 * (context->req_sent - context->req_rcvd) / ((double) context->req_sent),
 376                         context->latency_total);
 377         if (context->req_rcvd != 0)
 378         {
 379                 double average;
 380                 double deviation;
 381
 382                 average = context_get_average (context);
 383                 deviation = context_get_stddev (context);
 384
 385                 mvwprintw (context->window, /* y = */ 2, /* x = */ 2,
 386                                 "rtt min/avg/max/sdev = %.3f/%.3f/%.3f/%.3f ms",
 387                                 context->latency_min,
 388                                 average,
 389                                 context->latency_max,
 390                                 deviation);
 391         }
 392         wrefresh (context->window);
 393 #endif
 394 }
 395
 396 static void time_normalize (struct timespec *ts)
 397 {
 398         while (ts->tv_nsec < 0)
 399         {
 400                 if (ts->tv_sec == 0)
 401                 {
 402                         ts->tv_nsec = 0;
 403                         return;
 404                 }
 405
 406                 ts->tv_sec  -= 1;
 407                 ts->tv_nsec += 1000000000;
 408         }
 409
 410         while (ts->tv_nsec >= 1000000000)
 411         {
 412                 ts->tv_sec  += 1;
 413                 ts->tv_nsec -= 1000000000;
 414         }
 415 }
 416
 417 static void time_calc (struct timespec *ts_dest, /* {{{ */
 418                 const struct timespec *ts_int,
 419                 const struct timeval  *tv_begin,
 420                 const struct timeval  *tv_end)
 421 {
 422         ts_dest->tv_sec = tv_begin->tv_sec + ts_int->tv_sec;
 423         ts_dest->tv_nsec = (tv_begin->tv_usec * 1000) + ts_int->tv_nsec;
 424         time_normalize (ts_dest);
 425
 426         /* Assure that `(begin + interval) > end'.
 427          * This may seem overly complicated, but `tv_sec' is of type `time_t'
 428          * which may be `unsigned. *sigh* */
 429         if ((tv_end->tv_sec > ts_dest->tv_sec)
 430                         || ((tv_end->tv_sec == ts_dest->tv_sec)
 431                                 && ((tv_end->tv_usec * 1000) > ts_dest->tv_nsec)))
 432         {
 433                 ts_dest->tv_sec  = 0;
 434                 ts_dest->tv_nsec = 0;
 435                 return;
 436         }
 437
 438         ts_dest->tv_sec = ts_dest->tv_sec - tv_end->tv_sec;
 439         ts_dest->tv_nsec = ts_dest->tv_nsec - (tv_end->tv_usec * 1000);
 440         time_normalize (ts_dest);
 441 } /* }}} void time_calc */
 442
 443 static int print_header (pingobj_t *ping) /* {{{ */
 444 {
 445         pingobj_iter_t *iter;
 446         int i;
 447
 448 #if USE_NCURSES
 449         initscr ();
 450         cbreak ();
 451         noecho ();
 452 #endif
 453
 454         i = 0;
 455         for (iter = ping_iterator_get (ping);
 456                         iter != NULL;
 457                         iter = ping_iterator_next (iter))
 458         {
 459                 ping_context_t *context;
 460                 size_t buffer_size;
 461
 462                 context = context_create ();
 463
 464                 buffer_size = sizeof (context->host);
 465                 ping_iterator_get_info (iter, PING_INFO_HOSTNAME, context->host, &buffer_size);
 466
 467                 buffer_size = sizeof (context->addr);
 468                 ping_iterator_get_info (iter, PING_INFO_ADDRESS, context->addr, &buffer_size);
 469
 470                 buffer_size = 0;
 471                 ping_iterator_get_info (iter, PING_INFO_DATA, NULL, &buffer_size);
 472
 473 #if USE_NCURSES
 474                 context->window = newwin (/* height = */ 4, COLS,
 475                                 /* start y = */ 4*i, /* start x = */ 0);
 476                 box (context->window, 0, 0);
 477                 mvwprintw (context->window, /* y = */ 0, /* x = */ 5,
 478                                 " %s ping statistics ",
 479                                 context->host);
 480                 wrefresh (context->window);
 481 #else /* !USE_NCURSES */
 482                 printf ("PING %s (%s) %zu bytes of data.\n",
 483                                 context->host, context->addr, buffer_size);
 484 #endif
 485
 486                 ping_iterator_set_context (iter, (void *) context);
 487
 488                 i++;
 489         }
 490
 491 #if USE_NCURSES
 492         delwin (main_win);
 493         main_win = newwin (LINES - 4*i, COLS, 4*i, 0);
 494         scrollok (main_win, TRUE);
 495 #endif
 496
 497         return (0);
 498 } /* }}} int print_header */
 499
 500 static int print_footer (pingobj_t *ping)
 501 {
 502         pingobj_iter_t *iter;
 503
 504 #if USE_NCURSES
 505         endwin ();
 506 #endif
 507
 508         for (iter = ping_iterator_get (ping);
 509                         iter != NULL;
 510                         iter = ping_iterator_next (iter))
 511         {
 512                 ping_context_t *context;
 513
 514                 context = ping_iterator_get_context (iter);
 515
 516                 printf ("\n--- %s ping statistics ---\n"
 517                                 "%i packets transmitted, %i received, %.2f%% packet loss, time %.1fms\n",
 518                                 context->host, context->req_sent, context->req_rcvd,
 519                                 context_get_packet_loss (context),
 520                                 context->latency_total);
 521
 522                 if (context->req_rcvd != 0)
 523                 {
 524                         double average;
 525                         double deviation;
 526
 527                         average = context_get_average (context);
 528                         deviation = context_get_stddev (context);
 529
 530                         printf ("rtt min/avg/max/sdev = %.3f/%.3f/%.3f/%.3f ms\n",
 531                                         context->latency_min,
 532                                         average,
 533                                         context->latency_max,
 534                                         deviation);
 535                 }
 536
 537                 ping_iterator_set_context (iter, NULL);
 538                 context_destroy (context);
 539         }
 540
 541         return (0);
 542 } /* }}} int print_footer */
 543
 544 int main (int argc, char **argv) /* {{{ */
 545 {
 546         pingobj_t      *ping;
 547         pingobj_iter_t *iter;
 548
 549         struct sigaction sigint_action;
 550
 551         struct timeval  tv_begin;
 552         struct timeval  tv_end;
 553         struct timespec ts_wait;
 554         struct timespec ts_int;
 555
 556         int optind;
 557         int i;
 558         int status;
 559 #if _POSIX_SAVED_IDS
 560         uid_t saved_set_uid;
 561
 562         /* Save the old effective user id */
 563         saved_set_uid = geteuid ();
 564         /* Set the effective user ID to the real user ID without changing the
 565          * saved set-user ID */
 566         status = seteuid (getuid ());
 567         if (status != 0)
 568         {
 569                 fprintf (stderr, "Temporarily dropping privileges "
 570                                 "failed: %s\n", strerror (errno));
 571                 exit (EXIT_FAILURE);
 572         }
 573 #endif
 574
 575         optind = read_options (argc, argv);
 576
 577 #if !_POSIX_SAVED_IDS
 578         /* Cannot temporarily drop privileges -> reject every file but "-". */
 579         if ((opt_filename != NULL)
 580                         && (strcmp ("-", opt_filename) != 0)
 581                         && (getuid () != geteuid ()))
 582         {
 583                 fprintf (stderr, "Your real and effective user IDs don't "
 584                                 "match. Reading from a file (option '-f')\n"
 585                                 "is therefore too risky. You can still read "
 586                                 "from STDIN using '-f -' if you like.\n"
 587                                 "Sorry.\n");
 588                 exit (EXIT_FAILURE);
 589         }
 590 #endif
 591
 592         if ((optind >= argc) && (opt_filename == NULL)) {
 593                 usage_exit (argv[0], 1);
 594         }
 595
 596         if ((ping = ping_construct ()) == NULL)
 597         {
 598                 fprintf (stderr, "ping_construct failed\n");
 599                 return (1);
 600         }
 601
 602         if (ping_setopt (ping, PING_OPT_TTL, &opt_send_ttl) != 0)
 603         {
 604                 fprintf (stderr, "Setting TTL to %i failed: %s\n",
 605                                 opt_send_ttl, ping_get_error (ping));
 606         }
 607
 608         {
 609                 double temp_sec;
 610                 double temp_nsec;
 611
 612                 temp_nsec = modf (opt_interval, &temp_sec);
 613                 ts_int.tv_sec  = (time_t) temp_sec;
 614                 ts_int.tv_nsec = (long) (temp_nsec * 1000000000L);
 615
 616                 /* printf ("ts_int = %i.%09li\n", (int) ts_int.tv_sec, ts_int.tv_nsec); */
 617         }
 618
 619         if (opt_addrfamily != PING_DEF_AF)
 620                 ping_setopt (ping, PING_OPT_AF, (void *) &opt_addrfamily);
 621
 622         if (opt_srcaddr != NULL)
 623         {
 624                 if (ping_setopt (ping, PING_OPT_SOURCE, (void *) opt_srcaddr) != 0)
 625                 {
 626                         fprintf (stderr, "Setting source address failed: %s\n",
 627                                         ping_get_error (ping));
 628                 }
 629         }
 630
 631         if (opt_device != NULL)
 632         {
 633                 if (ping_setopt (ping, PING_OPT_DEVICE, (void *) opt_device) != 0)
 634                 {
 635                         fprintf (stderr, "Setting device failed: %s\n",
 636                                         ping_get_error (ping));
 637                 }
 638         }
 639
 640         if (opt_filename != NULL)
 641         {
 642                 FILE *infile;
 643                 char line[256];
 644                 char host[256];
 645
 646                 if (strcmp (opt_filename, "-") == 0)
 647                         /* Open STDIN */
 648                         infile = fdopen(0, "r");
 649                 else
 650                         infile = fopen(opt_filename, "r");
 651
 652                 if (infile == NULL)
 653                 {
 654                         fprintf (stderr, "Opening %s failed: %s\n",
 655                                         (strcmp (opt_filename, "-") == 0)
 656                                         ? "STDIN" : opt_filename,
 657                                         strerror(errno));
 658                         return (1);
 659                 }
 660
 661 #if _POSIX_SAVED_IDS
 662                 /* Regain privileges */
 663                 status = seteuid (saved_set_uid);
 664                 if (status != 0)
 665                 {
 666                         fprintf (stderr, "Temporarily re-gaining privileges "
 667                                         "failed: %s\n", strerror (errno));
 668                         exit (EXIT_FAILURE);
 669                 }
 670 #endif
 671
 672                 while (fgets(line, sizeof(line), infile))
 673                 {
 674                         /* Strip whitespace */
 675                         if (sscanf(line, "%s", host) != 1)
 676                                 continue;
 677
 678                         if ((host[0] == 0) || (host[0] == '#'))
 679                                 continue;
 680
 681                         if (ping_host_add(ping, host) < 0)
 682                         {
 683                                 const char *errmsg = ping_get_error (ping);
 684
 685                                 fprintf (stderr, "Adding host `%s' failed: %s\n", host, errmsg);
 686                                 continue;
 687                         }
 688                 }
 689
 690 #if _POSIX_SAVED_IDS
 691                 /* Drop privileges */
 692                 status = seteuid (getuid ());
 693                 if (status != 0)
 694                 {
 695                         fprintf (stderr, "Temporarily dropping privileges "
 696                                         "failed: %s\n", strerror (errno));
 697                         exit (EXIT_FAILURE);
 698                 }
 699 #endif
 700
 701                 fclose(infile);
 702         }
 703
 704 #if _POSIX_SAVED_IDS
 705         /* Regain privileges */
 706         status = seteuid (saved_set_uid);
 707         if (status != 0)
 708         {
 709                 fprintf (stderr, "Temporarily re-gaining privileges "
 710                                 "failed: %s\n", strerror (errno));
 711                 exit (EXIT_FAILURE);
 712         }
 713 #endif
 714
 715         for (i = optind; i < argc; i++)
 716         {
 717                 if (ping_host_add (ping, argv[i]) < 0)
 718                 {
 719                         const char *errmsg = ping_get_error (ping);
 720
 721                         fprintf (stderr, "Adding host `%s' failed: %s\n", argv[i], errmsg);
 722                         continue;
 723                 }
 724         }
 725
 726         /* Permanently drop root privileges if we're setuid-root. */
 727         status = setuid (getuid ());
 728         if (status != 0)
 729         {
 730                 fprintf (stderr, "Dropping privileges failed: %s\n",
 731                                 strerror (errno));
 732                 exit (EXIT_FAILURE);
 733         }
 734
 735 #if _POSIX_SAVED_IDS
 736         saved_set_uid = (uid_t) -1;
 737 #endif
 738
 739         print_header (ping);
 740
 741         if (i == 0)
 742                 return (1);
 743
 744         memset (&sigint_action, '\0', sizeof (sigint_action));
 745         sigint_action.sa_handler = sigint_handler;
 746         if (sigaction (SIGINT, &sigint_action, NULL) < 0)
 747         {
 748                 perror ("sigaction");
 749                 return (1);
 750         }
 751
 752         while (opt_count != 0)
 753         {
 754                 int status;
 755
 756                 if (gettimeofday (&tv_begin, NULL) < 0)
 757                 {
 758                         perror ("gettimeofday");
 759                         return (1);
 760                 }
 761
 762                 if (ping_send (ping) < 0)
 763                 {
 764                         fprintf (stderr, "ping_send failed: %s\n",
 765                                         ping_get_error (ping));
 766                         return (1);
 767                 }
 768
 769                 for (iter = ping_iterator_get (ping);
 770                                 iter != NULL;
 771                                 iter = ping_iterator_next (iter))
 772                 {
 773                         print_host (iter);
 774                 }
 775                 fflush (stdout);
 776
 777                 /* Don't sleep in the last iteration */
 778                 if (opt_count == 1)
 779                         break;
 780
 781                 if (gettimeofday (&tv_end, NULL) < 0)
 782                 {
 783                         perror ("gettimeofday");
 784                         return (1);
 785                 }
 786
 787                 time_calc (&ts_wait, &ts_int, &tv_begin, &tv_end);
 788
 789                 /* printf ("Sleeping for %i.%09li seconds\n", (int) ts_wait.tv_sec, ts_wait.tv_nsec); */
 790                 while ((status = nanosleep (&ts_wait, &ts_wait)) != 0)
 791                 {
 792                         if (errno != EINTR)
 793                         {
 794                                 perror ("nanosleep");
 795                                 break;
 796                         }
 797                         else if (opt_count == 0)
 798                         {
 799                                 /* sigint */
 800                                 break;
 801                         }
 802                 }
 803
 804                 if (opt_count > 0)
 805                         opt_count--;
 806         } /* while (opt_count != 0) */
 807
 808         print_footer (ping);
 809
 810         ping_destroy (ping);
 811
 812         return (0);
 813 } /* }}} int main */
 814
 815 /* vim: set fdm=marker : */