path: root/plugins/check_icmp.c

/*
 * check_icmp - A hack of fping2 to work with nagios.
 *              This way we don't have to use the output parser.
 *
 * VIEWING NOTES:
 * This file was formatted with tab indents at a tab stop of 4.
 *
 * It is highly recommended that your editor is set to this
 * tab stop setting for viewing and editing.
 *
 * COPYLEFT;
 * This programs copyright status is currently undetermined. Much of
 * the code in it comes from the fping2 program which used to be licensed
 * under the Stanford General Software License (available at
 * http://graphics.stanford.edu/software/license.html). It is presently
 * unclear what license (if any) applies to the original code at the
 * moment.
 *
 * The fping website can be found at http://www.fping.com
 */

#include <stdio.h>
#include <errno.h>
#include <time.h>
#include <signal.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>
#include <stddef.h>

#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>

#include <sys/file.h>

#include <netinet/in_systm.h>
#include <netinet/in.h>

/* Linux has bizarre ip.h and ip_icmp.h */
/* Taken from the fping distro. Thank you. */
#if defined( __linux__ )
#include "linux.h"
#else
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#endif /* defined(__linux__) */

#include <arpa/inet.h>
#include <netdb.h>

/* RS6000 has sys/select.h */
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif							/* HAVE_SYS_SELECT_H */

/* rta threshold values can't be larger than MAXTTL seconds */
#ifndef MAXTTL
#  define MAXTTL	255
#endif
#ifndef IPDEFTTL
#  define IPDEFTTL	64
#endif

/*** externals ***/
extern char *optarg;
extern int optind, opterr;

/*** Constants ***/
#define REV_DATE	"2004-09-06"
#define EMAIL		"ae@op5.se"
#define VERSION		"0.8"

#ifndef INADDR_NONE
# define INADDR_NONE 0xffffffU
#endif

/*** Ping packet defines ***/
/* data added after ICMP header for our nefarious purposes */
typedef struct ping_data {
	unsigned int ping_count;	/* counts up to -[n|p] count or 1 */
	struct timeval ping_ts;		/* time sent */
} PING_DATA;

#define MIN_PING_DATA	sizeof(PING_DATA)
#define	MAX_IP_PACKET	65536	/* (theoretical) max IP packet size */
#define SIZE_IP_HDR		20
#define SIZE_ICMP_HDR	ICMP_MINLEN	/* from ip_icmp.h */
#define MAX_PING_DATA	(MAX_IP_PACKET - SIZE_IP_HDR - SIZE_ICMP_HDR)

/*
 *  Interval is the minimum amount of time between sending a ping packet to
 *  any host.
 *
 *  Perhost_interval is the minimum amount of time between sending a ping
 *  packet to a particular responding host
 *
 *  Timeout  is the initial amount of time between sending a ping packet to
 *  a particular non-responding host.
 *
 *  Retry is the number of ping packets to send to a non-responding host
 *  before giving up (in is-it-alive mode).
 *
 *  Backoff factor is how much longer to wait on successive retries.
 */
#ifndef DEFAULT_INTERVAL
#define DEFAULT_INTERVAL 25		/* default time between packets (msec) */
#endif

#ifndef DEFAULT_RETRY
#define DEFAULT_RETRY	1			/* number of times to retry a host */
#endif

#ifndef DEFAULT_TIMEOUT
# define DEFAULT_TIMEOUT 1000
#endif

#ifndef DEFAULT_BACKOFF_FACTOR
#define DEFAULT_BACKOFF_FACTOR 1.5	/* exponential timeout factor */
#endif
#define MIN_BACKOFF_FACTOR     1.0	/* exponential timeout factor */
#define MAX_BACKOFF_FACTOR     5.0	/* exponential timeout factor */

#ifndef DNS_TIMEOUT
#define DNS_TIMEOUT 1000		/* time in usec for dns retry */
#endif

#ifndef MAX_RTA_THRESHOLD_VALUE
# define MAX_RTA_THRESHOLD_VALUE 120*1000000 /* 2 minutes should be enough */
#endif
#ifndef MIN_RTA_THRESHOLD_VALUE
# define MIN_RTA_THRESHOLD_VALUE 10000	/* minimum RTA threshold value */
#endif

/* sized so as to be like traditional ping */
#define DEFAULT_PING_DATA_SIZE	(MIN_PING_DATA + 44)

/* maxima and minima */
#define MAX_COUNT				50		/* max count even if we're root */
#define MAX_RETRY				5
#define MIN_INTERVAL			25	/* msecs */
#define MIN_TIMEOUT				50	/* msecs */

/* response time array flags */
#define RESP_WAITING	-1
#define RESP_UNUSED		-2

#define	ICMP_UNREACH_MAXTYPE	15

/* entry used to keep track of each host we are pinging */
struct host_entry {
	int i;						/* index into array */
	char *name;					/* name as given by user */
	char *host;					/* text description of host */
	struct sockaddr_in saddr;	/* internet address */
	unsigned short **pr;		/* TCP port range to check for connectivity */
	struct timeval last_send_time;	/* time of last packet sent */
	unsigned int num_sent;		/* number of ping packets sent */
	unsigned int num_recv;		/* number of pings received */
	unsigned int total_time;	/* sum of response times */
	unsigned int status;		/* this hosts status */
	unsigned int running;		/* unset when through sending */
	unsigned int waiting;		/* waiting for response */
	int *resp_times;	/* individual response times */
	struct host_entry *prev, *next;	/* doubly linked list */
};

