From bf9d0869beeb86911855e1867ebd3ec5e4bdf746 Mon Sep 17 00:00:00 2001 From: Stanley Hopcroft Date: Tue, 1 Feb 2005 07:33:13 +0000 Subject: Revised check_icmp (1.0) from A Ericsson. git-svn-id: https://nagiosplug.svn.sourceforge.net/svnroot/nagiosplug/nagiosplug/trunk@1118 f882894a-f735-0410-b71e-b25c423dba1c --- plugins/check_icmp.c | 2241 +++++++++++++++++++++++--------------------------- 1 file changed, 1012 insertions(+), 1229 deletions(-) (limited to 'plugins/check_icmp.c') diff --git a/plugins/check_icmp.c b/plugins/check_icmp.c index 45716824..2f03552f 100644 --- a/plugins/check_icmp.c +++ b/plugins/check_icmp.c @@ -1,1416 +1,1199 @@ /* * $Id$ * - * This is a hack of fping2 made to work with nagios. - * It's fast and removes the necessity of parsing another programs output. + * Author: Andreas Ericsson * - * VIEWING NOTES: - * This file was formatted with tab indents at a tab stop of 4. + * License: GNU GPL 2.0 or any later version. * - * It is highly recommended that your editor is set to this - * tab stop setting for viewing and editing. + * Relevant RFC's: 792 (ICMP), 791 (IP) * - * 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. + * This program was modeled somewhat after the check_icmp program, + * which was in turn a hack of fping (www.fping.org) but has been + * completely rewritten since to generate higher precision rta values, + * and support several different modes as well as setting ttl to control. + * redundant routes. The only remainders of fping is currently a few + * function names. * - * The fping website can be found at http://www.fping.com */ -const char *progname = "check_icmp"; -const char *revision = "$Revision$"; -const char *copyright = "2004"; -const char *email = "nagiosplug-devel@lists.sourceforge.net"; - -#include "common.h" -#include "netutils.h" -#include "utils.h" - +#include +#include #include -#include -#include -#include - -#include - #include - -#include +#include +#include #include - -#include -#include +#include +#include +#include +#include #include - -#include - #include #include - #include #include - #include -#include - -/* RS6000 has sys/select.h */ -#ifdef HAVE_SYS_SELECT_H -#include -#endif /* HAVE_SYS_SELECT_H */ +#include -/* rta threshold values can't be larger than MAXTTL seconds */ +/** sometimes undefined system macros (quite a few, actually) **/ #ifndef MAXTTL -# define MAXTTL 255 -#endif -#ifndef IPDEFTTL -# define IPDEFTTL 64 +# define MAXTTL 255 #endif - -/*** externals ***/ -extern char *optarg; -extern int optind, opterr; - -/*** Constants ***/ -//#define EMAIL "ae@op5.se" -//#define VERSION "0.8.1" - #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 */ +#ifndef SOL_IP +#define SOL_IP 0 #endif -#ifndef DEFAULT_TIMEOUT -# define DEFAULT_TIMEOUT 1000 +/* we bundle these in one #ifndef, since they're all from BSD + * Put individual #ifndef's around those that bother you */ +#ifndef ICMP_UNREACH_NET_UNKNOWN +# define ICMP_UNREACH_NET_UNKNOWN 6 +# define ICMP_UNREACH_HOST_UNKNOWN 7 +# define ICMP_UNREACH_ISOLATED 8 +# define ICMP_UNREACH_NET_PROHIB 9 +# define ICMP_UNREACH_HOST_PROHIB 10 +# define ICMP_UNREACH_TOSNET 11 +# define ICMP_UNREACH_TOSHOST 12 #endif - -#ifndef DEFAULT_BACKOFF_FACTOR -#define DEFAULT_BACKOFF_FACTOR 1.5 /* exponential timeout factor */ +/* tru64 has the ones above, but not these */ +#ifndef ICMP_UNREACH_FILTER_PROHIB +# define ICMP_UNREACH_FILTER_PROHIB 13 +# define ICMP_UNREACH_HOST_PRECEDENCE 14 +# define ICMP_UNREACH_PRECEDENCE_CUTOFF 15 #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 my_start_time; /* conflict with utils.c 33, but not found ?? */ -struct timeval my_end_time; /* conflict with utils.c 33, but not found ?? */ -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 *); - -/* common functions */ -void print_help (void); -void print_usage (void); - -/*** the various exit-states */ -/*enum { +/** typedefs and such **/ +enum states { STATE_OK = 0, STATE_WARNING, STATE_CRITICAL, STATE_UNKNOWN, - STATE_DEPENDANT, + STATE_DEPENDENT, 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; +typedef unsigned short range_t; /* type for get_range() -- unimplemented */ + +typedef struct rta_host { + unsigned short id; /* id in **table, and icmp pkts */ + char *name; /* arg used for adding this host */ + char *msg; /* icmp error message, if any */ + struct sockaddr_in saddr_in; /* the address of this host */ + struct in_addr error_addr; /* stores address of error replies */ + unsigned long long time_waited; /* total time waited, in usecs */ + unsigned int icmp_sent, icmp_recv, icmp_lost; /* counters */ + unsigned char icmp_type, icmp_code; /* type and code from errors */ + unsigned short flags; /* control/status flags */ + double rta; /* measured RTA */ + unsigned char pl; /* measured packet loss */ + struct rta_host *next; /* linked list */ +} rta_host; + +#define FLAG_LOST_CAUSE 0x01 /* decidedly dead target. */ + +/* threshold structure. all values are maximum allowed, exclusive */ +typedef struct threshold { + unsigned char pl; /* max allowed packet loss in percent */ + unsigned int rta; /* roundtrip time average, microseconds */ +} threshold; + +/* the data structure */ +typedef struct icmp_ping_data { + struct timeval stime; /* timestamp (saved in protocol struct as well) */ + unsigned short ping_id; +} icmp_ping_data; + +/* the different modes of this program are as follows: + * MODE_RTA: send all packets no matter what (mimic check_icmp and check_ping) + * MODE_HOSTCHECK: Return immediately upon any sign of life + * In addition, sends packets to ALL addresses assigned + * to this host (as returned by gethostbyname() or + * gethostbyaddr() and expects one host only to be checked at + * a time. Therefore, any packet response what so ever will + * count as a sign of life, even when received outside + * crit.rta limit. Do not misspell any additional IP's. + * MODE_ALL: Requires packets from ALL requested IP to return OK (default). + * MODE_ICMP: implement something similar to check_icmp (MODE_RTA without + * tcp and udp args does this) + */ +#define MODE_RTA 0 +#define MODE_HOSTCHECK 1 +#define MODE_ALL 2 +#define MODE_ICMP 3 + +/* the different ping types we can do + * TODO: investigate ARP ping as well */ +#define HAVE_ICMP 1 +#define HAVE_UDP 2 +#define HAVE_TCP 4 +#define HAVE_ARP 8 + +#define MIN_PING_DATA_SIZE sizeof(struct icmp_ping_data) +#define MAX_IP_PKT_SIZE 65536 /* (theoretical) max IP packet size */ +#define IP_HDR_SIZE 20 +#define MAX_PING_DATA (MAX_IP_PKT_SIZE - IP_HDR_SIZE - ICMP_MINLEN) +#define DEFAULT_PING_DATA_SIZE (MIN_PING_DATA_SIZE + 44) + +/* various target states */ +#define TSTATE_INACTIVE 0x01 /* don't ping this host anymore */ +#define TSTATE_WAITING 0x02 /* unanswered packets on the wire */ +#define TSTATE_ALIVE 0x04 /* target is alive (has answered something) */ +#define TSTATE_UNREACH 0x08 + +/** prototypes **/ +static void usage(unsigned char, char *); +static u_int get_timevar(const char *); +static u_int get_timevaldiff(struct timeval *, struct timeval *); +static int wait_for_reply(int, u_int); +static int recvfrom_wto(int, char *, unsigned int, struct sockaddr *, u_int *); +static int send_icmp_ping(int, struct rta_host *); +static int get_threshold(char *str, threshold *th); +static void run_checks(void); +static int add_target(char *); +static int add_target_ip(char *, struct in_addr *); +static int handle_random_icmp(struct icmp *, struct sockaddr_in *); +static unsigned short icmp_checksum(unsigned short *, int); +static void finish(int); +static void crash(const char *, ...); + +/** external **/ +extern int optind, opterr, optopt; +extern char *optarg; +extern char **environ; + +/** global variables **/ +static char *progname; +static struct rta_host **table, *cursor, *list; +static threshold crit = {80, 500000}, warn = {40, 200000}; +static int mode, protocols, sockets, debug = 0, timeout = 10; +static unsigned short icmp_pkt_size, icmp_data_size = DEFAULT_PING_DATA_SIZE; +static unsigned int icmp_sent = 0, icmp_recv = 0, icmp_lost = 0; +#define icmp_pkts_en_route (icmp_sent - (icmp_recv + icmp_lost)) +static unsigned short targets_down = 0, targets = 0, packets = 0; +#define targets_alive (targets - targets_down) +static unsigned int retry_interval, pkt_interval, target_interval; +static int icmp_sock, tcp_sock, udp_sock, status = STATE_OK; +static pid_t pid; +static struct timezone tz; +static struct timeval prog_start; +static unsigned long long max_completion_time = 0; +static unsigned char ttl = 0; /* outgoing ttl */ +static unsigned int warn_down = 1, crit_down = 1; /* host down threshold values */ +float pkt_backoff_factor = 1.5; +float target_backoff_factor = 1.5; + +/** code start **/ +static void +crash(const char *fmt, ...) +{ + va_list ap; + + printf("%s: ", progname); + + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); + + if(errno) printf(": %s", strerror(errno)); + puts(""); -/***************************************************************************** - * Code block start * - *****************************************************************************/ -int main(int argc, char **argv) + exit(3); +} + + +static char * +get_icmp_error_msg(unsigned char icmp_type, unsigned char icmp_code) { - 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]; - - setlocale (LC_ALL, ""); - bindtextdomain (PACKAGE, LOCALEDIR); - textdomain (PACKAGE); - - /* check if we are root */ - if(geteuid()) { - printf(_("Root access needed (for raw sockets)\n")); - exit(STATE_UNKNOWN); - } + char *msg = "unreachable"; - /* confirm that ICMP is available on this machine */ - if((proto = getprotobyname("icmp")) == NULL) - crash(_("icmp: unknown protocol")); + if(debug > 1) printf("get_icmp_error_msg(%u, %u)\n", icmp_type, icmp_code); + switch(icmp_type) { + case ICMP_UNREACH: + switch(icmp_code) { + case ICMP_UNREACH_NET: msg = "Net unreachable"; break; + case ICMP_UNREACH_HOST: msg = "Host unreachable"; break; + case ICMP_UNREACH_PROTOCOL: msg = "Protocol unreachable (firewall?)"; break; + case ICMP_UNREACH_PORT: msg = "Port unreachable (firewall?)"; break; + case ICMP_UNREACH_NEEDFRAG: msg = "Fragmentation needed"; break; + case ICMP_UNREACH_SRCFAIL: msg = "Source route failed"; break; + case ICMP_UNREACH_ISOLATED: msg = "Source host isolated"; break; + case ICMP_UNREACH_NET_UNKNOWN: msg = "Unknown network"; break; + case ICMP_UNREACH_HOST_UNKNOWN: msg = "Unknown host"; break; + case ICMP_UNREACH_NET_PROHIB: msg = "Network denied (firewall?)"; break; + case ICMP_UNREACH_HOST_PROHIB: msg = "Host denied (firewall?)"; break; + case ICMP_UNREACH_TOSNET: msg = "Bad TOS for network (firewall?)"; break; + case ICMP_UNREACH_TOSHOST: msg = "Bad TOS for host (firewall?)"; break; + case ICMP_UNREACH_FILTER_PROHIB: msg = "Prohibited by filter (firewall)"; break; + case ICMP_UNREACH_HOST_PRECEDENCE: msg = "Host precedence violation"; break; + case ICMP_UNREACH_PRECEDENCE_CUTOFF: msg = "Precedence cutoff"; break; + default: msg = "Invalid code"; break; + } + break; - /* create raw socket for ICMP calls (ping) */ - sock = socket(AF_INET, SOCK_RAW, proto->p_proto); + case ICMP_TIMXCEED: + /* really 'out of reach', or non-existant host behind a router serving + * two different subnets */ + switch(icmp_code) { + case ICMP_TIMXCEED_INTRANS: msg = "Time to live exceeded in transit"; break; + case ICMP_TIMXCEED_REASS: msg = "Fragment reassembly time exceeded"; break; + default: msg = "Invalid code"; break; + } + break; - if(sock < 0) - crash(_("Can't create raw socket")); + case ICMP_SOURCEQUENCH: msg = "Transmitting too fast"; break; + case ICMP_REDIRECT: msg = "Redirect (change route)"; break; + case ICMP_PARAMPROB: msg = "Bad IP header (required option absent)"; break; - /* drop privileges now that we have the socket */ - if((uid = getuid())) { - seteuid(uid); + /* the following aren't error messages, so ignore */ + case ICMP_TSTAMP: + case ICMP_TSTAMPREPLY: + case ICMP_IREQ: + case ICMP_IREQREPLY: + case ICMP_MASKREQ: + case ICMP_MASKREPLY: + default: msg = ""; break; } - - if(argc < 2) print_usage(); - ident = getpid() & 0xFFFF; + return msg; +} + +static int +handle_random_icmp(struct icmp *p, struct sockaddr_in *addr) +{ + struct icmp *sent_icmp = NULL; + struct rta_host *host = NULL; + unsigned char *ptr; - if(!(host_base_ptr = malloc(sizeof(struct host_name_list)))) { - crash(_("Unable to allocate memory for host name list\n")); + if(p->icmp_type == ICMP_ECHO && p->icmp_id == pid) { + /* echo request from us to us (pinging localhost) */ + return 0; } - 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); - print_usage(); - } - break; + ptr = (unsigned char *)p; + if(debug) printf("handle_random_icmp(%p, %p)\n", (void *)p, (void *)addr); + + /* only handle a few types, since others can't possibly be replies to + * us in a sane network (if it is anyway, it will be counted as lost + * at summary time, but not as quickly as a proper response */ + /* TIMXCEED can be an unreach from a router with multiple IP's which + * serves two different subnets on the same interface and a dead host + * on one net is pinged from the other. The router will respond to + * itself and thus set TTL=0 so as to not loop forever. Even when + * TIMXCEED actually sends a proper icmp response we will have passed + * too many hops to have a hope of reaching it later, in which case it + * indicates overconfidence in the network, poor routing or both. */ + if(p->icmp_type != ICMP_UNREACH && p->icmp_type != ICMP_TIMXCEED && + p->icmp_type != ICMP_SOURCEQUENCH && p->icmp_type != ICMP_PARAMPROB) + { + return 0; + } - case 'c': - if(get_threshold(optarg, &crit)) { - printf(_("Illegal threshold pair specified for -%c"), c); - print_usage(); - } - break; + /* might be for us. At least it holds the original package (according + * to RFC 792). If it isn't, just ignore it */ + sent_icmp = (struct icmp *)(ptr + 28); + if(sent_icmp->icmp_type != ICMP_ECHO || sent_icmp->icmp_id != pid || + sent_icmp->icmp_seq >= targets) + { + if(debug) printf("Packet is no response to a packet we sent\n"); + return 0; + } - case 't': - if(!(timeout = (u_int) strtoul(optarg, NULL, 0) * 100)) { - printf(_("Option -%c requires integer argument\n"), c); - print_usage(); - } - break; + /* it is indeed a response for us */ + host = table[sent_icmp->icmp_seq]; + if(debug) { + printf("Received \"%s\" from %s for ICMP ECHO sent to %s.\n", + get_icmp_error_msg(p->icmp_type, p->icmp_code), + inet_ntoa(addr->sin_addr), host->name); + } - case 'r': - if(!(retry = (u_int) strtoul(optarg, NULL, 0))) { - printf(_("Option -%c requires integer argument\n"), c); - print_usage(); - } - break; + icmp_lost++; + host->icmp_lost++; + /* don't spend time on lost hosts any more */ + if(host->flags & FLAG_LOST_CAUSE) return 0; - case 'i': - if(!(interval = (u_int) strtoul(optarg, NULL, 0) * 100)) { - printf(_("Option -%c requires positive non-zero integer argument\n"), c); - print_usage(); - } - break; + /* source quench means we're sending too fast, so increase the + * interval and mark this packet lost */ + if(p->icmp_type == ICMP_SOURCEQUENCH) { + pkt_interval *= pkt_backoff_factor; + target_interval *= target_backoff_factor; + } + else { + targets_down++; + host->flags |= FLAG_LOST_CAUSE; + } + host->icmp_type = p->icmp_type; + host->icmp_code = p->icmp_code; + host->error_addr.s_addr = addr->sin_addr.s_addr; - case 'p': - case 'n': - if(!(count = (u_int) strtoul(optarg, NULL, 0))) { - printf(_("Option -%c requires positive non-zero integer argument\n"), c); - print_usage(); - } - break; + return 0; +} +int +main(int argc, char **argv) +{ + int i; + char *ptr; + long int arg; + int icmp_sockerrno, udp_sockerrno, tcp_sockerrno; + int result; + struct rta_host *host; + + /* we only need to be setsuid when we get the sockets, so do + * that before pointer magic (esp. on network data) */ + icmp_sockerrno = udp_sockerrno = tcp_sockerrno = sockets = 0; + + if((icmp_sock = socket(PF_INET, SOCK_RAW, IPPROTO_ICMP)) != -1) + sockets |= HAVE_ICMP; + else icmp_sockerrno = errno; + + /* if((udp_sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) != -1) */ + /* sockets |= HAVE_UDP; */ + /* else udp_sockerrno = errno; */ + + /* if((tcp_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) != -1) */ + /* sockets |= HAVE_TCP; */ + /* else tcp_sockerrno = errno; */ + + /* now drop privileges (no effect if not setsuid or geteuid() == 0) */ + setuid(getuid()); + + /* POSIXLY_CORRECT might break things, so unset it (the portable way) */ + environ = NULL; + + /* use the pid to mark packets as ours */ + pid = getpid(); + /* printf("pid = %u\n", pid); */ + + /* get calling name the old-fashioned way for portability instead + * of relying on the glibc-ism __progname */ + ptr = strrchr(argv[0], '/'); + if(ptr) progname = &ptr[1]; + else progname = argv[0]; + + /* now set defaults. Use progname to set them initially (allows for + * superfast check_host program when target host is up */ + cursor = list = NULL; + table = NULL; + + mode = MODE_RTA; + crit.rta = 500000; + crit.pl = 80; + warn.rta = 200000; + warn.pl = 40; + protocols = HAVE_ICMP | HAVE_UDP | HAVE_TCP; + pkt_interval = 80000; /* 80 msec packet interval by default */ + packets = 5; + + if(!strcmp(progname, "check_icmp") || !strcmp(progname, "check_ping")) { + mode = MODE_ICMP; + protocols = HAVE_ICMP; + } + else if(!strcmp(progname, "check_host")) { + mode = MODE_HOSTCHECK; + pkt_interval = 1000000; + packets = 5; + crit.rta = warn.rta = 1000000; + crit.pl = warn.pl = 100; + } + else if(!strcmp(progname, "check_rta_multi")) { + mode = MODE_ALL; + target_interval = 0; + pkt_interval = 50000; + packets = 5; + } + + /* parse the arguments */ + for(i = 1; i < argc; i++) { + while((arg = getopt(argc, argv, "vhVw:c:n:p:t:H:i:b:I:l:")) != EOF) { + switch(arg) { + case 'v': + debug++; + break; case 'b': - if(!(ping_data_size = (u_int) strtoul(optarg, NULL, 0))) { - printf(_("Option -%c requires integer argument\n"), c); - print_usage(); - } + /* silently ignored for now */ break; - - case 'h': - print_usage(); + case 'i': + pkt_interval = get_timevar(optarg); break; - - case 'e': - elapsed_flag = 1; + case 'I': + target_interval = get_timevar(optarg); break; - - case 'm': - multif_flag = 1; + case 'w': + get_threshold(optarg, &warn); break; - - case 'd': - name_flag = 1; + case 'c': + get_threshold(optarg, &crit); break; - - case 'A': - addr_flag = 1; + case 'n': + case 'p': + packets = strtoul(optarg, NULL, 0); break; - - case 's': - stats_flag = 1; + case 't': + timeout = strtoul(optarg, NULL, 0); + if(!timeout) timeout = 10; break; - - case 'u': - unreachable_flag = 1; + case 'H': + add_target(optarg); break; - - case 'a': - alive_flag = 1; + case 'l': + ttl = (unsigned char)strtoul(optarg, NULL, 0); break; - - case 'v': - printf("%s: Version %s $Date$\n", prog, VERSION); - 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; + case 'd': /* implement later, for cluster checks */ + warn_down = (unsigned char)strtoul(optarg, &ptr, 0); + if(ptr) { + crit_down = (unsigned char)strtoul(ptr + 1, NULL, 0); + } break; - - default: - printf(_("Option flag -%c specified, but not recognized\n"), c); - print_usage(); + case 'h': case 'V': default: + usage(arg, NULL); 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); + argv = &argv[optind]; + while(*argv) { + add_target(*argv); + argv++; } - - /* 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); - print_usage(); + if(!targets) { + errno = 0; + crash("No hosts to check"); + exit(3); } - 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); - print_usage(); - + if(!sockets) { + if(icmp_sock == -1) { + errno = icmp_sockerrno; + crash("Failed to obtain ICMP socket"); + return -1; + } + /* if(udp_sock == -1) { */ + /* errno = icmp_sockerrno; */ + /* crash("Failed to obtain UDP socket"); */ + /* return -1; */ + /* } */ + /* if(tcp_sock == -1) { */ + /* errno = icmp_sockerrno; */ + /* crash("Failed to obtain TCP socker"); */ + /* return -1; */ + /* } */ } + if(!ttl) ttl = 64; - 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); - print_usage(); - + if(icmp_sock) { + result = setsockopt(icmp_sock, SOL_IP, IP_TTL, &ttl, sizeof(ttl)); + if(debug) { + if(result == -1) printf("setsockopt failed\n"); + else printf("ttl set to %u\n", ttl); + } } - if(count > MAX_COUNT) { - printf(_("%s: count %u not valid, must be less than %u\n"), - prog, count, MAX_COUNT); - print_usage(); + /* stupid users should be able to give whatever thresholds they want + * (nothing will break if they do), but some anal plugin maintainer + * will probably add some printf() thing here later, so it might be + * best to at least show them where to do it. ;) */ + if(warn.pl > crit.pl) warn.pl = crit.pl; + if(warn.rta > crit.rta) warn.rta = crit.rta; + if(warn_down > crit_down) crit_down = warn_down; + + signal(SIGINT, finish); + signal(SIGHUP, finish); + signal(SIGTERM, finish); + signal(SIGALRM, finish); + if(debug) printf("Setting alarm timeout to %u seconds\n", timeout); + alarm(timeout); + + /* make sure we don't wait any longer than necessary */ + gettimeofday(&prog_start, &tz); + max_completion_time = + ((targets * packets * pkt_interval) + (targets * target_interval)) + + (targets * packets * crit.rta) + crit.rta; + + if(debug) { + printf("packets: %u, targets: %u\n" + "target_interval: %0.3f, pkt_interval %0.3f\n" + "crit.rta: %0.3f\n" + "max_completion_time: %0.3f\n", + packets, targets, + (float)target_interval / 1000, (float)pkt_interval / 1000, + (float)crit.rta / 1000, + (float)max_completion_time / 1000); } - if(count_flag) { - alive_flag = unreachable_flag = 0; + if(debug) { + if(max_completion_time > (u_int)timeout * 1000000) { + printf("max_completion_time: %llu timeout: %u\n", + max_completion_time, timeout); + printf("Timout must be at lest %llu\n", + max_completion_time / 1000000 + 1); + } } - 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")); - print_usage(); + icmp_pkt_size = icmp_data_size + ICMP_MINLEN; + if(debug > 2) printf("icmp_pkt_size = %u\n", icmp_pkt_size); + if(icmp_pkt_size < sizeof(struct icmp) + sizeof(struct icmp_ping_data)) { + icmp_pkt_size = sizeof(struct icmp) + sizeof(struct icmp_ping_data); } - - 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++; - } + if(debug > 2) printf("icmp_pkt_size = %u\n", icmp_pkt_size); + + if(debug) { + printf("crit = {%u, %u%%}, warn = {%u, %u%%}\n", + crit.rta, crit.pl, warn.rta, warn.pl); + printf("pkt_interval: %u target_interval: %u retry_interval: %u\n", + pkt_interval, target_interval, retry_interval); + printf("icmp_pkt_size: %u timeout: %u\n", + icmp_pkt_size, timeout); } - // 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(packets > 20) { + errno = 0; + crash("packets is > 20 (%d)", packets); } - if(!num_hosts) { - printf(_("No hosts to work with!\n\n")); - print_usage(); + host = list; + table = malloc(sizeof(struct rta_host **) * (argc - 1)); + i = 0; + while(host) { + host->id = i; + table[i] = host; + host = host->next; + i++; } - /* 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 */ + run_checks(); - ping_pkt_size = ping_data_size + SIZE_ICMP_HDR; + errno = 0; + finish(0); - signal(SIGINT, (void *)finish); - - gettimeofday(&my_start_time, &tz); - current_time = my_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(¤t_time, &tz); - lt = timeval_diff(¤t_time, &last_send_time); - ht = timeval_diff(¤t_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 */ + return(0); +} - /* 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); +static void +run_checks() +{ + u_int i, t, result; + u_int final_wait, time_passed; + + /* this loop might actually violate the pkt_interval or target_interval + * settings, but only if there aren't any packets on the wire which + * indicates that the target can handle an increased packet rate */ + for(i = 0; i < packets; i++) { + for(t = 0; t < targets; t++) { + /* don't send useless packets */ + if(!targets_alive) finish(0); + if(table[t]->flags & FLAG_LOST_CAUSE) { + if(debug) printf("%s is a lost cause. not sending any more\n", + table[t]->name); continue; + } + + /* we're still in the game, so send next packet */ + (void)send_icmp_ping(icmp_sock, table[t]); + result = wait_for_reply(icmp_sock, target_interval); + } + result = wait_for_reply(icmp_sock, pkt_interval * targets); + } - } /* IF */ - } /* ELSE */ + if(icmp_pkts_en_route && targets_alive) { + time_passed = get_timevaldiff(NULL, NULL); + final_wait = max_completion_time - time_passed; - /* could send to this host, so keep considering it */ - if(ht > interval) { - advance = 0; + if(debug) { + printf("time_passed: %u final_wait: %u max_completion_time: %llu\n", + time_passed, final_wait, max_completion_time); + } + if(time_passed > max_completion_time) { + if(debug) printf("Time passed. Finishing up\n"); + finish(0); } - } /* WHILE */ - finish(); - return 0; -} /* main() */ + /* catch the packets that might come in within the timeframe, but + * haven't yet */ + if(debug) printf("Waiting for %u micro-seconds (%0.3f msecs)\n", + final_wait, (float)final_wait / 1000); + result = wait_for_reply(icmp_sock, final_wait); + } +} -/************************************************************ - * Description: - * - * Main program clean up and exit point - ************************************************************/ -void finish() +/* response structure: + * ip header : 20 bytes + * icmp header : 28 bytes + * icmp echo reply : the rest + */ +static int +wait_for_reply(int sock, u_int t) { - int i; - HOST_ENTRY *h; - - gettimeofday(&my_end_time, &tz); - - /* tot up unreachables */ - for(i=0; inum_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); - } + int n, hlen; + static char buf[4096]; + struct sockaddr_in resp_addr; + struct ip *ip; + struct icmp *icp, *sent_icmp; + struct rta_host *host; + struct icmp_ping_data *data; + struct timeval wait_start, now; + u_int tdiff, i, per_pkt_wait; + + /* if we can't listen or don't have anything to listen to, just return */ + if(!t || !icmp_pkts_en_route) return 0; + + gettimeofday(&wait_start, &tz); + + i = t; + per_pkt_wait = t / icmp_pkts_en_route; + while(icmp_pkts_en_route && get_timevaldiff(&wait_start, NULL) < i) { + t = per_pkt_wait; + + /* wrap up if all targets are declared dead */ + if(!targets_alive || + get_timevaldiff(&prog_start, NULL) >= max_completion_time || + (mode == MODE_HOSTCHECK && targets_down)) + { + finish(0); } - 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; + /* reap responses until we hit a timeout */ + n = recvfrom_wto(sock, buf, sizeof(buf), + (struct sockaddr *)&resp_addr, &t); + if(!n) { + if(debug > 1) { + printf("recvfrom_wto() timed out during a %u usecs wait\n", + per_pkt_wait); } + continue; /* timeout for this one, so keep trying */ + } + if(n < 0) { + if(debug) printf("recvfrom_wto() returned errors\n"); + return n; + } - if(num_hosts == 1 || status != STATE_OK) { - printf("%s - %s: rta %s ms, lost %d%%", - state_text(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(" :: "); - } + ip = (struct ip *)buf; + if(debug > 1) printf("received %u bytes from %s\n", + ntohs(ip->ip_len), inet_ntoa(resp_addr.sin_addr)); + +/* obsolete. alpha on tru64 provides the necessary defines, but isn't broken */ +/* #if defined( __alpha__ ) && __STDC__ && !defined( __GLIBC__ ) */ + /* alpha headers are decidedly broken. Using an ansi compiler, + * they provide ip_vhl instead of ip_hl and ip_v, so we mask + * off the bottom 4 bits */ +/* hlen = (ip->ip_vhl & 0x0f) << 2; */ +/* #else */ + hlen = ip->ip_hl << 2; +/* #endif */ + + if(n < (hlen + ICMP_MINLEN)) { + crash("received packet too short for ICMP (%d bytes, expected %d) from %s\n", + n, hlen + icmp_pkt_size, inet_ntoa(resp_addr.sin_addr)); + } + /* else if(debug) { */ + /* printf("ip header size: %u, packet size: %u (expected %u, %u)\n", */ + /* hlen, ntohs(ip->ip_len) - hlen, */ + /* sizeof(struct ip), icmp_pkt_size); */ + /* } */ + + /* check the response */ + icp = (struct icmp *)(buf + hlen); + sent_icmp = (struct icmp *)(buf + hlen + ICMP_MINLEN); + /* printf("buf: %p, icp: %p, distance: %u (expected %u)\n", */ + /* buf, icp, */ + /* (u_int)icp - (u_int)buf, hlen); */ + /* printf("buf: %p, sent_icmp: %p, distance: %u (expected %u)\n", */ + /* buf, sent_icmp, */ + /* (u_int)sent_icmp - (u_int)buf, hlen + ICMP_MINLEN); */ + + if(icp->icmp_id != pid) { + handle_random_icmp(icp, &resp_addr); + continue; + } - /* fin_stat should always hold the WORST state */ - if(fin_stat != STATE_CRITICAL && status != STATE_OK) { - fin_stat = status; - } + if(icp->icmp_type != ICMP_ECHOREPLY || icp->icmp_seq >= targets) { + if(debug > 2) printf("not a proper ICMP_ECHOREPLY\n"); + handle_random_icmp(icp, &resp_addr); + continue; } - } - if(num_noaddress) { - printf(_("No hostaddress specified.\n")); - print_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; - } + /* this is indeed a valid response */ + data = (struct icmp_ping_data *)(icp->icmp_data); - if(num_hosts > 1) { - if(num_alive == num_hosts) { - printf(_("OK - All %d hosts are alive\n"), num_hosts); + host = table[icp->icmp_seq]; + gettimeofday(&now, &tz); + tdiff = get_timevaldiff(&data->stime, &now); + + host->time_waited += tdiff; + host->icmp_recv++; + icmp_recv++; + + if(debug) { + printf("%0.3f ms rtt from %s, outgoing ttl: %u, incoming ttl: %u\n", + (float)tdiff / 1000, inet_ntoa(resp_addr.sin_addr), + ttl, ip->ip_ttl); } - else { - printf(_("CRITICAL - %d of %d hosts are alive\n"), num_alive, num_hosts); + + /* if we're in hostcheck mode, exit with limited printouts */ + if(mode == MODE_HOSTCHECK) { + printf("OK - %s responds to ICMP. Packet %u, rta %0.3fms|" + "pkt=%u;;0;%u rta=%0.3f;%0.3f;%0.3f;;\n", + host->name, icmp_recv, (float)tdiff / 1000, + icmp_recv, packets, (float)tdiff / 1000, + (float)warn.rta / 1000, (float)crit.rta / 1000); + exit(STATE_OK); } } - exit(fin_stat); -} + return 0; +} -void send_ping(int lsock, HOST_ENTRY *h) +/* the ping functions */ +static int +send_icmp_ping(int sock, struct rta_host *host) { - char *buffer; + static char *buf = NULL; /* re-use so we prevent leaks */ + long int len; struct icmp *icp; - PING_DATA *pdp; - int n; - - buffer = (char *)malloc((size_t) ping_pkt_size); - if(!buffer) - crash(_("Can't malloc ping packet")); + struct icmp_ping_data *data; + struct timeval tv; + struct sockaddr *addr; - memset(buffer, 0, ping_pkt_size * sizeof(char)); - icp = (struct icmp *)buffer; + + if(sock == -1) { + errno = 0; + crash("Attempt to send on bogus socket"); + return -1; + } + addr = (struct sockaddr *)&host->saddr_in; + + if(!buf) { + buf = (char *)malloc(icmp_pkt_size + sizeof(struct ip)); + if(!buf) { + crash("send_icmp_ping(): failed to malloc %d bytes for send buffer", + icmp_pkt_size); + return -1; /* might be reached if we're in debug mode */ + } + } + memset(buf, 0, icmp_pkt_size + sizeof(struct ip)); - gettimeofday(&h->last_send_time, &tz); + if((gettimeofday(&tv, &tz)) == -1) return -1; + icp = (struct icmp *)buf; 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; + icp->icmp_id = pid; + icp->icmp_seq = host->id; + data = (struct icmp_ping_data *)icp->icmp_data; + data->ping_id = 10; /* host->icmp.icmp_sent; */ + memcpy(&data->stime, &tv, sizeof(struct timeval)); + icp->icmp_cksum = icmp_checksum((u_short *)icp, icmp_pkt_size); + + len = sendto(sock, buf, icmp_pkt_size, 0, (struct sockaddr *)addr, + sizeof(struct sockaddr)); + + if(len < 0 || (unsigned int)len != icmp_pkt_size) { + if(debug) printf("Failed to send ping to %s\n", + inet_ntoa(host->saddr_in.sin_addr)); + return -1; + } - h->num_sent++; - h->waiting++; - num_pingsent++; - last_send_time = h->last_send_time; - } /* ELSE */ + icmp_sent++; + host->icmp_sent++; - free(buffer); -} /* send_ping() */ + return 0; +} -int wait_for_reply(int lsock) +static int +recvfrom_wto(int sock, char *buf, unsigned int len, struct sockaddr *saddr, + u_int *timo) { - int result; - static char buffer[4096]; - struct sockaddr_in response_addr; - struct ip *ip; - int hlen; - struct icmp *icp; + u_int slen; 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__ */ + struct timeval to, then, now; + fd_set rd, wr; - 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(¤t_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(¤t_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: + if(!*timo) { + if(debug) printf("*timo is not\n"); 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")); + to.tv_sec = *timo / 1000000; + to.tv_usec = (*timo - (to.tv_sec * 1000000)); - strcpy(nm, name); - strcat(nm, " ("); - strcat(nm, as); - strcat(nm, ")"); + FD_ZERO(&rd); + FD_ZERO(&wr); + FD_SET(sock, &rd); + errno = 0; + gettimeofday(&then, &tz); + n = select(sock + 1, &rd, &wr, NULL, &to); + if(n < 0) crash("select() in recvfrom_wto"); + gettimeofday(&now, &tz); + *timo = get_timevaldiff(&then, &now); - return (nm); + if(!n) return 0; /* timeout */ -} /* na_cat() */ + slen = sizeof(struct sockaddr); + return recvfrom(sock, buf, len, 0, saddr, &slen); +} -void add_addr(char *name, char *host, struct in_addr ipaddr) +static void +finish(int sig) { - HOST_ENTRY *p; - unsigned int n; - int *i; - - if(!(p = (HOST_ENTRY *) malloc(sizeof(HOST_ENTRY)))) { - crash(_("Can't allocate HOST_ENTRY")); + u_int i = 0; + unsigned char pl; + double rta; + struct rta_host *host; + char *status_string[] = + {"OK", "WARNING", "CRITICAL", "UNKNOWN", "DEPENDENT"}; + + alarm(0); + if(debug > 1) printf("finish(%d) called\n", sig); + + if(icmp_sock != -1) close(icmp_sock); + if(udp_sock != -1) close(udp_sock); + if(tcp_sock != -1) close(tcp_sock); + + if(debug) { + printf("icmp_sent: %u icmp_recv: %u icmp_lost: %u\n", + icmp_sent, icmp_recv, icmp_lost); + printf("targets: %u targets_alive: %u\n", targets, targets_alive); } - 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; + /* iterate thrice to calculate values, give output, and print perfparse */ + host = list; + while(host) { + if(!host->icmp_recv) { + /* rta 0 is ofcourse not entirely correct, but will still show up + * conspicuosly as missing entries in perfparse and cacti */ + pl = 100; + rta = 0; + status = STATE_CRITICAL; + /* up the down counter if not already counted */ + if(!(host->flags & FLAG_LOST_CAUSE) && targets_alive) targets_down++; + } + else { + pl = ((host->icmp_sent - host->icmp_recv) * 100) / host->icmp_sent; + rta = (double)host->time_waited / host->icmp_recv; + } + host->pl = pl; + host->rta = rta; + if(!status && (pl >= warn.pl || rta >= warn.rta)) status = STATE_WARNING; + if(pl >= crit.pl || rta >= crit.rta) status = STATE_CRITICAL; - /* array for response time results */ - if(!(i = (int *)malloc(trials * sizeof(int)))) { - crash(_("Can't allocate resp_times array")); + host = host->next; } + /* this is inevitable */ + if(!targets_alive) status = STATE_CRITICAL; + printf("%s - ", status_string[status]); + + host = list; + while(host) { + if(debug) puts(""); + if(i) { + if(i < targets) printf(" :: "); + else printf("\n"); + } + i++; + if(!host->icmp_recv) { + status = STATE_CRITICAL; + if(host->flags & FLAG_LOST_CAUSE) { + printf("%s: %s @ %s. rta nan, lost %d%%", + host->name, + get_icmp_error_msg(host->icmp_type, host->icmp_code), + inet_ntoa(host->error_addr), + 100); + } + else { /* not marked as lost cause, so we have no flags for it */ + printf("%s: rta nan, lost 100%%", host->name); + } + } + else { /* !icmp_recv */ + printf("%s: rta %0.3fms, lost %u%%", + host->name, host->rta / 1000, host->pl); + } - 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); + host = host->next; + } - if(h == NULL || h->h_name == NULL) - return inet_ntoa(in); - else - return (char *)h->h_name; + /* iterate once more for pretty perfparse output */ + printf("|"); + i = 0; + host = list; + while(host) { + if(debug) puts(""); + printf("%srta=%0.3fms;%0.3f;%0.3f;0; %spl=%u%%;%u;%u;; ", + (targets > 1) ? host->name : "", + host->rta / 1000, (float)warn.rta / 1000, (float)crit.rta / 1000, + (targets > 1) ? host->name : "", + host->pl, warn.pl, crit.pl); + + host = host->next; + } -} /* get_host_by_address() */ + /* finish with an empty line */ + puts(""); + if(debug) printf("targets: %u, targets_alive: %u\n", + targets, targets_alive); + exit(status); +} -char *cpystr(char *string) +static u_int +get_timevaldiff(struct timeval *early, struct timeval *later) { - 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() */ + u_int ret; + struct timeval now; + if(!later) { + gettimeofday(&now, &tz); + later = &now; + } + if(!early) early = &prog_start; -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); + /* if early > later we return 0 so as to indicate a timeout */ + if(early->tv_sec > early->tv_sec || + (early->tv_sec == later->tv_sec && early->tv_usec > later->tv_usec)) + { + return 0; } - else printf("%s: %s\n", prog, msg); - exit(STATE_UNKNOWN); -} /* crash() */ + ret = (later->tv_sec - early->tv_sec) * 1000000; + ret += later->tv_usec - early->tv_usec; + return ret; +} -long timeval_diff(struct timeval *a, struct timeval *b) +static int +add_target_ip(char *arg, struct in_addr *in) { - double temp; - - temp = (((a->tv_sec * 1000000) + a->tv_usec) - - ((b->tv_sec * 1000000) + b->tv_usec)) / 10; - - return (long)temp; - -} /* timeval_diff() */ - + struct rta_host *host; + + /* disregard obviously stupid addresses */ + if(in->s_addr == INADDR_NONE || in->s_addr == INADDR_ANY) + return -1; + + /* no point in adding two identical IP's, so don't. ;) */ + host = list; + while(host) { + if(host->saddr_in.sin_addr.s_addr == in->s_addr) { + if(debug) printf("Identical IP already exists. Not adding %s\n", arg); + return -1; + } + host = host->next; + } -char *sprint_tm(int t) -{ - static char buf[10]; + /* add the fresh ip */ + host = malloc(sizeof(struct rta_host)); + if(!host) { + crash("add_target_ip(%s, %s): malloc(%d) failed", + arg, inet_ntoa(*in), sizeof(struct rta_host)); + } + memset(host, 0, sizeof(struct rta_host)); - /* <= 0.99 ms */ - if(t < 100) { - sprintf(buf, "0.%02d", t); - return (buf); - } /* IF */ + /* set the values. use calling name for output */ + host->name = strdup(arg); - /* 1.00 - 9.99 ms */ - if(t < 1000) { - sprintf(buf, "%d.%02d", t / 100, t % 100); - return (buf); - } /* IF */ + /* fill out the sockaddr_in struct */ + host->saddr_in.sin_family = AF_INET; + host->saddr_in.sin_addr.s_addr = in->s_addr; - /* 10.0 - 99.9 ms */ - if(t < 10000) { - sprintf(buf, "%d.%d", t / 100, (t % 100) / 10); - return (buf); - } /* IF */ + if(!list) list = cursor = host; + else cursor->next = host; - /* >= 100 ms */ - sprintf(buf, "%d", t / 100); - return (buf); -} /* sprint_tm() */ + cursor = host; + targets++; + return 0; +} -/* - * select() is posix, so we expect it to be around - */ -void u_sleep(int u_sec) +/* wrapper for add_target_ip */ +static int +add_target(char *arg) { - 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 lsock, 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(lsock, &readset); - nfound = select(lsock + 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); + int i; + struct hostent *he; + struct in_addr *in, ip; + + /* don't resolve if we don't have to */ + if((ip.s_addr = inet_addr(arg)) != INADDR_NONE) { + /* don't add all ip's if we were given a specific one */ + return add_target_ip(arg, &ip); + /* he = gethostbyaddr((char *)in, sizeof(struct in_addr), AF_INET); */ + /* if(!he) return add_target_ip(arg, in); */ + } + else { + errno = 0; + he = gethostbyname(arg); + if(!he) { + errno = 0; + crash("Failed to resolve %s", arg); + return -1; + } } - return(0); /* 0 bytes read, so return it */ -} /* recvfrom_wto() */ + /* possibly add all the IP's as targets */ + for(i = 0; he->h_addr_list[i]; i++) { + in = (struct in_addr *)he->h_addr_list[i]; + add_target_ip(arg, in); + /* this is silly, but it works */ + if(mode == MODE_HOSTCHECK || mode == MODE_ALL) { + printf("mode: %d\n", mode); + continue; + } + break; + } + return 0; +} /* * u = micro * m = milli * s = seconds + * return value is in microseconds */ -int get_threshold(char *str, threshold *th) +static u_int +get_timevar(const char *str) +{ + char p, u, *ptr; + unsigned int len; + u_int i, d; /* integer and decimal, respectively */ + u_int factor = 1000; /* default to milliseconds */ + + if(!str) return 0; + len = strlen(str); + if(!len) return 0; + + /* unit might be given as ms|m (millisec), + * us|u (microsec) or just plain s, for seconds */ + u = p = '\0'; + u = str[len - 1]; + if(len >= 2 && !isdigit((int)str[len - 2])) p = str[len - 2]; + if(p && u == 's') u = p; + else if(!p) p = u; + if(debug > 2) printf("evaluating %s, u: %c, p: %c\n", str, u, p); + + if(u == 'u') factor = 1; /* microseconds */ + else if(u == 'm') factor = 1000; /* milliseconds */ + else if(u == 's') factor = 1000000; /* seconds */ + if(debug > 2) printf("factor is %u\n", factor); + + i = strtoul(str, &ptr, 0); + if(!ptr || *ptr != '.' || strlen(ptr) < 2 || factor == 1) + return i * factor; + + /* time specified in usecs can't have decimal points, so ignore them */ + if(factor == 1) return i; + + d = strtoul(ptr + 1, NULL, 0); + + /* d is decimal, so get rid of excess digits */ + while(d >= factor) d /= 10; + + /* the last parenthesis avoids floating point exceptions. */ + return ((i * factor) + (d * (factor / 10))); +} + +/* not too good at checking errors, but it'll do (main() should barfe on -1) */ +static int +get_threshold(char *str, threshold *th) { - unsigned int i, factor = 0; - char *p = NULL; + char *p = NULL, i = 0; if(!str || !strlen(str) || !th) return -1; - for(i=0; ipl = (unsigned char)strtoul(p+1, NULL, 0); + break; } + i = 1; + p--; } + th->rta = get_timevar(str); + + if(!th->rta) return -1; - /* default to milliseconds */ - if(!factor) factor = 1000; + if(th->rta > MAXTTL * 1000000) th->rta = MAXTTL * 1000000; + if(th->pl > 100) th->pl = 100; - 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; } -void -print_help (void) +unsigned short +icmp_checksum(unsigned short *p, int n) { - print_revision (progname, revision); + register unsigned short cksum; + register long sum = 0; - printf ("Copyright (c) 2004 Andreas Ericsson \n"); - printf (COPYRIGHT, copyright, email); + while(n > 1) { + sum += *p++; + n -= 2; + } - printf (_("This plugin will check hosts sending icmp pings\n\n")); + /* mop up the occasional odd byte */ + if(n == 1) sum += (unsigned char)*p; - print_usage (); + sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */ + sum += (sum >> 16); /* add carry */ + cksum = ~sum; /* ones-complement, trunc to 16 bits */ - printf (_(UT_HELP_VRSN)); - - printf (_("\ - -H, \n\ - Host name argument for servers\n\ - -b \n\ - ping packet size in bytes (default %d)\n\ - -n \n\ - number of pings to send to each target (default %d)\n\ - -r \n\ - number of retries (default %d)\n\ - -t \n\ - timeout value (in msec) (default %d)\n\ - -i \n\ - packet interval (in msec) (default %d)\n\ - -w \n\ - warning threshold pair, given as RTA[ums],PL[%%]\n\ - -c \n\ - critical threshold pair, given as RTA[ums],PL[%%]\n\ - -D \n\ - increase debug output level\n\n"),ping_data_size,count,retry,(timeout / 100),DEFAULT_INTERVAL); - - printf (_(UT_WARN_CRIT)); - - printf (_(UT_TIMEOUT), DEFAULT_SOCKET_TIMEOUT); - - printf (_(UT_VERBOSE)); - -// printf (_("This plugin will check hosts sending icmp pings\n")); - - printf (_(UT_SUPPORT)); + return cksum; } -void -print_usage (void) +/* make core plugin developers happy (silly, really) */ +static void +usage(unsigned char arg, char *msg) { - printf ("\ -Usage: %s -H | [-b ] [-n ]\n\ - [-r ] [-t ] [-i packet interval]\n\ - [-w ] [-c ]\n\ - [-D ] \n", progname); + if(msg) printf("%s: %s\n", progname, msg); + + if(arg == 'V') { + printf("$Id$\n"); + exit(STATE_UNKNOWN); + } + + printf("Usage: %s [options] [-H] host1 host2 hostn\n\n", progname); + + if(arg != 'h') exit(3); + + printf("Where options are any combination of:\n" + " * -H | --host specify a target\n" + " * -w | --warn warning threshold (currently %0.3fms,%u%%)\n" + " * -c | --crit critical threshold (currently %0.3fms,%u%%)\n" + " * -n | --packets number of packets to send (currently %u)\n" + " * -i | --interval max packet interval (currently %0.3fms)\n" + " * -I | --hostint max target interval (currently %0.3fms)\n" + " * -l | --ttl TTL on outgoing packets (currently %u)\n" + " * -t | --timeout timeout value (seconds, currently %u)\n" + " * -b | --bytes icmp packet size (currenly ignored)\n" + " -v | --verbose verbosity++\n" + " -h | --help this cruft\n", + (float)warn.rta / 1000, warn.pl, (float)crit.rta / 1000, crit.pl, + packets, + (float)pkt_interval / 1000, (float)target_interval / 1000, + ttl, timeout); + + puts("\nThe -H switch is optional. Naming a host (or several) to check is not.\n\n" + "Threshold format for -w and -c is 200.25,60% for 200.25 msec RTA and 60%\n" + "packet loss. The default values should work well for most users.\n" + "You can specify different RTA factors using the standardized abbreviations\n" + "us (microseconds), ms (milliseconds, default) or just plain s for seconds.\n\n" + "Threshold format for -d is warn,crit. 12,14 means WARNING if >= 12 hops\n" + "are spent and CRITICAL if >= 14 hops are spent.\n" + "NOTE: Some systems decrease TTL when forming ICMP_ECHOREPLY, others do not.\n\n" + "The -v switch can be specified several times for increased verbosity.\n\n" + "Long options are currently unsupported.\n\n" + "Options marked with * require an argument\n"); + + puts("The latest version of this plugin can be found at http://oss.op5.se/nagios\n" + "or https://devel.op5.se/oss until the day it is included in the official\n" + "plugin distribution.\n"); + + exit(3); } -- cgit v1.2.3