From 0b6423f9c99d9edf8c96fefd0f6c453859395aa1 Mon Sep 17 00:00:00 2001 From: Holger Weiss Date: Mon, 30 Sep 2013 00:03:24 +0200 Subject: Import Nagios Plugins site Import the Nagios Plugins web site, Cronjobs, infrastructure scripts, and configuration files. --- web/attachments/36739-check_dns.diff | 913 +++++++++++++++++++++++++++++++++++ 1 file changed, 913 insertions(+) create mode 100644 web/attachments/36739-check_dns.diff (limited to 'web/attachments/36739-check_dns.diff') diff --git a/web/attachments/36739-check_dns.diff b/web/attachments/36739-check_dns.diff new file mode 100644 index 0000000..c0eb4c6 --- /dev/null +++ b/web/attachments/36739-check_dns.diff @@ -0,0 +1,913 @@ +--- check_dns_resolver/check_dns_resolver.c Mon Nov 25 18:01:26 2002 ++++ TarZip/nagiosplug-1.3-beta1/plugins/check_dns.c Thu Feb 28 01:42:57 2002 +@@ -1,508 +1,415 @@ +-/* +- * check_dns_resolver is a version of check_dns (for nagios) that +- * talks to the nameservers without using nslookup +- * +- * Author: Roy Marantz (marantz@nbcs.rutgers.edu) +- * no copyrite - do what you want with this. +- * +- * $Id: check_dns_resolver.c,v 1.1.1.1 2002/11/25 23:01:26 marantz Exp $ +- * +- * solaris build instructions +- * cc -o check_dns_resolver check_dns_resolver.c -lresolv -lsocket -lnsl +- * +- */ +- +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#define MAXPACKET 8192 /* BIND maximum packet size */ +- +-void catch_alarm(int ignored) { +- printf("query timed out\n"); +- exit(2); ++/****************************************************************************** ++ * ++ * CHECK_DNS.C ++ * ++ * Program: DNS plugin for Nagios ++ * License: GPL ++ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org) ++ * ++ * Last Modified: $Date: 2002/02/28 06:42:57 $ ++ * ++ * Notes: ++ * - Safe popen added by Karl DeBisschop 9-11-99 ++ * ++ * Command line: CHECK_DNS [dns_server] ++ * ++ * Description: ++ * ++ * This program will use the nslookup program to obtain the IP address ++ * for a given host name. A optional DNS server may be specified. If ++ * no DNS server is specified, the default server(s) for the system ++ * are used. ++ * ++ * Return Values: ++ * OK The DNS query was successful (host IP address was returned). ++ * WARNING The DNS server responded, but could not fulfill the request. ++ * CRITICAL The DNS server is not responding or encountered an error. ++ * ++ * License Information: ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++ * ++ *****************************************************************************/ ++ ++#include "common.h" ++#include "popen.h" ++#include "utils.h" ++ ++int process_arguments (int, char **); ++int call_getopt (int, char **); ++int validate_arguments (void); ++void print_usage (char *); ++void print_help (char *); ++int error_scan (char *); ++ ++#define ADDRESS_LENGTH 256 ++char query_address[ADDRESS_LENGTH] = ""; ++char dns_server[ADDRESS_LENGTH] = ""; ++char ptr_server[ADDRESS_LENGTH] = ""; ++int verbose = FALSE; ++ ++int ++main (int argc, char **argv) ++{ ++ char *command_line = NULL; ++ char input_buffer[MAX_INPUT_BUFFER]; ++ char *output = NULL; ++ char *address = NULL; ++ char *temp_buffer = NULL; ++ int result = STATE_UNKNOWN; ++ ++ /* Set signal handling and alarm */ ++ if (signal (SIGALRM, popen_timeout_alarm_handler) == SIG_ERR) { ++ printf ("Cannot catch SIGALRM"); ++ return STATE_UNKNOWN; ++ } ++ ++ if (process_arguments (argc, argv) != OK) { ++ print_usage (my_basename (argv[0])); ++ return STATE_UNKNOWN; ++ } ++ ++ /* get the command to run */ ++ command_line = ssprintf (command_line, "%s %s %s", NSLOOKUP_COMMAND, ++ query_address, dns_server); ++ ++ alarm (timeout_interval); ++ time (&start_time); ++ ++ if (verbose) ++ printf ("%s\n", command_line); ++ /* run the command */ ++ child_process = spopen (command_line); ++ if (child_process == NULL) { ++ printf ("Could not open pipe: %s\n", command_line); ++ return STATE_UNKNOWN; ++ } ++ ++ child_stderr = fdopen (child_stderr_array[fileno (child_process)], "r"); ++ if (child_stderr == NULL) ++ printf ("Could not open stderr for %s\n", command_line); ++ ++ /* scan stdout */ ++ while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) { ++ ++ if (verbose) ++ printf ("%s\n", input_buffer); ++ ++ if (strstr (input_buffer, ".in-addr.arpa")) { ++ if ((temp_buffer = strstr (input_buffer, "name = "))) ++ address = strscpy (address, temp_buffer + 7); ++ else { ++ output = strscpy (output, "Unknown error (plugin)"); ++ result = STATE_WARNING; ++ } ++ } ++ ++ /* the server is responding, we just got the host name... */ ++ if (strstr (input_buffer, "Name:")) { ++ ++ /* get the host address */ ++ if (!fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) ++ break; ++ ++ if (verbose) ++ printf ("%s\n", input_buffer); ++ ++ if ((temp_buffer = index (input_buffer, ':'))) { ++ address = strscpy (address, temp_buffer + 2); ++ strip (address); ++ result = STATE_OK; ++ } ++ else { ++ output = strscpy (output, "Unknown error (plugin)"); ++ result = STATE_WARNING; ++ } ++ ++ break; ++ } ++ ++ result = error_scan (input_buffer); ++ if (result != STATE_OK) { ++ output = strscpy (output, 1 + index (input_buffer, ':')); ++ break; ++ } ++ ++ } ++ ++ /* scan stderr */ ++ while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) { ++ if (error_scan (input_buffer) != STATE_OK) { ++ result = max (result, error_scan (input_buffer)); ++ output = strscpy (output, 1 + index (input_buffer, ':')); ++ } ++ } ++ ++ /* close stderr */ ++ (void) fclose (child_stderr); ++ ++ /* close stdout */ ++ if (spclose (child_process)) { ++ result = max (result, STATE_WARNING); ++ if (!strcmp (output, "")) ++ output = strscpy (output, "nslookup returned error status"); ++ } ++ ++ (void) time (&end_time); ++ ++ if (result == STATE_OK) ++ printf ("DNS ok - %d seconds response time, Address(es) is/are %s\n", ++ (int) (end_time - start_time), address); ++ else if (result == STATE_WARNING) ++ printf ("DNS WARNING - %s\n", ++ !strcmp (output, "") ? " Probably a non-existent host/domain" : output); ++ else if (result == STATE_CRITICAL) ++ printf ("DNS CRITICAL - %s\n", ++ !strcmp (output, "") ? " Probably a non-existent host/domain" : output); ++ else ++ printf ("DNS problem - %s\n", ++ !strcmp (output, "") ? " Probably a non-existent host/domain" : output); ++ ++ return result; + } + +-typedef union { +- HEADER hdr; +- u_char buf[MAXPACKET]; +-} querybuf; +- +-static struct hostent * +-getanswer(const querybuf *answer, +- int anslen, +- const char *qname, +- int qtype); +- +-int debugging = 0; +- +-int main (int argc, char **argv) { +- int n; +- time_t start_time, end_time; +- querybuf answer; +- struct hostent *hentry; +- register char **h; +- +- int norecurse = 0; +- int timeout = 30; +- char *host = NULL; +- char *server = NULL; +- +-/* if (process_arguments (argc, argv) != OK) { +- print_usage (my_basename (argv[0])); +- exit(1); +- } +-*/ +- +- { +- int c; +- int errflg = 0; +- int showversion = 0; +- char *pgm = argv[0]; +- extern char *optarg; +- extern int optind; +- +- while ((c = getopt(argc, argv, "dhrt:s:H:V")) != EOF) +- switch (c) { +- case 't': timeout = atoi(optarg); break; +- case 's': server = optarg; break; +- case 'H': host = optarg; break; +- case 'r': norecurse = 1; break; +- case 'd': debugging++; break; +- case 'V': showversion++; break; +- case 'h': +- case '?': errflg++; +- } +- if (host == NULL || errflg || optind != argc) { +- fprintf(stderr, "usage: %s %s\n%s %d\n%s\n%s\n%s\n%s\n%s\n", +- pgm, +- "[-d] [-V] [-r] [-t timeout] [-s server] -H host", +- "where: timeout is time (in seconds) to wait for dns server, default", +- timeout, +- " host is the fully qualified hostname to ask address of", +- " server is the IP address or hostname of the nameserver to ask, default from /etc/resolv.conf", +- " -r turns off recursive resolver lookups", +- " -d turns on resolver debugging", +- " -V prints program version" +- ); +- exit (2); +- } +- if (showversion) { +- printf("%s version $Revision: 1.1.1.1 $\n", pgm); +- exit(0); +- } +- } +- +- +- /* Set signal handling and alarm */ +- if (signal (SIGALRM, catch_alarm) == SIG_ERR) { +- printf("DNS problem - Cannot set ALRM handler"); +- exit(33); +- } +- +- /* process /etc/resolv.conf */ +- if (res_init() == -1) { +- printf("DNS problem - Cannot call res_init \n"); +- exit(33); +- } +- +- if (debugging) { +- _res.options |= RES_DEBUG; /* turn on resolver debugging */ +- } +- +- if (norecurse) { +- _res.options &= ~RES_RECURSE; /* turn off recursive lookup */ +- } +- +- if (server) { +- struct hostent *hp; +- static struct sockaddr_in *a; +- in_addr_t s; +- +- /* override the nameservers from resolv.conf */ +- _res.nscount = 1; +- a = &_res.nsaddr_list[0]; +- /* a->sin_port = ... leave the port alone */ +- +- hp = gethostbyname(server); +- if (hp && hp->h_addr_list[0] != NULL) { +- a->sin_family = hp->h_addrtype; +- bcopy(hp->h_addr_list[0], &a->sin_addr, hp->h_length); +- } else { +- /* assume a dotted quad address */ +- s = inet_addr(server); +- if (s == -1) { +- printf("DNS problem - Cannot resolve server %s\n", server); +- exit(33); +- } +- a->sin_family = AF_INET; +- bcopy(&s, &a->sin_addr, sizeof(in_addr_t)); +- } +- } +- +- time (&start_time); +- alarm (timeout); +- +- n = res_query(host, C_IN, T_A, answer.buf, sizeof(answer)); +- +- alarm(0); /* cancel pending alarm */ +- (void) time (&end_time); +- +- if (n < 0) { +- printf("DNS CRITICAL - query failed: %d\n", n); +- exit(n); +- } +- +- hentry = getanswer(&answer, n, host, T_A); +- if (hentry == NULL) { +- printf("DNS WARNING - no answer\n"); +- exit(2); +- } +- printf("DNS ok - %d seconds response time, Address(es) is/are", +- (int) (end_time - start_time)); +- for(h=hentry->h_addr_list; *h; h++) { +- struct in_addr a; +- bcopy(*h, &a, hentry->h_length); +- printf(" %s", inet_ntoa(a)); +- } +- printf("\n"); ++int ++error_scan (char *input_buffer) ++{ ++ ++ /* the DNS lookup timed out */ ++ if (strstr (input_buffer, ++ "Note: nslookup is deprecated and may be removed from future releases.") ++ || strstr (input_buffer, ++ "Consider using the `dig' or `host' programs instead. Run nslookup with") ++ || strstr (input_buffer, ++ "the `-sil[ent]' option to prevent this message from appearing.")) ++ return STATE_OK; ++ ++ /* the DNS lookup timed out */ ++ else if (strstr (input_buffer, "Timed out")) ++ return STATE_WARNING; ++ ++ /* DNS server is not running... */ ++ else if (strstr (input_buffer, "No response from server")) ++ return STATE_CRITICAL; ++ ++ /* Host name is valid, but server doesn't have records... */ ++ else if (strstr (input_buffer, "No records")) ++ return STATE_WARNING; ++ ++ /* Host or domain name does not exist */ ++ else if (strstr (input_buffer, "Non-existent")) ++ return STATE_CRITICAL; ++ else if (strstr (input_buffer, "** server can't find")) ++ return STATE_CRITICAL; ++ else if(strstr(input_buffer,"NXDOMAIN")) /* 9.x */ ++ return STATE_CRITICAL; ++ ++ /* Connection was refused */ ++ else if (strstr (input_buffer, "Connection refused")) ++ return STATE_CRITICAL; ++ ++ /* Network is unreachable */ ++ else if (strstr (input_buffer, "Network is unreachable")) ++ return STATE_CRITICAL; ++ ++ /* Internal server failure */ ++ else if (strstr (input_buffer, "Server failure")) ++ return STATE_CRITICAL; ++ ++ /* DNS server refused to service request */ ++ else if (strstr (input_buffer, "Refused")) ++ return STATE_CRITICAL; ++ ++ /* Request error */ ++ else if (strstr (input_buffer, "Format error")) ++ return STATE_WARNING; ++ ++ else ++ return STATE_OK; + +- exit(0); + } + ++/* process command-line arguments */ ++int ++process_arguments (int argc, char **argv) ++{ ++ int c; ++ ++ if (argc < 2) ++ return ERROR; + ++ for (c = 1; c < argc; c++) ++ if (strcmp ("-to", argv[c]) == 0) ++ strcpy (argv[c], "-t"); ++ ++ c = 0; ++ while (c += (call_getopt (argc - c, &argv[c]))) { ++ if (argc <= c) ++ break; ++ if (query_address[0] == 0) { ++ if (is_host (argv[c]) == FALSE) { ++ printf ("Invalid name/address: %s\n\n", argv[c]); ++ return ERROR; ++ } ++ if (strlen (argv[c]) >= ADDRESS_LENGTH) ++ terminate (STATE_UNKNOWN, "Input buffer overflow\n"); ++ strcpy (query_address, argv[c]); ++ } ++ else if (dns_server[0] == 0) { ++ if (is_host (argv[c]) == FALSE) { ++ printf ("Invalid name/address: %s\n\n", argv[c]); ++ return ERROR; ++ } ++ if (strlen (argv[c]) >= ADDRESS_LENGTH) ++ terminate (STATE_UNKNOWN, "Input buffer overflow\n"); ++ strcpy (dns_server, argv[c]); ++ } ++ } + +-/* stripped down getanswer */ ++ return validate_arguments (); ++ ++} + +-/* +- * Copyright (c) 1985, 1988, 1993 +- * The Regents of the University of California. All rights reserved. +- * +- * Redistribution and use in source and binary forms, with or without +- * modification, are permitted provided that the following conditions +- * are met: +- * 1. Redistributions of source code must retain the above copyright +- * notice, this list of conditions and the following disclaimer. +- * 2. Redistributions in binary form must reproduce the above copyright +- * notice, this list of conditions and the following disclaimer in the +- * documentation and/or other materials provided with the distribution. +- * 3. All advertising materials mentioning features or use of this software +- * must display the following acknowledgement: +- * This product includes software developed by the University of +- * California, Berkeley and its contributors. +- * 4. Neither the name of the University nor the names of its contributors +- * may be used to endorse or promote products derived from this software +- * without specific prior written permission. +- * +- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +- * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +- * SUCH DAMAGE. +- * - +- * Portions Copyright (c) 1993 by Digital Equipment Corporation. +- * +- * Permission to use, copy, modify, and distribute this software for any +- * purpose with or without fee is hereby granted, provided that the above +- * copyright notice and this permission notice appear in all copies, and that +- * the name of Digital Equipment Corporation not be used in advertising or +- * publicity pertaining to distribution of the document or software without +- * specific, written prior permission. +- * +- * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL +- * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES +- * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT +- * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL +- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR +- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS +- * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +- * SOFTWARE. +- * - +- * --Copyright-- +- */ +- +-static const char AskedForGot[] = +- "gethostby*.getanswer: asked for \"%s\", got \"%s\""; +-static char *h_addr_ptrs[MAXADDRS + 1]; +- +-static struct hostent host; +-static char *host_aliases[MAXALIASES]; +-static char hostbuf[8*1024]; +-static u_char host_addr[16]; /* IPv4 or IPv6 */ +-static FILE *hostf = NULL; +-static int stayopen = 0; +- +- +-typedef union { +- int32_t al; +- char ac; +-} align; +- +-#define dprintf printf +- +-static struct hostent * +-getanswer(const querybuf *answer, +- int anslen, +- const char *qname, +- int qtype) ++int ++call_getopt (int argc, char **argv) + { +- register const HEADER *hp; +- register const u_char *cp; +- register int n; +- const u_char *eom; +- char *bp, **ap, **hap; +- int type, class, buflen, ancount, qdcount; +- int haveanswer, had_error; +- int toobig = 0; +- char tbuf[MAXDNAME]; +- const char *tname; +- int (*name_ok) __P((const char *)); +- +- tname = qname; +- host.h_name = NULL; +- host.h_length = INADDRSZ; +- host.h_addrtype = AF_INET; +- +- eom = answer->buf + anslen; +- switch (qtype) { +- case T_A: +- case T_AAAA: +- name_ok = res_hnok; +- break; +- case T_PTR: +- name_ok = res_dnok; +- break; +- default: +- return (NULL); /* XXX should be abort(); */ +- } +- /* +- * find first satisfactory answer +- */ +- hp = &answer->hdr; +- ancount = ntohs(hp->ancount); +- qdcount = ntohs(hp->qdcount); +- bp = hostbuf; +- buflen = sizeof hostbuf; +- cp = answer->buf + HFIXEDSZ; +- if (qdcount != 1) { +- h_errno = NO_RECOVERY; +- return (NULL); +- } +- n = dn_expand(answer->buf, eom, cp, bp, buflen); +- if ((n < 0) || !(*name_ok)(bp)) { +- h_errno = NO_RECOVERY; +- return (NULL); +- } +- cp += n + QFIXEDSZ; +- if (qtype == T_A || qtype == T_AAAA) { +- /* res_send() has already verified that the query name is the +- * same as the one we sent; this just gets the expanded name +- * (i.e., with the succeeding search-domain tacked on). +- */ +- n = strlen(bp) + 1; /* for the \0 */ +- host.h_name = bp; +- bp += n; +- buflen -= n; +- /* The qname can be abbreviated, but h_name is now absolute. */ +- qname = host.h_name; +- } +- ap = host_aliases; +- *ap = NULL; +- host.h_aliases = host_aliases; +- hap = h_addr_ptrs; +- *hap = NULL; +- host.h_addr_list = h_addr_ptrs; +- haveanswer = 0; +- had_error = 0; +- while (ancount-- > 0 && cp < eom && !had_error) { +- n = dn_expand(answer->buf, eom, cp, bp, buflen); +- if ((n < 0) || !(*name_ok)(bp)) { +- had_error++; +- continue; +- } +- +- cp += n; /* name */ +- type = _getshort(cp); +- cp += INT16SZ; /* type */ +- class = _getshort(cp); +- cp += INT16SZ + INT32SZ; /* class, TTL */ +- n = _getshort(cp); +- cp += INT16SZ; /* len */ +- if (class != C_IN) { +- /* XXX - debug? syslog? */ +- cp += n; +- continue; /* XXX - had_error++ ? */ +- } +- if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) { +- if (ap >= &host_aliases[MAXALIASES-1]) +- continue; +- n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf); +- if ((n < 0) || !(*name_ok)(tbuf)) { +- had_error++; +- continue; +- } +- cp += n; +- /* Store alias. */ +- *ap++ = bp; +- n = strlen(bp) + 1; /* for the \0 */ +- bp += n; +- buflen -= n; +- /* Get canonical name. */ +- n = strlen(tbuf) + 1; /* for the \0 */ +- if (n > buflen) { +- had_error++; +- continue; +- } +- strcpy(bp, tbuf); +- host.h_name = bp; +- bp += n; +- buflen -= n; +- continue; +- } +- +- if (qtype == T_PTR && type == T_CNAME) { +- n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf); +- if ((n < 0) || !res_hnok(tbuf)) { +- had_error++; +- continue; +- } +- cp += n; +- /* Get canonical name. */ +- n = strlen(tbuf) + 1; /* for the \0 */ +- if (n > buflen) { +- had_error++; +- continue; +- } +- strcpy(bp, tbuf); +- tname = bp; +- bp += n; +- buflen -= n; +- continue; +- } +- if (type != qtype) { +- dprintf("gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"", +- qname, p_class(C_IN), p_type(qtype), +- p_type(type)); +- cp += n; +- continue; /* XXX - had_error++ ? */ +- } +- switch (type) { +- case T_PTR: +- if (strcasecmp(tname, bp) != 0) { +- dprintf(AskedForGot, qname, bp); +- cp += n; +- continue; /* XXX - had_error++ ? */ +- } +- n = dn_expand(answer->buf, eom, cp, bp, buflen); +- if ((n < 0) || !res_hnok(bp)) { +- had_error++; +- break; +- } +-#if MULTI_PTRS_ARE_ALIASES +- cp += n; +- if (!haveanswer) +- host.h_name = bp; +- else if (ap < &host_aliases[MAXALIASES-1]) +- *ap++ = bp; +- else +- n = -1; +- if (n != -1) { +- n = strlen(bp) + 1; /* for the \0 */ +- bp += n; +- buflen -= n; +- } +- break; ++ int c, i = 1; + ++#ifdef HAVE_GETOPT_H ++ int opt_index = 0; ++ static struct option long_opts[] = { ++ {"help", no_argument, 0, 'h'}, ++ {"version", no_argument, 0, 'V'}, ++ {"verbose", no_argument, 0, 'v'}, ++ {"timeout", required_argument, 0, 't'}, ++ {"hostname", required_argument, 0, 'H'}, ++ {"server", required_argument, 0, 's'}, ++ {"reverse-server", required_argument, 0, 'r'}, ++ {0, 0, 0, 0} ++ }; ++#endif ++ ++ ++ while (1) { ++#ifdef HAVE_GETOPT_H ++ c = getopt_long (argc, argv, "+?hVvt:H:s:r:", long_opts, &opt_index); + #else +- host.h_name = bp; +- h_errno = NETDB_SUCCESS; +- return (&host); ++ c = getopt (argc, argv, "+?hVvt:H:s:r:"); + #endif +- case T_A: +- case T_AAAA: +- if (strcasecmp(host.h_name, bp) != 0) { +- dprintf(AskedForGot, host.h_name, bp); +- cp += n; +- continue; /* XXX - had_error++ ? */ +- } +- if (n != host.h_length) { +- cp += n; +- continue; +- } +- if (!haveanswer) { +- register int nn; +- +- host.h_name = bp; +- nn = strlen(bp) + 1; /* for the \0 */ +- bp += nn; +- buflen -= nn; +- } +- +- bp += sizeof(align) - ((u_long)bp % sizeof(align)); +- +- if (bp + n >= &hostbuf[sizeof hostbuf]) { +- dprintf("size (%d) too big\n", n); +- had_error++; +- continue; +- } +- if (hap >= &h_addr_ptrs[MAXADDRS-1]) { +- if (!toobig++) +- dprintf("Too many addresses (%d)\n", +- MAXADDRS); +- cp += n; +- continue; +- } +- bcopy(cp, *hap++ = bp, n); +- bp += n; +- buflen -= n; +- cp += n; +- break; +- default: +- abort(); +- } +- if (!had_error) +- haveanswer++; +- } +- if (haveanswer) { +- *ap = NULL; +- *hap = NULL; +-# if defined(RESOLVSORT) +- /* +- * Note: we sort even if host can take only one address +- * in its return structures - should give it the "best" +- * address in that case, not some random one +- */ +- if (_res.nsort && haveanswer > 1 && qtype == T_A) +- addrsort(h_addr_ptrs, haveanswer); +-# endif /*RESOLVSORT*/ +- if (!host.h_name) { +- n = strlen(qname) + 1; /* for the \0 */ +- if (n > buflen) +- goto try_again; +- strcpy(bp, qname); +- host.h_name = bp; +- bp += n; +- buflen -= n; +- } +- h_errno = NETDB_SUCCESS; +- return (&host); +- } +- try_again: +- h_errno = TRY_AGAIN; +- return (NULL); ++ ++ if (c == -1 || c == EOF) ++ break; ++ ++ i++; ++ switch (c) { ++ case 't': ++ case 'H': ++ case 's': ++ case 'r': ++ i++; ++ } ++ ++ switch (c) { ++ case '?': /* args not parsable */ ++ printf ("%s: Unknown argument: %s\n\n", my_basename (argv[0]), optarg); ++ print_usage (my_basename (argv[0])); ++ exit (STATE_UNKNOWN); ++ case 'h': /* help */ ++ print_help (my_basename (argv[0])); ++ exit (STATE_OK); ++ case 'V': /* version */ ++ print_revision (my_basename (argv[0]), "$Revision: 1.1.1.1 $"); ++ exit (STATE_OK); ++ case 'v': /* version */ ++ verbose = TRUE; ++ break; ++ case 't': /* timeout period */ ++ timeout_interval = atoi (optarg); ++ break; ++ case 'H': /* hostname */ ++ if (is_host (optarg) == FALSE) { ++ printf ("Invalid host name/address\n\n"); ++ print_usage (my_basename (argv[0])); ++ exit (STATE_UNKNOWN); ++ } ++ if (strlen (optarg) >= ADDRESS_LENGTH) ++ terminate (STATE_UNKNOWN, "Input buffer overflow\n"); ++ strcpy (query_address, optarg); ++ break; ++ case 's': /* server name */ ++ if (is_host (optarg) == FALSE) { ++ printf ("Invalid server name/address\n\n"); ++ print_usage (my_basename (argv[0])); ++ exit (STATE_UNKNOWN); ++ } ++ if (strlen (optarg) >= ADDRESS_LENGTH) ++ terminate (STATE_UNKNOWN, "Input buffer overflow\n"); ++ strcpy (dns_server, optarg); ++ break; ++ case 'r': /* reverse server name */ ++ if (is_host (optarg) == FALSE) { ++ printf ("Invalid host name/address\n\n"); ++ print_usage (my_basename (argv[0])); ++ exit (STATE_UNKNOWN); ++ } ++ if (strlen (optarg) >= ADDRESS_LENGTH) ++ terminate (STATE_UNKNOWN, "Input buffer overflow\n"); ++ strcpy (ptr_server, optarg); ++ break; ++ } ++ } ++ return i; ++} ++ ++int ++validate_arguments () ++{ ++ if (query_address[0] == 0) ++ return ERROR; ++ else ++ return OK; ++} ++ ++void ++print_usage (char *cmd) ++{ ++ printf ("Usage: %s -H host [-s server] [-t timeout]\n" " %s --help\n" ++ " %s --version\n", cmd, cmd, cmd); ++} ++ ++void ++print_help (char *cmd) ++{ ++ print_revision (cmd, "$Revision: 1.1.1.1 $"); ++ printf ("Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)\n\n"); ++ print_usage (cmd); ++ printf ("\n"); ++ printf ++ ("-H, --hostname=HOST\n" ++ " The name or address you want to query\n" ++ "-s, --server=HOST\n" ++ " Optional DNS server you want to use for the lookup\n" ++ "-t, --timeout=INTEGER\n" ++ " Seconds before connection times out (default: %d)\n" ++ "-h, --help\n" ++ " Print detailed help\n" ++ "-V, --version\n" ++ " Print version numbers and license information\n" ++ "\n" ++ "This plugin uses the nslookup program to obtain the IP address\n" ++ "for the given host/domain query. A optional DNS server to use may\n" ++ "be specified. If no DNS server is specified, the default server(s)\n" ++ "specified in /etc/resolv.conf will be used.\n", DEFAULT_SOCKET_TIMEOUT); + } -- cgit v1.2.3-74-g34f1