typedef struct host_entry HOST_ENTRY;

struct host_name_list {
	char *entry;
	struct host_name_list *next;
};

/* threshold structure */
struct threshold {
	unsigned int pl;	/* packet loss */
	unsigned int rta;	/* roundtrip time average */
};
typedef struct threshold threshold;

/*****************************************************************************
 *                             Global Variables                              *
 *****************************************************************************/

HOST_ENTRY *rrlist = NULL;		/* linked list of hosts be pinged */
HOST_ENTRY **table = NULL;		/* array of pointers to items in the list */
HOST_ENTRY *cursor;

char *prog;						/* our name */
int ident;						/* our pid, for marking icmp packets */
int sock;						/* socket */
u_int debug = 0;

/* threshold value defaults;
 * WARNING;  60% packetloss or 200 msecs round trip average
 * CRITICAL; 80% packetloss or 500 msecs round trip average */
threshold warn = {60, 200 * 1000};
threshold crit = {80, 500 * 1000};

/* times get *100 because all times are calculated in 10 usec units, not ms */
unsigned int retry = DEFAULT_RETRY;
u_int timeout = DEFAULT_TIMEOUT * 100;
u_int interval = DEFAULT_INTERVAL * 100;
float backoff = DEFAULT_BACKOFF_FACTOR;
u_int select_time;	/* calculated using maximum threshold rta value */
u_int ping_data_size = DEFAULT_PING_DATA_SIZE;
u_int ping_pkt_size;
unsigned int count = 5;
unsigned int trials = 1;

/* global stats */
int total_replies = 0;
int num_jobs = 0;				/* number of hosts still to do */
int num_hosts = 0;				/* total number of hosts */
int num_alive = 0;				/* total number alive */
int num_unreachable = 0;		/* total number unreachable */
int num_noaddress = 0;			/* total number of addresses not found */
int num_timeout = 0;			/* number of timed out packets */
int num_pingsent = 0;			/* total pings sent */
int num_pingreceived = 0;		/* total pings received */
int num_othericmprcvd = 0;		/* total non-echo-reply ICMP received */

struct timeval current_time;	/* current time (pseudo) */
struct timeval start_time;
struct timeval end_time;
struct timeval last_send_time;	/* time last ping was sent */
struct timezone tz;

/* switches */
int generate_flag = 0;			/* flag for IP list generation */
int stats_flag, unreachable_flag, alive_flag;
int elapsed_flag, version_flag, count_flag;
int name_flag, addr_flag, backoff_flag;
int multif_flag;

/*** prototypes ***/
void add_name(char *);
void add_addr(char *, char *, struct in_addr);
char *na_cat(char *, struct in_addr);
char *cpystr(char *);
void crash(char *);
char *get_host_by_address(struct in_addr);
int in_cksum(u_short *, int);
void u_sleep(int);
int recvfrom_wto(int, char *, int, struct sockaddr *, int);
void remove_job(HOST_ENTRY *);
void send_ping(int, HOST_ENTRY *);
long timeval_diff(struct timeval *, struct timeval *);
void usage(void);
int wait_for_reply(int);
void finish(void);
int handle_random_icmp(struct icmp *, struct sockaddr_in *);
char *sprint_tm(int);
int get_threshold(char *, threshold *);

/*** the various exit-states */
enum {
	STATE_OK = 0,
	STATE_WARNING,
	STATE_CRITICAL,
	STATE_UNKNOWN,
	STATE_DEPENDANT,
	STATE_OOB
};
/* the strings that correspond to them */
char *status_string[STATE_OOB] = {
	"OK",
	"WARNING",
	"CRITICAL",
	"UNKNOWN",
	"DEPENDANT"
};

int status = STATE_OK;
int fin_stat = STATE_OK;

/*****************************************************************************
 *                           Code block start                                *
 *****************************************************************************/
