![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: b7c0754)
raw | patch | inline | side by side (parent: b7c0754)
| author | Stanley Hopcroft <stanleyhopcroft@users.sourceforge.net> | |
| Tue, 1 Feb 2005 07:33:13 +0000 (07:33 +0000) | ||
| committer | Stanley Hopcroft <stanleyhopcroft@users.sourceforge.net> | |
| Tue, 1 Feb 2005 07:33:13 +0000 (07:33 +0000) |
git-svn-id: https://nagiosplug.svn.sourceforge.net/svnroot/nagiosplug/nagiosplug/trunk@1118 f882894a-f735-0410-b71e-b25c423dba1c
| plugins/check_icmp.c | patch | blob | history |
diff --git a/plugins/check_icmp.c b/plugins/check_icmp.c
index 4571682498d0227cac6d763ac555987953489d78..2f03552f948538faf0c4ee067520251e8b6c0778 100644 (file)
--- a/plugins/check_icmp.c
+++ b/plugins/check_icmp.c
/*
* $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 <ae@op5.se>
*
- * 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 <sys/time.h>
+#include <sys/types.h>
#include <stdio.h>
-#include <errno.h>
-#include <time.h>
-#include <signal.h>
-
-#include <unistd.h>
-
#include <stdlib.h>
-
-#include <string.h>
+#include <stdarg.h>
+#include <unistd.h>
#include <stddef.h>
-
-#include <sys/types.h>
-#include <sys/time.h>
+#include <errno.h>
+#include <string.h>
+#include <ctype.h>
+#include <netdb.h>
#include <sys/socket.h>
-
-#include <sys/file.h>
-
#include <netinet/in_systm.h>
#include <netinet/in.h>
-
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
-
#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 */
+#include <signal.h>
-/* 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; 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);
- }
+ 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; 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';
+ /* pointer magic slims code by 10 lines. i is bof-stop on stupid libc's */
+ p = &str[strlen(str) - 1];
+ while(p != &str[1]) {
+ if(*p == '%') *p = '\0';
+ else if(*p == ',' && i) {
+ *p = '\0'; /* reset it so get_timevar(str) works nicely later */
+ th->pl = (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 <ae@op5.se>\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 <vhost> | [-b <ping packet size in bytes>] [-n <number of pings>]\n\
- [-r <number of retries>] [-t <timeout>] [-i packet interval]\n\
- [-w <warning threshold>] [-c <critical threshold>]\n\
- [-D <debug>] \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);
}