home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume26 / fping / part01 / fping.c < prev    next >
C/C++ Source or Header  |  1993-07-03  |  23KB  |  822 lines
  1. /* 
  2.  * fping: fast-ping, file-ping
  3.  *
  4.  * Used to send out ping requests to a list of hosts in a round robin
  5.  * fashion. 
  6.  *
  7.  *
  8.  *   fping has been compiled tested under the following systems:
  9.  *
  10.  *  Ultrix 4.2a DECstation
  11.  *  Ultrix 3.1 VAX
  12.  *  NeXT 2.1
  13.  *  SunOS 4.1.1 Sparcstation (gcc and cc)
  14.  *  AIX 3.1 RISC System/6000
  15.  *
  16.  */
  17.  
  18. /* 
  19.  ***************************************************
  20.  *
  21.  * Standard RCS Header information (see co(1))
  22.  *
  23.  * $Author: schemers $
  24.  *
  25.  * $Date: 1993/02/23 00:16:38 $
  26.  *
  27.  * $Revision: 1.20 $
  28.  *
  29.  * $Locker: schemers $
  30.  *
  31.  * $Source: /networking/src/fping/RCS/fping.c,v $
  32.  *
  33.  * $State: Exp $
  34.  *
  35.  * $Log: fping.c,v $
  36.  * Revision 1.20  1993/02/23  00:16:38  schemers
  37.  * fixed syntax error (should have compiled before checking in...)
  38.  *
  39.  * Revision 1.19  1993/02/23  00:15:15  schemers
  40.  * turned off printing of "is alive" when -a is specified.
  41.  *
  42.  * Revision 1.18  1992/07/28  15:16:44  schemers
  43.  * added a fflush(stdout) call before the summary is sent to stderr, so
  44.  * everything shows up in the right order.
  45.  *
  46.  * Revision 1.17  1992/07/23  03:29:42  schemers
  47.  * fixed declaration of timeval_diff.
  48.  *
  49.  * Revision 1.16  1992/07/22  19:24:37  schemers
  50.  * Modified file reading so it would skip blanks lines or lines starting
  51.  * with a '#'. Now you can do something like:
  52.  *
  53.  * fping -ad < /etc/hosts
  54.  *
  55.  * Revision 1.15  1992/07/21  17:07:18  schemers
  56.  * Put in sanity checks so only root can specify "dangerous" options.
  57.  * Changed usage to show switchs in alphabetical order.
  58.  *
  59.  * Revision 1.14  1992/07/21  16:40:52  schemers
  60.  * Now when sendto returns an error, the host is considered unreachable and
  61.  * and the error message (from errno) is displayed.
  62.  *
  63.  * Revision 1.13  1992/07/17  21:02:17  schemers
  64.  * changed default timeout to 2500 msec (for WANs), and default try
  65.  * to 3. This gives 10 second overall timeout.
  66.  *
  67.  * Added -e option for showing elapsed (round-trip) time on packets
  68.  *
  69.  * Modified -s option to inlude to round-trip stats
  70.  *
  71.  * Added #ifndef DEFAULT_* stuff its easier to change the defaults
  72.  *
  73.  * Reorganized main loop.
  74.  *
  75.  * cleaned up timeval stuff. removed set_timeval and timeval_expired
  76.  * since they aren't needed anymore. Just use timeval_diff.
  77.  *
  78.  * Revision 1.12  1992/07/17  16:38:54  schemers
  79.  * move socket create call so I could do a setuid(getuid()) before the
  80.  * fopen call is made. Once the socket is created root privs aren't needed
  81.  * to send stuff out on it.
  82.  *
  83.  * Revision 1.11  1992/07/17  16:28:38  schemers
  84.  * moved num_timeout counter. It really was for debug purposes and didn't
  85.  * make sense to the general public :-) Now it is the number of timeouts
  86.  * (pings that didn't get received with the time limit).
  87.  *
  88.  * Revision 1.10  1992/07/16  16:24:38  schemers
  89.  * changed usage() to use fprintf(stderr,"...");
  90.  *
  91.  * Revision 1.9  1992/07/16  16:00:04  schemers
  92.  * Added _NO_PROTO stuff for older compilers, and _POSIX_SOURCE
  93.  * for unistd.h, and _POSIX_SOURCE for stdlib.h. Also added
  94.  * check for __cplusplus.
  95.  *
  96.  * Revision 1.8  1992/07/16  05:44:41  schemers
  97.  * changed -a and -u to only show hostname in results. This is
  98.  * for easier parsing. Also added -v flag
  99.  *
  100.  * Revision 1.7  1992/07/14  18:45:23  schemers
  101.  * initialized last_time in add_host function
  102.  *
  103.  * Revision 1.6  1992/07/14  18:32:40  schemers
  104.  * changed select to use FD_ macros
  105.  *
  106.  * Revision 1.5  1992/07/14  17:21:22  schemers
  107.  * standardized exit status codes
  108.  *
  109.  * Revision 1.4  1992/06/26  15:25:35  schemers
  110.  * changed name from rrping to fping
  111.  *
  112.  * Revision 1.3  1992/06/24  15:39:32  schemers
  113.  * added -d option for unreachable systems
  114.  *
  115.  * Revision 1.2  1992/06/23  03:01:23  schemers
  116.  * misc fixes from R.L. "Bob" Morgan
  117.  *
  118.  * Revision 1.1  1992/06/19  18:23:52  schemers
  119.  * Initial revision
  120.  *
  121.  *--------------------------------------------------
  122.  * Copyright (c) 1992 Board of Trustees
  123.  *            Leland Stanford Jr. University
  124.  ***************************************************
  125.  */
  126.  
  127. /*
  128.  * Redistribution and use in source and binary forms are permitted
  129.  * provided that the above copyright notice and this paragraph are
  130.  * duplicated in all such forms and that any documentation,
  131.  * advertising materials, and other materials related to such
  132.  * distribution and use acknowledge that the software was developed
  133.  * by Stanford University.  The name of the University may not be used 
  134.  * to endorse or promote products derived from this software without 
  135.  * specific prior written permission.
  136.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  137.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  138.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  139.  */
  140.  
  141. #ifndef _NO_PROTO
  142. #if !__STDC__ && !defined(__cplusplus) && !defined(FUNCPROTO) \
  143.                                                  && !defined(_POSIX_SOURCE)
  144. #define _NO_PROTO
  145. #endif /* __STDC__ */
  146. #endif /* _NO_PROTO */
  147.  
  148. #ifdef __cplusplus
  149. extern "C" {
  150. #endif
  151.  
  152. #include <stdio.h>
  153. #include <errno.h>
  154. #include <time.h>
  155.  
  156. #ifdef _POSIX_SOURCE
  157. #include <unistd.h>
  158. #endif
  159.  
  160. #ifdef __STDC__
  161. #include <stdlib.h>
  162. #endif
  163.  
  164. #include <string.h>
  165.  
  166. #include <sys/types.h>
  167. #include <sys/time.h>
  168. #include <sys/socket.h>
  169.  
  170.  
  171. #include <netinet/in_systm.h>
  172. #include <netinet/in.h>
  173. #include <netinet/ip.h>
  174. #include <netinet/ip_icmp.h>
  175. #include <arpa/inet.h>
  176.  
  177. #include <netdb.h>
  178.  
  179. /* RS6000 has sys/select.h */
  180. #ifndef FD_SET
  181. #include <sys/select.h>
  182. #endif
  183.  
  184. /* externals */
  185.  
  186. extern char *optarg;
  187. extern int optind,opterr;
  188. extern char *sys_errlist[];
  189.  
  190.  
  191. #ifdef __cplusplus
  192. }
  193. #endif
  194.  
  195. /* constants */
  196.  
  197. #ifndef DEFAULT_INTERVAL
  198. #define DEFAULT_INTERVAL 25        /* default time between packets (msec) */
  199. #endif
  200.  
  201. #ifndef DEFAULT_TIMEOUT
  202. #define DEFAULT_TIMEOUT 2500       /* individual host timeouts */
  203. #endif
  204.  
  205. #ifndef DEFAULT_RETRY 
  206. #define DEFAULT_RETRY 3            /* number of times to retry a host */
  207. #endif
  208.  
  209.  
  210. /* typedef's */
  211.  
  212. /* entry used to keep track of each host we are pinging */
  213.  
  214. typedef struct host_entry {
  215.      char                 *host;              /* text description of host */
  216.      struct sockaddr_in   saddr;              /* internet address */
  217.      int                  i;                  /* index into array */
  218.      int                  num_packets_sent;   /* number of ping packets sent */
  219.      struct host_entry    *prev,*next;        /* doubly linked list */
  220.      struct timeval       last_time;          /* time of last packet sent */
  221. } HOST_ENTRY;
  222.  
  223. /* globals */
  224.  
  225. HOST_ENTRY *rrlist=NULL;    /* linked list of hosts be pinged */
  226. HOST_ENTRY **table=NULL;    /* array of pointers to items in the list */
  227. HOST_ENTRY *cursor;
  228.  
  229. char *prog;
  230. int ident;                  /* our pid */
  231. int s;                      /* socket */
  232.  
  233. int retry = DEFAULT_RETRY;
  234. int timeout = DEFAULT_TIMEOUT;
  235. int interval = DEFAULT_INTERVAL;
  236.  
  237. long max_reply=0;
  238. long min_reply=10000;
  239. int total_replies=0;
  240. double sum_replies=0;
  241.  
  242. struct timeval timeout_timeval;
  243. struct timezone tz;
  244.  
  245. int num_waiting=0;                 /* number of hosts we are pinging */
  246. int num_hosts;                     /* total number of hosts */
  247.  
  248. int num_alive=0,                  /* total number alive */
  249.     num_unreachable=0,            /* total number unreachable */
  250.     num_noaddress=0;              /* total number of addresses not found */
  251.  
  252. int num_timeout=0,                /* number of times select timed out */
  253.     num_pingsent=0,               /* total pings sent */
  254.     num_pingreceived=0;           /* total pings received */
  255.  
  256. struct timeval current_time;      /* current time (pseudo) */
  257. struct timeval start_time; 
  258. struct timeval end_time;   
  259.  
  260. /* switches */
  261. int verbose_flag,dns_flag,stats_flag,unreachable_flag,alive_flag;
  262. int elapsed_flag,version_flag;
  263.  
  264. char *filename=NULL;               /* file containing hosts to ping */
  265.  
  266. /* forward declarations */
  267.  
  268. #ifdef _NO_PROTO
  269.  
  270. void add_host();
  271. void crash_and_burn();
  272. void errno_crash_and_burn();
  273. char *get_host_by_address();
  274. int in_cksum();
  275. int recvfrom_wto ();
  276. void remove_job();
  277. void send_ping();
  278. void usage();
  279. int wait_for_reply();
  280. long timeval_diff();
  281. #else
  282.  
  283. void add_host(char *host);
  284. void crash_and_burn(char *message);
  285. void errno_crash_and_burn(char *message);
  286. char *get_host_by_address(struct in_addr in);
  287. int in_cksum(u_short *p, int n);
  288. int recvfrom_wto (int s, char *buf, int len, struct sockaddr *saddr, int timo);
  289. void remove_job(HOST_ENTRY *h);
  290. void send_ping(int s,HOST_ENTRY *h);
  291. long timeval_diff(struct timeval *a,struct timeval *b);
  292. void usage();
  293. int wait_for_reply();
  294.  
  295. #endif
  296.  
  297. #ifdef _NO_PROTO
  298. int main(argc,argv)
  299. int argc; char **argv;
  300. #else
  301. int main(int argc, char **argv)
  302. #endif
  303. {
  304.  
  305.   int c;
  306.  
  307.   struct protoent *proto;
  308.  
  309.   /* check if we are root */
  310.  
  311.   if (geteuid()) {
  312.       fprintf(stderr,
  313.         "This program can only be run by root, or it must be setuid root.\n");
  314.       exit(3);
  315.   }
  316.  
  317.   if ((proto = getprotobyname("icmp")) == NULL) 
  318.              crash_and_burn("icmp: unknown protocol");
  319.  
  320.   /* create the socket here as root. Then setuid back to 
  321.         the person running the program. This is so they
  322.         can't open a file that doesn't belong to them! */
  323.  
  324.   s = socket(AF_INET, SOCK_RAW, proto->p_proto);
  325.   if (s<0) errno_crash_and_burn("can't create raw socket");
  326.  
  327.   setuid(getuid());
  328.  
  329.   prog = argv[0];
  330.   ident = getpid() & 0xFFFF;
  331.  
  332.   verbose_flag=1;
  333.  
  334.   opterr=0;
  335.  
  336.   while ((c = getopt(argc,argv,"edhqusavt:i:f:r:")) != EOF) 
  337.      switch (c) {
  338.        case 't': if ( (timeout=atoi(optarg)) <0) usage();  break;
  339.        case 'f': filename= optarg;                         break;
  340.        case 'r': if ((retry=atoi(optarg))<0) usage();      break;
  341.        case 'i': if ((interval=atoi(optarg))<0) usage();   break;
  342.        case 'h': usage();                                  break;
  343.        case 'q': verbose_flag = 0;                           break;
  344.        case 'e': elapsed_flag = 1;                           break;
  345.        case 'd': dns_flag = 1;                             break;
  346.        case 's': stats_flag = 1;                           break;
  347.        case 'u': unreachable_flag = 1;                     break;
  348.        case 'a': alive_flag = 1;                           break;
  349.            case 'v':
  350.                      printf("%s: $Revision: 1.20 $ $Date: 1993/02/23 00:16:38 $\n",argv[0]);
  351.                      printf("%s: comments to schemers@Stanford.EDU\n",argv[0]);
  352.                      exit(0);
  353.            default : fprintf(stderr,"Unknown flag: %s\n",argv[0]); 
  354.                      usage(); break;
  355.      }
  356.  
  357.   if (unreachable_flag && alive_flag) {
  358.     fprintf(stderr,"%s: specify only one of a,u\n",argv[0]);
  359.     usage();
  360.   }
  361.  
  362.   if ( (interval<10 || retry >20 || timeout <250) && getuid()) {
  363.     fprintf(stderr,"%s: these options are too risky for mere mortals.\n",prog);
  364.     fprintf(stderr,"%s: You need i >=10, retry < 20, and t >= 250\n",prog);
  365.     exit(3);
  366.   }
  367.  
  368.   if (alive_flag || unreachable_flag) verbose_flag=0;
  369.  
  370.   argv = &argv[optind];
  371.   if (*argv && filename)   { usage(); }
  372.   if (!*argv && !filename) { filename = "-"; }
  373.  
  374.   if (*argv) while (*argv) {
  375.              add_host(*argv);
  376.              ++argv;
  377.   } else if (filename) {
  378.          FILE *ping_file;
  379.          char line[132];
  380.          char host[132],*p;
  381.          if (strcmp(filename,"-")==0) {
  382.              ping_file=fdopen(0,"r");
  383.          } else {
  384.              ping_file=fopen(filename,"r");
  385.          }
  386.          if (!ping_file) errno_crash_and_burn("fopen");
  387.          while(fgets(line,132,ping_file)) {
  388.            sscanf(line,"%s",host);
  389.               if ((!*host) || (host[0]=='#'))  /* magic to avoid comments */
  390.                 continue;
  391.            p=(char*)malloc(strlen(host)+1);
  392.            if (!p) crash_and_burn("can't malloc host");
  393.            strcpy(p,host);
  394.            add_host(p);
  395.          }
  396.          fclose(ping_file);
  397.   } else usage();
  398.  
  399.   if (!num_hosts) exit(2);
  400.  
  401.   /* allocate array to hold outstanding ping requests */
  402.  
  403.   table = (HOST_ENTRY **) malloc(sizeof(HOST_ENTRY *)*num_hosts);
  404.   if (!table) crash_and_burn("Can't malloc array of hosts");
  405.  
  406.   cursor=rrlist;
  407.  
  408.   for( num_waiting=0; num_waiting < num_hosts; num_waiting++ ) {
  409.       table[num_waiting]=cursor;
  410.       cursor->i = num_waiting;
  411.       cursor=cursor->next;
  412.   }
  413.  
  414.   gettimeofday(&start_time,&tz);
  415.   cursor=rrlist;
  416.   while (num_waiting) {  /* while pings are outstanding */
  417.         if ( (timeval_diff(¤t_time,&cursor->last_time)> timeout) ||
  418.                                                 cursor->num_packets_sent==0)  {
  419.            if (cursor->num_packets_sent>0)  num_timeout++;
  420.             if (cursor->num_packets_sent == retry+1) {
  421.                         if(verbose_flag || unreachable_flag) {
  422.                               if (dns_flag) printf("%s",
  423.                                  get_host_by_address(cursor->saddr.sin_addr));
  424.                               else    printf("%s",cursor->host);
  425.                               if (verbose_flag) printf(" is unreachable");
  426.                               printf("\n");
  427.                        }
  428.                        num_unreachable++;
  429.                        remove_job(cursor); 
  430.            } else send_ping(s,cursor);
  431.      }
  432.       while(wait_for_reply() && num_waiting) {  /* call wfr until we timeout */
  433.                     /* wait! */
  434.       }
  435.       gettimeofday(¤t_time,&tz);
  436.       if (cursor) cursor = cursor->next;
  437.   }  
  438.  
  439.   gettimeofday(&end_time,&tz);
  440.  
  441.   if (stats_flag) {
  442.      fflush(stdout);
  443.      fprintf(stderr,"\n");
  444.      fprintf(stderr," %8d hosts\n",num_hosts);
  445.      fprintf(stderr," %8d alive\n",num_alive);
  446.      fprintf(stderr," %8d unreachable\n",num_unreachable);
  447.      fprintf(stderr," %8d unknown addresses\n",num_noaddress);
  448.      fprintf(stderr,"\n");
  449.      fprintf(stderr," %8d timeouts (waiting for response)\n",num_timeout);
  450.      fprintf(stderr," %8d pings sent\n",num_pingsent);
  451.      fprintf(stderr," %8d pings received\n",num_pingreceived);
  452.      fprintf(stderr,"\n");
  453.  
  454. if (total_replies==0) {
  455.           min_reply=0; max_reply=0; total_replies=1; sum_replies=0;
  456. }
  457.  
  458.      fprintf(stderr," %8d msec (min round trip time)\n",min_reply);
  459.      fprintf(stderr," %8d msec (avg round trip time)\n",(int)sum_replies/total_replies);
  460.      fprintf(stderr," %8d msec (max round trip time)\n",max_reply);
  461.      fprintf(stderr," %8.3f sec (elapsed real time)\n",
  462.          timeval_diff( &end_time,&start_time)/1000.0);
  463.      fprintf(stderr,"\n");
  464.  
  465.   }
  466.  
  467.   if (num_noaddress) exit(2);
  468.   else if (num_alive != num_hosts) exit(1); 
  469.   
  470.   exit(0);
  471.  
  472. }
  473.  
  474.  
  475. /*
  476.  * 
  477.  * Compose and transmit an ICMP_ECHO REQUEST packet.  The IP packet
  478.  * will be added on by the kernel.  The ID field is our UNIX process ID,
  479.  * and the sequence number is an index into an array of outstanding
  480.  * ping requests. The sequence number will later be used to quickly
  481.  * figure out who the ping reply came from.
  482.  *
  483.  */
  484.  
  485. #ifdef _NO_PROTO
  486. void send_ping(s,h)
  487. int s; HOST_ENTRY *h;
  488. #else
  489. void send_ping(int s,HOST_ENTRY *h)
  490. #endif
  491. {
  492.   static char buffer[32];
  493.   struct icmp *icp = (struct icmp *) buffer;
  494.   int n,len;
  495.  
  496.   gettimeofday(&h->last_time,&tz);
  497.  
  498.   icp->icmp_type = ICMP_ECHO;
  499.   icp->icmp_code = 0;
  500.   icp->icmp_cksum = 0;
  501.   icp->icmp_seq = h->i;
  502.   icp->icmp_id = ident;
  503. #define SIZE_ICMP_HDR 8
  504. #define SIZE_PACK_SENT (sizeof(h->num_packets_sent))
  505. #define SIZE_LAST_TIME (sizeof(h->last_time))
  506.  
  507.   bcopy(&h->last_time,&buffer[SIZE_ICMP_HDR],SIZE_LAST_TIME);
  508.   bcopy(&h->num_packets_sent,
  509.              &buffer[SIZE_ICMP_HDR+SIZE_LAST_TIME], SIZE_PACK_SENT);
  510.  
  511.   len = SIZE_ICMP_HDR+SIZE_LAST_TIME+SIZE_PACK_SENT;
  512.  
  513.   icp->icmp_cksum = in_cksum( (u_short *)icp, len );
  514.  
  515.   n = sendto( s, buffer, len, 0, (struct sockaddr *)&h->saddr, 
  516.                                                sizeof(struct sockaddr_in) );
  517.   if( n < 0 || n != len ) {
  518.       if (verbose_flag || unreachable_flag) {
  519.         if (dns_flag) printf("%s",get_host_by_address(h->saddr.sin_addr));
  520.          else printf("%s",cursor->host);
  521.          if (verbose_flag) printf(" error while sending ping: %s\n",
  522.                                sys_errlist[errno]);
  523.          printf("\n");
  524.       }
  525.       num_unreachable++;
  526.       remove_job(h); 
  527.   } else {
  528.        h->num_packets_sent++;
  529.        num_pingsent++;
  530.   }
  531.  
  532. }
  533.  
  534. #ifdef _NO_PROTO
  535. int wait_for_reply()
  536. #else
  537. int wait_for_reply()
  538. #endif
  539. {
  540. int result;
  541. static char buffer[4096];
  542. struct sockaddr_in response_addr;
  543. struct ip *ip;
  544. int hlen;
  545. struct icmp *icp;
  546. int n;
  547. HOST_ENTRY *h;
  548.  
  549. long this_reply;
  550. int the_index;
  551. struct timeval sent_time;
  552.  
  553.  
  554.  result=recvfrom_wto(s,buffer,4096,
  555.                      (struct sockaddr *)&response_addr,interval);
  556.  
  557.   if (result<0) { return 0; } /* timeout */
  558.   
  559.   ip = (struct ip *) buffer;
  560.   hlen = ip->ip_hl << 2;
  561.   if (result < hlen+ICMP_MINLEN) { return(1); /* too short */ }
  562.  
  563.   icp = (struct icmp *)(buffer + hlen);
  564.  
  565.   if ( 
  566.        ( icp->icmp_type != ICMP_ECHOREPLY ) ||   
  567.        ( icp->icmp_id   != ident          ) 
  568.   ) {
  569.        return 1; /* packet received, but not the one we are looking for! */
  570.   }
  571.  
  572.       num_pingreceived++;
  573.  
  574.   if ( ( icp->icmp_seq  >= num_hosts    ) ||
  575.        ( !table[icp->icmp_seq]          ) ||
  576.        ( table[icp->icmp_seq]->saddr.sin_addr.s_addr 
  577.                                 != response_addr.sin_addr.s_addr)) { 
  578.        return 1; /* packet received, don't about it anymore */
  579.   }
  580.  
  581.     n=icp->icmp_seq;
  582.     h=table[n];
  583.  
  584.     gettimeofday(¤t_time,&tz);
  585.     bcopy(&icp->icmp_data[0],&sent_time,sizeof(sent_time));
  586.     bcopy(&icp->icmp_data[SIZE_LAST_TIME],&the_index,  sizeof(the_index));
  587.     this_reply = timeval_diff(¤t_time,&sent_time);
  588.     if (this_reply>max_reply) max_reply=this_reply;
  589.     if (this_reply<min_reply) min_reply=this_reply;
  590.     sum_replies += this_reply;
  591.     total_replies++;
  592.  
  593.     if(verbose_flag||alive_flag) {
  594.        if (dns_flag) printf("%s",get_host_by_address(response_addr.sin_addr));
  595.        else printf("%s",h->host);
  596.        if (verbose_flag) printf(" is alive");
  597.        if (elapsed_flag) printf(" (%d msec)",this_reply);
  598.        printf("\n");
  599.     }
  600.     num_alive++;
  601.     remove_job(h); /* remove job */
  602.     return num_waiting;
  603. }
  604.  
  605. /*
  606.  * Checksum routine for Internet Protocol family headers (C Version)
  607.  * From ping examples in W.Richard Stevens "UNIX NETWORK PROGRAMMING" book.
  608.  */
  609.  
  610. #ifdef _NO_PROTO
  611. int in_cksum(p,n)
  612. u_short *p; int n;
  613. #else
  614. int in_cksum(u_short *p, int n)
  615. #endif
  616. {
  617.   register u_short answer;
  618.   register long sum = 0;
  619.   u_short odd_byte = 0;
  620.  
  621.   while( n > 1 )  { sum += *p++; n -= 2; }
  622.  
  623.   /* mop up an odd byte, if necessary */
  624.   if( n == 1 ) {
  625.       *(u_char *)(&odd_byte) = *(u_char *)p;
  626.       sum += odd_byte;
  627.   }
  628.  
  629.   sum = (sum >> 16) + (sum & 0xffff);    /* add hi 16 to low 16 */
  630.   sum += (sum >> 16);            /* add carry */
  631.   answer = ~sum;            /* ones-complement, truncate*/
  632.   return (answer);
  633. }
  634.  
  635.  
  636. /* add host to linked list of hosts to be pinged */
  637. /* assume memory for *host is ours!!!            */
  638.  
  639. #ifdef _NO_PROTO
  640. void add_host(host)
  641. char *host;
  642. #else
  643. void add_host(char *host)
  644. #endif
  645. {
  646.   HOST_ENTRY *p;
  647.   struct hostent *host_ent;
  648.   struct in_addr *host_add;
  649.  
  650.   u_long ipaddress = inet_addr(host);
  651.  
  652.   if ( (ipaddress == -1) &&
  653.        ( ((host_ent=gethostbyname(host)) == 0) ||
  654.           ((host_add = (struct in_addr *) *(host_ent->h_addr_list))==0))
  655.      )  {
  656.           if (verbose_flag) fprintf(stderr,"%s address not found\n",host);
  657.           num_noaddress++;
  658.           return;
  659.        }
  660.  
  661.   p = (HOST_ENTRY *) malloc(sizeof(HOST_ENTRY));
  662.   if (!p) crash_and_burn("can't allocate HOST_ENTRY");
  663.  
  664.   p->host=host;
  665.   p->num_packets_sent = 0;
  666.   p->last_time.tv_sec =0;
  667.   p->last_time.tv_usec =0;
  668.  
  669.   bzero((char*) &p->saddr, sizeof(p->saddr));
  670.   p->saddr.sin_family      = AF_INET;
  671.  
  672.   if (ipaddress==-1) p->saddr.sin_addr = *host_add; 
  673.   else p->saddr.sin_addr.s_addr = ipaddress;
  674.  
  675.   if (!rrlist) {
  676.       rrlist = p;
  677.       p->next = p;
  678.       p->prev = p;
  679.   } else {
  680.       p->next = rrlist;
  681.       p->prev = rrlist->prev;
  682.       p->prev->next = p;
  683.       p->next->prev = p;
  684.       rrlist = p;
  685.   }
  686.   num_hosts++;
  687. }
  688.  
  689. #ifdef _NO_PROTO
  690. void remove_job(h)
  691. HOST_ENTRY *h;
  692. #else
  693. void remove_job(HOST_ENTRY *h)
  694. #endif
  695. {
  696.  
  697.   table[h->i]=NULL;
  698.   --num_waiting;
  699.  
  700.   if (num_waiting) {                    /* remove us from list of jobs */
  701.        h->prev->next = h->next;
  702.        h->next->prev = h->prev;
  703.        if (h==cursor) { cursor = h-> next; }
  704.   } else {     
  705.        cursor=NULL;
  706.        rrlist=NULL;
  707.   }
  708.  
  709. }
  710.  
  711. #ifdef _NO_PROTO
  712. char *get_host_by_address(in)
  713. struct in_addr in;
  714. #else
  715. char *get_host_by_address(struct in_addr in)
  716. #endif
  717. {
  718.   struct hostent *h;
  719.    h=gethostbyaddr((char *) &in,sizeof(struct in_addr),AF_INET);
  720.    if (h==NULL || h->h_name==NULL) return inet_ntoa(in);
  721.    else return h->h_name;
  722. }
  723.  
  724.  
  725. #ifdef _NO_PROTO
  726. void crash_and_burn(message)
  727. char *message;
  728. #else
  729. void crash_and_burn(char *message)
  730. #endif
  731. {
  732.   if (verbose_flag) fprintf(stderr,"%s: %s\n",prog,message);
  733.   exit(4);
  734. }
  735.  
  736. #ifdef _NO_PROTO
  737. void errno_crash_and_burn(message)
  738. char *message;
  739. #else
  740. void errno_crash_and_burn(char *message)
  741. #endif
  742. {
  743.   if (verbose_flag)
  744.         fprintf(stderr,"%s: %s : %s\n",prog,message,sys_errlist[errno]);
  745.   exit(4);
  746. }
  747.  
  748. #ifdef _NO_PROTO
  749. long timeval_diff(a,b)
  750. struct timeval *a,*b;
  751. #else
  752. long timeval_diff(struct timeval *a,struct timeval *b)
  753. #endif
  754. {
  755. double temp;
  756.  
  757. temp = 
  758.   (((a->tv_sec*1000000)+ a->tv_usec) - 
  759.      ((b->tv_sec*1000000)+ b->tv_usec))/1000;
  760.  
  761. return (long) temp;
  762.  
  763. }
  764.  
  765. /*
  766.  * recvfrom_wto: receive with timeout
  767.  *      returns length of data read or -1 if timeout
  768.  *      crash_and_burn on any other errrors
  769.  *
  770.  */
  771.  
  772.  
  773. #ifdef _NO_PROTO
  774. int recvfrom_wto (s,buf,len, saddr, timo)
  775. int s; char *buf; int len; struct sockaddr *saddr; int timo;
  776. #else
  777. int recvfrom_wto (int s, char *buf, int len, struct sockaddr *saddr, int timo)
  778. #endif
  779. {
  780.   int nfound,slen,n;
  781.   struct timeval to;
  782.   fd_set readset,writeset;
  783.  
  784.   to.tv_sec  = timo/1000;
  785.   to.tv_usec = (timo - (to.tv_sec*1000))*1000;
  786.  
  787.   FD_ZERO(&readset);
  788.   FD_ZERO(&writeset);
  789.   FD_SET(s,&readset);
  790.   nfound = select(s+1,&readset,&writeset,NULL,&to);
  791.   if (nfound<0) errno_crash_and_burn("select");
  792.   if (nfound==0) return -1;  /* timeout */
  793.   slen=sizeof(struct sockaddr);
  794.   n=recvfrom(s,buf,len,0,saddr,&slen);
  795.   if (n<0) errno_crash_and_burn("recvfrom");
  796.   return n;
  797. }
  798.  
  799. #ifdef _NO_PROTO
  800. void usage()
  801. #else
  802. void usage()
  803. #endif
  804. {
  805.   fprintf(stderr,"\n");
  806.   fprintf(stderr,"Usage: %s [options] [systems...]\n",prog);
  807.   fprintf(stderr,"   -a         show systems that are alive\n");
  808.   fprintf(stderr,"   -d         use dns to lookup address for return ping packet\n");
  809.   fprintf(stderr,"   -e         show elapsed time on return packets\n");
  810.   fprintf(stderr,"   -f file    read list of systems from a file ( - means stdin)\n");
  811.   fprintf(stderr,"   -i n       interval (between ping packets) in milliseconds (default %d)\n",interval);
  812.   fprintf(stderr,"   -q         quiet (don't show per host results)\n");
  813.   fprintf(stderr,"   -r n       retry limit (default %d)\n",retry);
  814.   fprintf(stderr,"   -s         dump final stats\n");
  815.   fprintf(stderr,"   -t n       individual host timeout in milliseconds (default %d)\n",timeout);
  816.   fprintf(stderr,"   -u         show systems that are unreachable\n");
  817.   fprintf(stderr,"   -v         show version\n");
  818.   fprintf(stderr,"   systems    list of systems to check (if no -f specified)\n");
  819.   fprintf(stderr,"\n");
  820.   exit(3);
  821. }
  822.