int main(int argc, char **argv)
{
	int c;
	u_int lt, ht;
	int advance;
	struct protoent *proto;
	uid_t uid;
	struct host_name_list *host_ptr, *host_base_ptr;

	if(strchr(argv[0], '/')) prog = strrchr(argv[0], '/') + 1;
	else prog = argv[0];

	/* check if we are root */
	if(geteuid()) {
		printf("Root access needed (for raw sockets)\n");
		exit(STATE_UNKNOWN);
	}

	/* confirm that ICMP is available on this machine */
	if((proto = getprotobyname("icmp")) == NULL)
		crash("icmp: unknown protocol");

	/* create raw socket for ICMP calls (ping) */
	sock = socket(AF_INET, SOCK_RAW, proto->p_proto);

	if(sock < 0)
		crash("can't create raw socket");

	/* drop privileges now that we have the socket */
	if((uid = getuid())) {
		seteuid(uid);
	}
	
	if(argc < 2) usage();

	ident = getpid() & 0xFFFF;

	if(!(host_base_ptr = malloc(sizeof(struct host_name_list)))) {
		crash("Unable to allocate memory for host name list\n");
	}
	host_ptr = host_base_ptr;

	backoff_flag = 0;
	opterr = 1;

	/* get command line options
	 * -H denotes a host (actually ignored and picked up later)
	 * -h for help
	 * -V or -v for version
	 * -d to display hostnames rather than addresses
	 * -t sets timeout for packets and tcp connects
	 * -r defines retries (persistence)
	 * -p or -n sets packet count (5)
	 * -b sets packet size (56)
	 * -w sets warning threshhold (200,40%)
	 * -c sets critical threshhold (500,80%)
	 * -i sets interval for both packet transmissions and connect attempts
	 */
#define OPT_STR "amH:hvVDdAp:n:b:r:t:i:w:c:"
	while((c = getopt(argc, argv, OPT_STR)) != EOF) {
		switch (c) {
			case 'H':
				if(!(host_ptr->entry = malloc(strlen(optarg) + 1))) {
					crash("Failed to allocate memory for hostname");
				}
				memset(host_ptr->entry, 0, strlen(optarg) + 1);
				host_ptr->entry = memcpy(host_ptr->entry, optarg, strlen(optarg));
				if(!(host_ptr->next = malloc(sizeof(struct host_name_list))))
					crash("Failed to allocate memory for hostname");
				host_ptr = host_ptr->next;
				host_ptr->next = NULL;
//				add_name(optarg);
				break;
				/* this is recognized, but silently ignored.
				 * host(s) are added later on */

				break;
			case 'w':
				if(get_threshold(optarg, &warn)) {
					printf("Illegal threshold pair specified for -%c", c);
					usage();
				}
				break;

			case 'c':
				if(get_threshold(optarg, &crit)) {
					printf("Illegal threshold pair specified for -%c", c);
					usage();
				}
				break;

			case 't':
				if(!(timeout = (u_int) strtoul(optarg, NULL, 0) * 100)) {
					printf("option -%c requires integer argument\n", c);
					usage();
				}
				break;

			case 'r':
				if(!(retry = (u_int) strtoul(optarg, NULL, 0))) {
					printf("option -%c requires integer argument\n", c);
					usage();
				}
				break;

			case 'i':
				if(!(interval = (u_int) strtoul(optarg, NULL, 0) * 100)) {
					printf("option -%c requires positive non-zero integer argument\n", c);
					usage();
				}
				break;

			case 'p':
			case 'n':
				if(!(count = (u_int) strtoul(optarg, NULL, 0))) {
					printf("option -%c requires positive non-zero integer argument\n", c);
					usage();
				}
				break;

			case 'b':
				if(!(ping_data_size = (u_int) strtoul(optarg, NULL, 0))) {
					printf("option -%c requires integer argument\n", c);
					usage();
				}
				break;

			case 'h':
				usage();
				break;

			case 'e':
				elapsed_flag = 1;
				break;
				
			case 'm':
				multif_flag = 1;
				break;
				
			case 'd':
				name_flag = 1;
				break;

			case 'A':
				addr_flag = 1;
				break;
				
			case 's':
				stats_flag = 1;
				break;

			case 'u':
				unreachable_flag = 1;
				break;

			case 'a':
				alive_flag = 1;
				break;

			case 'v':
				printf("%s: Version %s $Date$\n", prog, VERSION, REV_DATE);
				printf("%s: comments to %s\n", prog, EMAIL);
				exit(STATE_OK);

			case 'g':
				/* use IP list generation */
				/* mutex with file input or command line targets */
				generate_flag = 1;
				break;

			default:
				printf("option flag -%c specified, but not recognized\n", c);
				usage();
				break;
		}
	}

	/* arguments are parsed, so now we validate them */

	if(count > 1) count_flag = 1;

	/* set threshold values to 10usec units (inherited from fping.c) */
	crit.rta = crit.rta / 10;
	warn.rta = warn.rta / 10;
	select_time = crit.rta;
	/* this isn't critical, but will most likely not be what the user expects
	 * so we tell him/her about it, but keep running anyways */
	if(warn.pl > crit.pl || warn.rta > crit.rta) {
		select_time = warn.rta;
		printf("(WARNING threshold > CRITICAL threshold) :: ");
		fflush(stdout);
	}

	/* A timeout smaller than maximum rta threshold makes no sense */
	if(timeout < crit.rta) timeout = crit.rta;
	else if(timeout < warn.rta) timeout = warn.rta;

	if((interval < MIN_INTERVAL * 100 || retry > MAX_RETRY) && getuid()) {
		printf("%s: these options are too risky for mere mortals.\n", prog);
		printf("%s: You need i >= %u and r < %u\n",
				prog, MIN_INTERVAL, MAX_RETRY);
		printf("Current settings; i = %d, r = %d\n",
			   interval / 100, retry);
		usage();
	}

	if((ping_data_size > MAX_PING_DATA) || (ping_data_size < MIN_PING_DATA)) {
		printf("%s: data size %u not valid, must be between %u and %u\n",
				prog, ping_data_size, MIN_PING_DATA, MAX_PING_DATA);
		usage();

	}

	if((backoff > MAX_BACKOFF_FACTOR) || (backoff < MIN_BACKOFF_FACTOR)) {
		printf("%s: backoff factor %.1f not valid, must be between %.1f and %.1f\n",
				prog, backoff, MIN_BACKOFF_FACTOR, MAX_BACKOFF_FACTOR);
		usage();

	}

	if(count > MAX_COUNT) {
		printf("%s: count %u not valid, must be less than %u\n",
				prog, count, MAX_COUNT);
		usage();
	}

	if(count_flag) {
		alive_flag = unreachable_flag = 0;
	}

	trials = (count > retry + 1) ? count : retry + 1;

	/* handle host names supplied on command line or in a file */
	/* if the generate_flag is on, then generate the IP list */
	argv = &argv[optind];

	/* cover allowable conditions */

	/* generate requires command line parameters beyond the switches */
	if(generate_flag && !*argv) {
		printf("generate flag requires command line parameters beyond switches\n");
		usage();
	}

	if(*argv && !generate_flag) {
		while(*argv) {
			if(!(host_ptr->entry = malloc(strlen(*argv) + 1))) {
				crash("Failed to allocate memory for hostname");
			}
			memset(host_ptr->entry, 0, strlen(*argv) + 1);
			host_ptr->entry = memcpy(host_ptr->entry, *argv, strlen(*argv));
			if(!(host_ptr->next = malloc(sizeof(struct host_name_list))))
				crash("Failed to allocate memory for hostname");
			host_ptr = host_ptr->next;
			host_ptr->next = NULL;

//			add_name(*argv);
			argv++;
		}
	}

	// now add all the hosts
	host_ptr = host_base_ptr;
	while(host_ptr->next) {
		add_name(host_ptr->entry);
		host_ptr = host_ptr->next;
	}

	if(!num_hosts) {
		printf("No hosts to work with!\n\n");
		usage();
	}

	/* allocate array to hold outstanding ping requests */
	table = (HOST_ENTRY **) malloc(sizeof(HOST_ENTRY *) * num_hosts);
	if(!table) crash("Can't malloc array of hosts");

	cursor = rrlist;

	for(num_jobs = 0; num_jobs < num_hosts; num_jobs++) {
		table[num_jobs] = cursor;
		cursor->i = num_jobs;

		cursor = cursor->next;
	}							/* FOR */

	ping_pkt_size = ping_data_size + SIZE_ICMP_HDR;

	signal(SIGINT, (void *)finish);

	gettimeofday(&start_time, &tz);
	current_time = start_time;

	last_send_time.tv_sec = current_time.tv_sec - 10000;

	cursor = rrlist;
	advance = 0;

	/* main loop */
	while(num_jobs) {
		/* fetch all packets that receive within time boundaries */
		while(num_pingsent &&
			  cursor &&
			  cursor->num_sent > cursor->num_recv &&
			  wait_for_reply(sock)) ;

		if(cursor && advance) {
			cursor = cursor->next;
		}

		gettimeofday(&current_time, &tz);
		lt = timeval_diff(&current_time, &last_send_time);
		ht = timeval_diff(&current_time, &cursor->last_send_time);

		advance = 1;

		/* if it's OK to send while counting or looping or starting */
		if(lt > interval) {
			/* send if starting or looping */
			if((cursor->num_sent == 0)) {
				send_ping(sock, cursor);
				continue;
			}					/* IF */

			/* send if counting and count not exceeded */
			if(count_flag) {
				if(cursor->num_sent < count) {
					send_ping(sock, cursor);
					continue;
				}				/* IF */
			}					/* IF */
		}						/* IF */

		/* is-it-alive mode, and timeout exceeded while waiting for a reply */
		/*   and we haven't exceeded our retries                            */
		if((lt > interval) && !count_flag && !cursor->num_recv &&
		   (ht > timeout) && (cursor->waiting < retry + 1)) {
			num_timeout++;

			/* try again */
			send_ping(sock, cursor);
			continue;
		}						/* IF */

		/* didn't send, can we remove? */

		/* remove if counting and count exceeded */
		if(count_flag) {
			if((cursor->num_sent >= count)) {
				remove_job(cursor);
				continue;
			}					/* IF */
		}						/* IF */
		else {
			/* normal mode, and we got one */
			if(cursor->num_recv) {
				remove_job(cursor);
				continue;
			}					/* IF */

			/* normal mode, and timeout exceeded while waiting for a reply */
			/* and we've run out of retries, so node is unreachable */
			if((ht > timeout) && (cursor->waiting >= retry + 1)) {
				num_timeout++;
				remove_job(cursor);
				continue;

			}					/* IF */
		}						/* ELSE */

		/* could send to this host, so keep considering it */
		if(ht > interval) {
			advance = 0;
		}
	}							/* WHILE */

	finish();
	return 0;
}								/* main() */

/************************************************************
 * Description:
 *
 * Main program clean up and exit point
 ************************************************************/
void finish()
{
	int i;
	HOST_ENTRY *h;

	gettimeofday(&end_time, &tz);

	/* tot up unreachables */
	for(i=0; i<num_hosts; i++) {
		h = table[i];

		if(!h->num_recv) {
			num_unreachable++;
			status = fin_stat = STATE_CRITICAL;
			if(num_hosts == 1) {
				printf("CRITICAL - %s is down (lost 100%%)|"
					   "rta=;%d;%d;; pl=100%%;%d;%d;;\n",
					   h->host,
					   warn.rta / 100, crit.rta / 100,
					   warn.pl, crit.pl);
			}
			else {
				printf("%s is down (lost 100%%)", h->host);
			}
		}
		else {
			/* reset the status */
			status = STATE_OK;

			/* check for warning before critical, for debugging purposes */
			if(warn.rta <= h->total_time / h->num_recv) {
/*				printf("warn.rta exceeded\n");
*/				status = STATE_WARNING;
			}
			if(warn.pl <= ((h->num_sent - h->num_recv) * 100) / h->num_sent) {
/*				printf("warn.pl exceeded (pl=%d)\n",
					   ((h->num_sent - h->num_recv) * 100) / h->num_sent);
*/				status = STATE_WARNING;
			}
			if(crit.rta <= h->total_time / h->num_recv) {
/*				printf("crit.rta exceeded\n");
*/				status = STATE_CRITICAL;
			}
			if(crit.pl <= ((h->num_sent - h->num_recv) * 100) / h->num_sent) {
/*				printf("crit.pl exceeded (pl=%d)\n",
					   ((h->num_sent - h->num_recv) * 100) / h->num_sent);
*/				status = STATE_CRITICAL;
			}

			if(num_hosts == 1 || status != STATE_OK) {
				printf("%s - %s: rta %s ms, lost %d%%",
					   status_string[status], h->host,
					   sprint_tm(h->total_time / h->num_recv),
					   h->num_sent > 0 ? ((h->num_sent - h->num_recv) * 100) / h->num_sent : 0
					   );
				/* perfdata only available for single-host stuff */
				if(num_hosts == 1) {
					printf("|rta=%sms;%d;%d;; pl=%d%%;%d;%d;;\n",
						   sprint_tm(h->total_time / h->num_recv), warn.rta / 100, crit.rta / 100,
						   h->num_sent > 0 ? ((h->num_sent - h->num_recv) * 100) / h->num_sent : 0, warn.pl, crit.pl
						   );
				}
				else printf(" :: ");
			}

			/* fin_stat should always hold the WORST state */
			if(fin_stat != STATE_CRITICAL && status != STATE_OK) {
				fin_stat = status;
			}
		}
	}

	if(num_noaddress) {
		printf("No hostaddress specified.\n");
		usage();
	}
	else if(num_alive != num_hosts) {
		/* for future multi-check support */
		/*printf("num_alive != num_hosts (%d : %d)\n", num_alive, num_hosts);*/
		fin_stat = STATE_CRITICAL;
	}

	if(num_hosts > 1) {
		if(num_alive == num_hosts) {
			printf("OK - All %d hosts are alive\n", num_hosts);
		}
		else {
			printf("CRITICAL - %d of %d hosts are alive\n", num_alive, num_hosts);
		}
	}
	exit(fin_stat);
}


void send_ping(int lsock, HOST_ENTRY *h)
{
	char *buffer;
	struct icmp *icp;
	PING_DATA *pdp;
	int n;

	buffer = (char *)malloc((size_t) ping_pkt_size);
	if(!buffer)
		crash("can't malloc ping packet");

	memset(buffer, 0, ping_pkt_size * sizeof(char));
	icp = (struct icmp *)buffer;

	gettimeofday(&h->last_send_time, &tz);

	icp->icmp_type = ICMP_ECHO;
	icp->icmp_code = 0;
	icp->icmp_cksum = 0;
	icp->icmp_seq = h->i;
	icp->icmp_id = ident;

	pdp = (PING_DATA *) (buffer + SIZE_ICMP_HDR);
	pdp->ping_ts = h->last_send_time;
	pdp->ping_count = h->num_sent;

	icp->icmp_cksum = in_cksum((u_short *) icp, ping_pkt_size);

	n = sendto(lsock, buffer, ping_pkt_size, 0,
			   (struct sockaddr *)&h->saddr, sizeof(struct sockaddr_in));

	if(n < 0 || (unsigned int)n != ping_pkt_size) {
		if(unreachable_flag) {
			printf("%s error while sending ping: %s\n",
				   h->host, strerror(errno));
		}			/* IF */

		num_unreachable++;
		remove_job(h);
	}				/* IF */
	else {
		/* mark this trial as outstanding */
		h->resp_times[h->num_sent] = RESP_WAITING;

		h->num_sent++;
		h->waiting++;
		num_pingsent++;
		last_send_time = h->last_send_time;
	}				/* ELSE */

	free(buffer);
}					/* send_ping() */

int wait_for_reply(int lsock)
{
	int result;
	static char buffer[4096];
	struct sockaddr_in response_addr;
	struct ip *ip;
	int hlen;
	struct icmp *icp;
	int n;
	HOST_ENTRY *h = NULL;
	long this_reply;
	int this_count;
	struct timeval sent_time;

	result = recvfrom_wto(lsock, buffer, sizeof(buffer),
						  (struct sockaddr *)&response_addr, select_time);

	if(result < 0) return 0;		/* timeout */

	ip = (struct ip *)buffer;

#if defined( __alpha__ ) && __STDC__ && !defined( __GLIBC__ )
	/* The alpha headers are decidedly broken.
	 * Using an ANSI compiler, it provides ip_vhl instead of ip_hl and
	 * ip_v.  So, to get ip_hl, we mask off the bottom four bits.
	 */
	hlen = (ip->ip_vhl & 0x0F) << 2;
#else
	hlen = ip->ip_hl << 2;
#endif /* defined(__alpha__) && __STDC__ */

	if(result < hlen + ICMP_MINLEN) {
		printf("received packet too short for ICMP (%d bytes from %s)\n", result,
			   inet_ntoa(response_addr.sin_addr));

		return (1);				/* too short */
	}							/* IF */

	icp = (struct icmp *)(buffer + hlen);
	if(icp->icmp_type != ICMP_ECHOREPLY) {
		/* handle some problem */
		if(handle_random_icmp(icp, &response_addr))
			num_othericmprcvd++;

		return 1;
	}							/* IF */

	if(icp->icmp_id != ident)
		return 1;				/* packet received, but not the one we are looking for! */

	num_pingreceived++;

	if(icp->icmp_seq >= (n_short) num_hosts)
		return(1);				/* packet received, don't worry about it anymore */

	n = icp->icmp_seq;
	h = table[n];
	
	/* received ping is cool, so process it */

	gettimeofday(&current_time, &tz);
	h->waiting = 0;
	h->num_recv++;

	memcpy(&sent_time, icp->icmp_data + offsetof(PING_DATA, ping_ts),
		   sizeof(sent_time));
	memcpy(&this_count, icp->icmp_data, sizeof(this_count));

	this_reply = timeval_diff(&current_time, &sent_time);
	h->total_time += this_reply;
	total_replies++;

	/* note reply time in array, probably */
	if((this_count >= 0) && ((unsigned int)this_count < trials)) {
		if(h->resp_times[this_count] != RESP_WAITING) {
			printf("%s : duplicate for [%d], %d bytes, %s ms",
				   h->host, this_count, result, sprint_tm(this_reply));

			if(response_addr.sin_addr.s_addr != h->saddr.sin_addr.s_addr)
				printf(" [<- %s]\n", inet_ntoa(response_addr.sin_addr));
		}					/* IF */
		else h->resp_times[this_count] = this_reply;
	}						/* IF */
	else {
		/* count is out of bounds?? */
		printf("%s : duplicate for [%d], %d bytes, %s ms\n",
			   h->host, this_count, result, sprint_tm(this_reply));
		}						/* ELSE */
	
	if(h->num_recv == 1) {
		num_alive++;
	}							/* IF */

	return num_jobs;
}								/* wait_for_reply() */

int handle_random_icmp(struct icmp *p, struct sockaddr_in *addr)
{
	struct icmp *sent_icmp;
	u_char *c;
	HOST_ENTRY *h;

	c = (u_char *) p;
	switch (p->icmp_type) {
	case ICMP_UNREACH:
		sent_icmp = (struct icmp *)(c + 28);

		if((sent_icmp->icmp_type == ICMP_ECHO) &&
		   (sent_icmp->icmp_id == ident) &&
		   (sent_icmp->icmp_seq < (n_short) num_hosts)) {
			/* this is a response to a ping we sent */
			h = table[sent_icmp->icmp_seq];

			if(p->icmp_code > ICMP_UNREACH_MAXTYPE) {
				printf("ICMP Unreachable (Invalid Code) from %s for ICMP Echo sent to %s",
						inet_ntoa(addr->sin_addr), h->host);

			}					/* IF */
			else {
				printf("ICMP Unreachable from %s for ICMP Echo sent to %s",
					   inet_ntoa(addr->sin_addr), h->host);

			}					/* ELSE */

			if(inet_addr(h->host) == INADDR_NONE)
				printf(" (%s)", inet_ntoa(h->saddr.sin_addr));

			printf("\n");

		}						/* IF */

		return 1;

	case ICMP_SOURCEQUENCH:
	case ICMP_REDIRECT:
	case ICMP_TIMXCEED:
	case ICMP_PARAMPROB:
		sent_icmp = (struct icmp *)(c + 28);
		if((sent_icmp->icmp_type = ICMP_ECHO) &&
		   (sent_icmp->icmp_id = ident) &&
		   (sent_icmp->icmp_seq < (n_short) num_hosts)) {
			/* this is a response to a ping we sent */
			h = table[sent_icmp->icmp_seq];
			printf("ICMP Unreachable from %s for ICMP Echo sent to %s",
					inet_ntoa(addr->sin_addr), h->host);

			if(inet_addr(h->host) == INADDR_NONE)
				printf(" (%s)", inet_ntoa(h->saddr.sin_addr));

			printf("\n");
		}						/* IF */

		return 2;

		/* no way to tell whether any of these are sent due to our ping */
		/* or not (shouldn't be, of course), so just discard            */
	case ICMP_TSTAMP:
	case ICMP_TSTAMPREPLY:
	case ICMP_IREQ:
	case ICMP_IREQREPLY:
	case ICMP_MASKREQ:
	case ICMP_MASKREPLY:
	default:
		return 0;

	}							/* SWITCH */

}								/* handle_random_icmp() */

int in_cksum(u_short * p, int n)
{
	register u_short answer;
	register long sum = 0;
	u_short odd_byte = 0;

	while(n > 1) {
		sum += *p++;
		n -= 2;
	}							/* WHILE */

	/* mop up an odd byte, if necessary */
	if(n == 1) {
		*(u_char *) (&odd_byte) = *(u_char *) p;
		sum += odd_byte;
	}							/* IF */

	sum = (sum >> 16) + (sum & 0xffff);	/* add hi 16 to low 16 */
	sum += (sum >> 16);			/* add carry */
	answer = ~sum;				/* ones-complement, truncate */

	return (answer);

}								/* in_cksum() */

void add_name(char *name)
{
	struct hostent *host_ent;
	int ipaddress;
	struct in_addr *ipa = (struct in_addr *)&ipaddress;
	struct in_addr *host_add;
	char *nm;
	int i = 0;
	
	if((ipaddress = inet_addr(name)) != -1) {
		/* input name is an IP addr, go with it */
		if(name_flag) {
			if(addr_flag)
				add_addr(name, na_cat(get_host_by_address(*ipa), *ipa), *ipa);
			else {
				nm = cpystr(get_host_by_address(*ipa));
				add_addr(name, nm, *ipa);

			}					/* ELSE */
		}						/* IF */
		else add_addr(name, name, *ipa);

		return;
	}							/* IF */

	/* input name is not an IP addr, maybe it's a host name */
	host_ent = gethostbyname(name);
	if(host_ent == NULL) {
		if(h_errno == TRY_AGAIN) {
			u_sleep(DNS_TIMEOUT);
			host_ent = gethostbyname(name);
		}						/* IF */

		if(host_ent == NULL) {
			printf("%s address not found\n", name);
			num_noaddress++;
			return;
		}						/* IF */
	}							/* IF */

	host_add = (struct in_addr *)*(host_ent->h_addr_list);
	if(host_add == NULL) {
		printf("%s has no address data\n", name);
		num_noaddress++;
		return;
	}							/* IF */
	else {
		/* it is indeed a hostname with a real address */
		while(host_add) {
			if(name_flag && addr_flag)
				add_addr(name, na_cat(name, *host_add), *host_add);
			else if(addr_flag) {
				nm = cpystr(inet_ntoa(*host_add));
				add_addr(name, nm, *host_add);
			}					/* ELSE IF */
			else {
				add_addr(name, name, *host_add);
			}

			if(!multif_flag) break;

			host_add = (struct in_addr *)(host_ent->h_addr_list[++i]);
		}						/* WHILE */
	}							/* ELSE */
}								/* add_name() */


char *na_cat(char *name, struct in_addr ipaddr)
{
	char *nm, *as;

	as = inet_ntoa(ipaddr);
	nm = (char *)malloc(strlen(name) + strlen(as) + 4);

	if(!nm)
		crash("can't allocate some space for a string");

	strcpy(nm, name);
	strcat(nm, " (");
	strcat(nm, as);
	strcat(nm, ")");

	return (nm);

}								/* na_cat() */


void add_addr(char *name, char *host, struct in_addr ipaddr)
{
	HOST_ENTRY *p;
	unsigned int n;
	int *i;

	if(!(p = (HOST_ENTRY *) malloc(sizeof(HOST_ENTRY)))) {
		crash("can't allocate HOST_ENTRY");
	}

	memset((char *)p, 0, sizeof(HOST_ENTRY));

	p->name = name;
	p->host = host;
	p->saddr.sin_family = AF_INET;
	p->saddr.sin_addr = ipaddr;
	p->running = 1;

	/* array for response time results */
	if(!(i = (int *)malloc(trials * sizeof(int)))) {
		crash("can't allocate resp_times array");
	}

	for(n = 1; n < trials; n++)
		i[n] = RESP_UNUSED;

		p->resp_times = i;

	if(!rrlist) {
		rrlist = p;
		p->next = p;
		p->prev = p;
	}							/* IF */
	else {
		p->next = rrlist;
		p->prev = rrlist->prev;
		p->prev->next = p;
		p->next->prev = p;
	}							/* ELSE */

	num_hosts++;
}								/* add_addr() */


void remove_job(HOST_ENTRY * h)
{
	h->running = 0;
	h->waiting = 0;
	num_jobs--;

	
	if(num_jobs) {
		/* remove us from list of active jobs */
		h->prev->next = h->next;
		h->next->prev = h->prev;
		if(h == cursor) cursor = h->next;
	}							/* IF */
	else {
		cursor = NULL;
		rrlist = NULL;
	}							/* ELSE */

}								/* remove_job() */


char *get_host_by_address(struct in_addr in)
{
	struct hostent *h;
	h = gethostbyaddr((char *)&in, sizeof(struct in_addr), AF_INET);

	if(h == NULL || h->h_name == NULL)
		return inet_ntoa(in);
	else
		return (char *)h->h_name;

}								/* get_host_by_address() */


char *cpystr(char *string)
{
	char *dst;

	if(string) {
		dst = (char *)malloc(1 + strlen(string));
		if(!dst) crash("malloc() failed!");

		strcpy(dst, string);
		return dst;

	}							/* IF */
	else return NULL;

}								/* cpystr() */


void crash(char *msg)
{
	if(errno || h_errno) {
		if(errno)
			printf("%s: %s : %s\n", prog, msg, strerror(errno));
		if(h_errno)
			printf("%s: %s : A network error occurred\n", prog, msg);
	}
	else printf("%s: %s\n", prog, msg);

	exit(STATE_UNKNOWN);
}								/* crash() */


long timeval_diff(struct timeval *a, struct timeval *b)
{
	double temp;

	temp = (((a->tv_sec * 1000000) + a->tv_usec) -
			((b->tv_sec * 1000000) + b->tv_usec)) / 10;

	return (long)temp;

}								/* timeval_diff() */


char *sprint_tm(int t)
{
	static char buf[10];

	/* <= 0.99 ms */
	if(t < 100) {
		sprintf(buf, "0.%02d", t);
		return (buf);
	}							/* IF */

	/* 1.00 - 9.99 ms */
	if(t < 1000) {
		sprintf(buf, "%d.%02d", t / 100, t % 100);
		return (buf);
	}							/* IF */

	/* 10.0 - 99.9 ms */
	if(t < 10000) {
		sprintf(buf, "%d.%d", t / 100, (t % 100) / 10);
		return (buf);
	}							/* IF */

	/* >= 100 ms */
	sprintf(buf, "%d", t / 100);
	return (buf);
}								/* sprint_tm() */


/*
 * select() is posix, so we expect it to be around
 */
void u_sleep(int u_sec)
{
	int nfound;
	struct timeval to;
	fd_set readset, writeset;
	
	to.tv_sec = u_sec / 1000000;
	to.tv_usec = u_sec - (to.tv_sec * 1000000);
/*	printf("u_sleep :: to.tv_sec: %d, to_tv_usec: %d\n",
		   (int)to.tv_sec, (int)to.tv_usec);
*/	
	FD_ZERO(&writeset);
	FD_ZERO(&readset);
	nfound = select(0, &readset, &writeset, NULL, &to);
	if(nfound < 0)
		crash("select() in u_sleep:");

	return;
}								/* u_sleep() */


/************************************************************
 * Description:
 *
 * receive with timeout
 * returns length of data read or -1 if timeout
 * crash on any other errrors
 ************************************************************/
/* TODO: add MSG_DONTWAIT to recvfrom flags (currently 0) */
int recvfrom_wto(int sock, char *buf, int len, struct sockaddr *saddr, int timo)
{
	int nfound = 0, slen, n;
	struct timeval to;
	fd_set readset, writeset;

	to.tv_sec = timo / 1000000;
	to.tv_usec = (timo - (to.tv_sec * 1000000)) * 10;

/*	printf("to.tv_sec: %d, to.tv_usec: %d\n", (int)to.tv_sec, (int)to.tv_usec);
*/

	FD_ZERO(&readset);
	FD_ZERO(&writeset);
	FD_SET(sock, &readset);
	nfound = select(sock + 1, &readset, &writeset, NULL, &to);
	if(nfound < 0) crash("select() in recvfrom_wto");

	if(nfound == 0) return -1;				/* timeout */

	if(nfound) {
		slen = sizeof(struct sockaddr);
		n = recvfrom(sock, buf, len, 0, saddr, &slen);
		if(n < 0) crash("recvfrom");
		return(n);
	}

	return(0);	/* 0 bytes read, so return it */
}								/* recvfrom_wto() */


/*
 * u = micro
 * m = milli
 * s = seconds
 */
int get_threshold(char *str, threshold *th)
{
	unsigned int i, factor = 0;
	char *p = NULL;

	if(!str || !strlen(str) || !th) return -1;

	for(i=0; i<strlen(str); i++) {
		/* we happily accept decimal points in round trip time thresholds,
		 * but we ignore them quite blandly. The new way of specifying higher
		 * precision is to specify 'u' (for microseconds),
		 * 'm' (for millisecs - default) or 's' for seconds. */
		if(!p && !factor) {
			if(str[i] == 's') factor = 1000000;		/* seconds */
			else if(str[i] == 'm') factor = 1000;	/* milliseconds */
			else if(str[i] == 'u') factor = 1;		/* microseconds */
		}

		if(str[i] == '%') str[i] = '\0';
		else if(str[i] == ',' && !p && i != (strlen(str) - 1)) {
			p = &str[i+1];
			str[i] = '\0';
		}
	}

	/* default to milliseconds */
	if(!factor) factor = 1000;

	if(!p || !strlen(p)) return -1;
	th->rta = (unsigned int)strtoul(str, NULL, 0) * factor;
	th->pl = (unsigned int)strtoul(p, NULL, 0);
	return 0;
}

/* make a blahblah */
void usage(void)
{
	printf("\nUsage: %s [options] [targets]\n", prog);
	printf("  -H host  target host\n");
	printf("  -b n     ping packet size in bytes (default %d)\n", ping_data_size);
	printf("  -n|p n   number of pings to send to each target (default %d)\n", count);
	printf("  -r n     number of retries (default %d)\n", retry);
	printf("  -t n     timeout value (in msec) (default %d)\n", timeout / 100);
	printf("  -i n     packet interval (in msec) (default %d)\n", DEFAULT_INTERVAL);
/* XXX - possibly on todo-list
	printf("  -m       ping multiple interfaces on target host\n");
	printf("  -a       show targets that are alive\n");
	printf("  -d       show dead targets\n");
*/	printf("  -v       show version\n");
	printf("  -D       increase debug output level\n");
	printf("  -w       warning threshold pair, given as RTA[ums],PL[%%]\n");
	printf("  -c       critical threshold pair, given as RTA[ums],PL[%%]\n");
	printf("\n");
	printf("Note:\n");
	printf("* This program requires root privileges to run properly.\n");
	printf("  If it is run as setuid root it will halt with an error if;\n");
	printf("    interval < 25 || retries > 5\n\n");
	printf("* Threshold pairs are given as such;\n");
	printf("    100,40%%\n");
	printf("  to set a threshold value pair of 100 milliseconds and 40%% packetloss\n");
	printf("  The '%%' sign is optional, and if rta value is suffixed by;\n");
	printf("    s, rta time is set in seconds\n");
	printf("    m, rta time will be set in milliseconds (this is default)\n");
	printf("    u, rta time will be set in microseconds\n");
	printf("  Decimal points are silently ignored for sideways compatibility.\n");
	printf("\n");
	exit(3);
}								/* usage() */