Initial revision

git-svn-id: https://nagiosplug.svn.sourceforge.net/svnroot/nagiosplug/nagiosplug/trunk@2 f882894a-f735-0410-b71e-b25c423dba1c

83 files changed, 20385 insertions, 0 deletions

diff --git a/plugins/.cvsignore b/plugins/.cvsignore
new file mode 100644
index 00000000..58f14fe8
--- /dev/null
+++ b/plugins/.cvsignore
@@ -0,0 +1,43 @@
+check_disk
+check_dns
+check_dummy
+check_ftp
+check_http
+check_imap
+check_load
+check_mrtg
+check_mrtgtraf
+check_nagios
+check_nntp
+check_nwstat
+check_overcr
+check_ping
+check_pop
+check_procs
+check_real
+check_reply
+check_smtp
+check_ssh
+check_tcp
+check_time
+check_udp
+check_ups
+check_users
+check_vsz
+check_by_ssh
+urlize
+check_pgsql
+check_radius
+check_ldap
+check_mysql
+check_netsaint
+check_hpjd
+check_snmp
+check_by_ssh
+check_swap
+stamp-h*
+*.h
+Makefile
+Makefile.in
+config.h.in
+.deps
diff --git a/plugins/Makefile.am b/plugins/Makefile.am
new file mode 100644
index 00000000..64b14bfb
--- /dev/null
+++ b/plugins/Makefile.am
@@ -0,0 +1,139 @@
+## Process this file with automake to produce Makefile.in
+
+VPATH = $(top_srcdir) $(top_srcdir)/plugins $(top_srcdir)/plugins/t
+
+INCLUDES = @LDAPINCLUDE@ @PGINCLUDE@ @SSLINCLUDE@ 
+
+libexec_PROGRAMS = check_disk check_dummy check_ftp check_http \
+                check_imap check_load check_mrtg check_mrtgtraf \
+                check_nntp check_nwstat check_overcr \
+                check_ping check_pop check_procs check_real \
+                check_smtp check_ssh check_tcp check_time check_udp \
+                check_ups check_users check_vsz urlize \
+                @EXTRAS@
+
+EXTRA_PROGRAMS = check_mysql check_radius check_pgsql check_snmp check_hpjd \
+                check_swap check_fping check_ldap check_game check_dig \
+                check_nagios check_by_ssh check_dns check_nt
+
+EXTRA_DIST = t utils.c netutils.c popen.c getopt.h getopt.c getopt1.c snprintf.c
+
+PLUGINHDRS = common.h config.h
+
+BASEOBJS = utils.o
+NETOBJS = netutils.o $(BASEOBJS)
+NETLIBS = $(NETOBJS) $(SOCKETLIBS)
+
+TESTS_ENVIRONMENT = perl -I $(top_builddir) -I $(top_srcdir)
+
+TESTS = @PLUGIN_TEST@
+
+test:
+        perl -I $(top_builddir) -I $(top_srcdir) ../test.pl
+
+AM_INSTALL_PROGRAM_FLAGS = @INSTALL_OPTS@
+
+##############################################################################
+# the actual targets
+
+check_dig_LDADD = $(BASEOBJS) popen.o
+check_disk_LDADD = $(BASEOBJS) popen.o
+check_dns_LDADD = $(BASEOBJS) popen.o
+check_dummy_LDADD = $(BASEOBJS)
+check_fping_LDADD = $(BASEOBJS) popen.o
+check_ftp_LDADD = $(NETLIBS)
+check_game_LDADD = $(BASEOBJS)
+check_http_LDADD = $(NETLIBS) $(SSLLIBS)
+check_hpjd_LDADD = $(BASEOBJS) popen.o
+check_imap_LDADD = $(NETLIBS)
+check_ldap_LDADD = $(NETLIBS) $(LDAPLIBS)
+check_load_LDADD = $(BASEOBJS) popen.o
+check_mrtg_LDADD = $(BASEOBJS)
+check_mrtgtraf_LDADD = $(BASEOBJS)
+check_mysql_LDADD = $(BASEOBJS) $(MYSQLLIBS)
+check_nagios_LDADD = $(BASEOBJS) popen.o
+check_nntp_LDADD = $(NETLIBS)
+check_nt_LDADD = $(NETLIBS)
+check_nwstat_LDADD = $(NETLIBS)
+check_overcr_LDADD = $(NETLIBS)
+check_pgsql_LDADD = $(BASEOBJS) $(PGLIBS)
+check_ping_LDADD = $(BASEOBJS) popen.o
+check_pop_LDADD = $(NETLIBS)
+check_procs_LDADD = $(BASEOBJS) popen.o
+check_radius_LDADD = $(BASEOBJS) $(RADIUSLIBS)
+check_real_LDADD = $(NETLIBS)
+check_snmp_LDADD = $(BASEOBJS) popen.o
+check_smtp_LDADD = $(NETLIBS)
+check_ssh_LDADD = $(NETLIBS)
+check_swap_LDADD = $(BASEOBJS) popen.o
+check_tcp_LDADD = $(NETLIBS) $(SSLLIBS)
+check_time_LDADD = $(NETLIBS)
+check_udp_LDADD = $(NETLIBS)
+check_ups_LDADD = $(NETLIBS)
+check_users_LDADD = $(BASEOBJS) popen.o
+check_vsz_LDADD = $(BASEOBJS) popen.o
+check_by_ssh_LDADD = $(BASEOBJS) popen.o
+urlize_LDADD = $(BASEOBJS) popen.o
+
+check_dig_DEPENDENCIES = check_dig.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_disk_DEPENDENCIES = check_disk.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_dns_DEPENDENCIES = check_dns.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_dummy_DEPENDENCIES = check_dummy.c  $(DEPLIBS)
+check_fping_DEPENDENCIES = check_fping.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_ftp_DEPENDENCIES = check_ftp.c $(NETOBJS) $(DEPLIBS)
+check_game_DEPENDENCIES = check_game.c  $(DEPLIBS)
+check_http_DEPENDENCIES = check_http.c $(NETOBJS) $(DEPLIBS)
+check_hpjd_DEPENDENCIES = check_hpjd.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_imap_DEPENDENCIES = check_imap.c $(NETOBJS) $(DEPLIBS)
+check_ldap_DEPENDENCIES = check_ldap.c $(NETOBJS) $(DEPLIBS)
+check_load_DEPENDENCIES = check_load.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_mrtg_DEPENDENCIES = check_mrtg.c  $(DEPLIBS)
+check_mrtgtraf_DEPENDENCIES = check_mrtgtraf.c  $(DEPLIBS)
+check_mysql_DEPENDENCIES = check_mysql.c  $(DEPLIBS)
+check_nagios_DEPENDENCIES = check_nagios.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_nntp_DEPENDENCIES = check_nntp.c $(NETOBJS) $(DEPLIBS)
+check_nt_DEPENDENCIES = check_nt.c $(NETOBJS) $(DEPLIBS)
+check_nwstat_DEPENDENCIES = check_nwstat.c $(NETOBJS) $(DEPLIBS)
+check_overcr_DEPENDENCIES = check_overcr.c $(NETOBJS) $(DEPLIBS)
+check_pgsql_DEPENDENCIES = check_pgsql.c  $(DEPLIBS)
+check_ping_DEPENDENCIES = check_ping.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_pop_DEPENDENCIES = check_pop.c $(NETOBJS) $(DEPLIBS)
+check_procs_DEPENDENCIES = check_procs.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_radius_DEPENDENCIES = check_radius.c  $(DEPLIBS)
+check_real_DEPENDENCIES = check_real.c $(NETOBJS) $(DEPLIBS)
+check_snmp_DEPENDENCIES = check_snmp.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_smtp_DEPENDENCIES = check_smtp.c $(NETOBJS) $(DEPLIBS)
+check_ssh_DEPENDENCIES = check_ssh.c $(NETOBJS) $(DEPLIBS)
+check_swap_DEPENDENCIES = check_swap.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_tcp_DEPENDENCIES = check_tcp.c $(NETOBJS) $(DEPLIBS)
+check_time_DEPENDENCIES = check_time.c $(NETOBJS) $(DEPLIBS)
+check_udp_DEPENDENCIES = check_udp.c $(NETOBJS) $(DEPLIBS)
+check_ups_DEPENDENCIES = check_ups.c $(NETOBJS) $(DEPLIBS)
+check_users_DEPENDENCIES = check_users.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_vsz_DEPENDENCIES = check_vsz.c $(BASEOBJS) popen.o $(DEPLIBS)
+check_by_ssh_DEPENDENCIES = check_by_ssh.c $(BASEOBJS) popen.o $(DEPLIBS)
+urlize_DEPENDENCIES = urlize.c $(BASEOBJS) popen.o $(DEPLIBS)
+
+##############################################################################
+# secondary dependencies
+
+popen.o: popen.c popen.h $(PLUGINHDRS)
+
+utils.o: utils.c utils.h $(PLUGINHDRS)
+
+netutils.o: netutils.c netutils.h $(PLUGINHDRS)
+
+getopt.o: getopt.c getopt.h
+        $(COMPILE) -c $(srcdir)/getopt.c -o $@
+
+getopt1.o: getopt1.c getopt.h
+        $(COMPILE) -c $(srcdir)/getopt1.c -o $@
+
+snprintf.o: snprintf.c
+        $(COMPILE) @NEED_VA_LIST@ -c $? -o $@
+
+libgetopt.a: getopt.o getopt1.o
+        $(AR) -r $@ getopt.o getopt1.o
+
+libsnprintf.a: snprintf.o
+        $(AR) -r $@ snprintf.o
diff --git a/plugins/check_by_ssh.c b/plugins/check_by_ssh.c
new file mode 100644
index 00000000..a81b333f
--- /dev/null
+++ b/plugins/check_by_ssh.c
@@ -0,0 +1,412 @@
+/******************************************************************************
+ *
+ * This file is part of the Nagios Plugins.
+ *
+ * Copyright (c) 1999, 2000, 2001 Karl DeBisschop <karl@debisschop.net>
+ *
+ * The Nagios Plugins are free software; you can redistribute them
+ * and/or modify them 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.
+ *
+ * $Id$
+ *
+ *****************************************************************************/
+ 
+#define PROGRAM check_by_ssh
+#define DESCRIPTION "Run checks on a remote system using ssh, wrapping the proper timeout around the ssh invocation."
+#define AUTHOR "Karl DeBisschop"
+#define EMAIL "karl@debisschop.net"
+#define COPYRIGHTDATE "1999, 2000, 2001"
+
+#include "config.h"
+#include "common.h"
+#include "popen.h"
+#include "utils.h"
+#include <time.h>
+
+#define PROGNAME "check_by_ssh"
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+void print_help (char *command_name);
+void print_usage (void);
+
+
+int commands;
+char *remotecmd = NULL;
+char *comm = NULL;
+char *hostname = NULL;
+char *outputfile = NULL;
+char *host_shortname = NULL;
+char *servicelist = NULL;
+int passive = FALSE;
+int verbose = FALSE;
+
+
+int
+main (int argc, char **argv)
+{
+
+        char input_buffer[MAX_INPUT_BUFFER] = "";
+        char *result_text = NULL;
+        char *status_text;
+        char *output = NULL;
+        char *eol = NULL;
+        char *srvc_desc = NULL;
+        int cresult;
+        int result = STATE_UNKNOWN;
+        time_t local_time;
+        FILE *fp = NULL;
+
+
+        /* process arguments */
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments\n");
+
+
+        /* Set signal handling and alarm timeout */
+        if (signal (SIGALRM, popen_timeout_alarm_handler) == SIG_ERR) {
+                printf ("Cannot catch SIGALRM");
+                return STATE_UNKNOWN;
+        }
+        alarm (timeout_interval);
+
+
+        /* run the command */
+
+        if (verbose)
+                printf ("%s\n", comm);
+
+        child_process = spopen (comm);
+
+        if (child_process == NULL) {
+                printf ("Unable to open pipe: %s", comm);
+                return STATE_UNKNOWN;
+        }
+
+
+        /* open STDERR  for spopen */
+        child_stderr = fdopen (child_stderr_array[fileno (child_process)], "r");
+        if (child_stderr == NULL) {
+                printf ("Could not open stderr for %s\n", SSH_COMMAND);
+        }
+
+
+        /* get results from remote command */
+        result_text = realloc (result_text, 1);
+        result_text[0] = 0;
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process))
+                result_text = strscat (result_text, input_buffer);
+
+
+        /* WARNING if output found on stderr */
+        if (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) {
+                printf ("%s\n", input_buffer);
+                return STATE_WARNING;
+        }
+        (void) fclose (child_stderr);
+
+
+        /* close the pipe */
+        result = spclose (child_process);
+
+
+        /* process output */
+        if (passive) {
+
+                if (!(fp = fopen (outputfile, "a"))) {
+                        printf ("SSH WARNING: could not open %s\n", outputfile);
+                        exit (STATE_UNKNOWN);
+                }
+
+                time (&local_time);
+                srvc_desc = strtok (servicelist, ":");
+                while (result_text != NULL) {
+                        status_text = (strstr (result_text, "STATUS CODE: "));
+                        if (status_text == NULL) {
+                                printf ("%s", result_text);
+                                return result;
+                        }
+                        output = result_text;
+                        result_text = strnl (status_text);
+                        eol = strpbrk (output, "\r\n");
+                        if (eol != NULL)
+                                eol[0] = 0;
+                        if (srvc_desc && status_text
+                                        && sscanf (status_text, "STATUS CODE: %d", &cresult) == 1) {
+                                fprintf (fp, "%d PROCESS_SERVICE_CHECK_RESULT;%s;%s;%d;%s\n",
+                                                                 (int) local_time, host_shortname, srvc_desc, cresult,
+                                                                 output);
+                                srvc_desc = strtok (NULL, ":");
+                        }
+                }
+
+        }
+
+        /* print the first line from the remote command */
+        else {
+                eol = strpbrk (result_text, "\r\n");
+                if (eol)
+                        eol[0] = 0;
+                printf ("%s\n", result_text);
+
+        }
+
+
+        /* return error status from remote command */
+        return result;
+}
+
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+        if (argc < 2)
+                return ERROR;
+
+        remotecmd = realloc (remotecmd, 1);
+        remotecmd[0] = 0;
+
+        for (c = 1; c < argc; c++)
+                if (strcmp ("-to", argv[c]) == 0)
+                        strcpy (argv[c], "-t");
+
+        comm = strscpy (comm, SSH_COMMAND);
+
+        c = 0;
+        while (c += (call_getopt (argc - c, &argv[c]))) {
+
+                if (argc <= c)
+                        break;
+
+                if (hostname == NULL) {
+                        if (!is_host (argv[c]))
+                                terminate (STATE_UNKNOWN, "%s: Invalid host name %s\n", PROGNAME,
+                                                                         argv[c]);
+                        hostname = argv[c];
+                }
+                else if (remotecmd == NULL) {
+                        remotecmd = strscpy (remotecmd, argv[c++]);
+                        for (; c < argc; c++)
+                                remotecmd = ssprintf (remotecmd, "%s %s", remotecmd, argv[c]);
+                }
+
+        }
+
+        if (commands > 1)
+                remotecmd = strscat (remotecmd, ";echo STATUS CODE: $?;");
+
+        if (remotecmd == NULL || strlen (remotecmd) <= 1)
+                usage ("No remotecmd\n");
+
+        comm = ssprintf (comm, "%s %s '%s'", comm, hostname, remotecmd);
+
+        return validate_arguments ();
+}
+
+
+
+
+
+/* Call getopt */
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 1;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {"verbose", no_argument, 0, 'v'},
+                {"fork", no_argument, 0, 'f'},
+                {"timeout", required_argument, 0, 't'},
+                {"host", required_argument, 0, 'H'},
+                {"port", required_argument,0,'P'},
+                {"output", required_argument, 0, 'O'},
+                {"name", required_argument, 0, 'n'},
+                {"services", required_argument, 0, 's'},
+                {"identity", required_argument, 0, 'i'},
+                {"user", required_argument, 0, 'u'},
+                {"logname", required_argument, 0, 'l'},
+                {"command", required_argument, 0, 'C'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+?Vvhft:H:O:P:p:i:u:l:C:n:s:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+?Vvhft:H:O:P:p:i:u:l:C:n:s:");
+#endif
+
+                if (c == -1 || c == EOF)
+                        break;
+
+                i++;
+                switch (c) {
+                case 't':
+                case 'H':
+                case 'O':
+                case 'p':
+                case 'i':
+                case 'u':
+                case 'l':
+                case 'n':
+                case 's':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* help */
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help (PROGNAME);
+                        exit (STATE_OK);
+                case 'v':                                                                       /* help */
+                        verbose = TRUE;
+                        break;
+                case 'f':                                                                       /* fork to background */
+                        comm = ssprintf (comm, "%s -f", comm);
+                        break;
+                case 't':                                                                       /* timeout period */
+                        if (!is_integer (optarg))
+                                usage2 ("timeout interval must be an integer", optarg);
+                        timeout_interval = atoi (optarg);
+                        break;
+                case 'H':                                                                       /* host */
+                        if (!is_host (optarg))
+                                usage2 ("invalid host name", optarg);
+                        hostname = optarg;
+                        break;
+                case 'P': /* port number */
+                case 'p': /* port number */
+                        if (!is_integer (optarg))
+                                usage2 ("port must be an integer", optarg);
+                        comm = ssprintf (comm,"%s -p %s", comm, optarg);
+                        break;
+                case 'O':                                                                       /* output file */
+                        outputfile = optarg;
+                        passive = TRUE;
+                        break;
+                case 's':                                                                       /* description of service to check */
+                        servicelist = optarg;
+                        break;
+                case 'n':                                                                       /* short name of host in nagios configuration */
+                        host_shortname = optarg;
+                        break;
+                case 'u':
+                        c = 'l';
+                case 'l':                                                                       /* login name */
+                case 'i':                                                                       /* identity */
+                        comm = ssprintf (comm, "%s -%c %s", comm, c, optarg);
+                        break;
+                case 'C':                                                                       /* Command for remote machine */
+                        commands++;
+                        if (commands > 1)
+                                remotecmd = strscat (remotecmd, ";echo STATUS CODE: $?;");
+                        remotecmd = strscat (remotecmd, optarg);
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        if (remotecmd == NULL || hostname == NULL)
+                return ERROR;
+        return OK;
+}
+
+
+
+
+
+void
+print_help (char *cmd)
+{
+        print_revision (cmd, "$Revision$");
+
+        printf
+                ("Copyright (c) 1999    Karl DeBisschop (kdebisschop@alum.mit.edu)\n\n"
+                 "This plugin will execute a command on a remote host using SSH\n\n");
+
+        print_usage ();
+
+        printf
+                ("\nOptions:\n"
+                 "-H, --hostname=HOST\n"
+                 "   name or IP address of remote host\n"
+                 "-C, --command='COMMAND STRING'\n"
+                 "   command to execute on the remote machine\n"
+                 "-f tells ssh to fork rather than create a tty\n"
+                 "-t, --timeout=INTEGER\n"
+                 "   specify timeout (default: %d seconds) [optional]\n"
+                 "-l, --logname=USERNAME\n"
+                 "   SSH user name on remote host [optional]\n"
+                 "-i, --identity=KEYFILE\n"
+                 "   identity of an authorized key [optional]\n"
+                 "-O, --output=FILE\n"
+                 "   external command file for nagios [optional]\n"
+                 "-s, --services=LIST\n"
+                 "   list of nagios service names, separated by ':' [optional]\n"
+                 "-n, --name=NAME\n"
+                 "   short name of host in nagios configuration [optional]\n"
+                 "\n"
+                 "The most common mode of use is to refer to a local identity file with\n"
+                 "the '-i' option. In this mode, the identity pair should have a null\n"
+                 "passphrase and the public key should be listed in the authorized_keys\n"
+                 "file of the remote host. Usually the key will be restricted to running\n"
+                 "only one command on the remote server. If the remote SSH server tracks\n"
+                 "invocation agruments, the one remote program may be an agent that can\n"
+                 "execute additional commands as proxy\n"
+                 "\n"
+                 "To use passive mode, provide multiple '-C' options, and provide\n"
+                 "all of -O, -s, and -n options (servicelist order must match '-C'\n"
+                 "options)\n", DEFAULT_SOCKET_TIMEOUT);
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage:\n"
+                 "check_by_ssh [-f] [-t timeout] [-i identity] [-l user] -H <host> <command>\n"
+                 "             [-n name] [-s servicelist] [-O outputfile] [-P port]\n"
+                 "check_by_ssh  -V prints version info\n"
+                 "check_by_ssh  -h prints more detailed help\n");
+}
diff --git a/plugins/check_dig.c b/plugins/check_dig.c
new file mode 100644
index 00000000..57609acd
--- /dev/null
+++ b/plugins/check_dig.c
@@ -0,0 +1,296 @@
+/******************************************************************************
+*
+* check_dig.c
+*
+* Program: dig plugin for Nagios
+* License: GPL
+* Copyright (c) 2000
+*
+* $Id$
+*
+*****************************************************************************/
+
+#include "config.h"
+#include "common.h"
+#include "utils.h"
+#include "popen.h"
+
+#define PROGNAME "check_dig"
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+int check_disk (int usp, int free_disk);
+void print_help (void);
+void print_usage (void);
+
+char *query_address = NULL;
+char *dns_server = NULL;
+int verbose = FALSE;
+
+int
+main (int argc, char **argv)
+{
+        char input_buffer[MAX_INPUT_BUFFER];
+        char *command_line = NULL;
+        char *output = NULL;
+        int result = STATE_UNKNOWN;
+
+        /* Set signal handling and alarm */
+        if (signal (SIGALRM, popen_timeout_alarm_handler) == SIG_ERR)
+                usage ("Cannot catch SIGALRM\n");
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Could not parse arguments\n");
+
+        /* get the command to run */
+        command_line =
+                ssprintf (command_line, "%s @%s %s", PATH_TO_DIG, dns_server,
+                                                        query_address);
+
+        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);
+
+        output = strscpy (output, "");
+
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+
+                /* the server is responding, we just got the host name... */
+                if (strstr (input_buffer, ";; ANSWER SECTION:")) {
+
+                        /* get the host address */
+                        if (!fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process))
+                                break;
+
+                        if (strpbrk (input_buffer, "\r\n"))
+                                input_buffer[strcspn (input_buffer, "\r\n")] = '\0';
+
+                        if (strstr (input_buffer, query_address) == input_buffer) {
+                                output = strscpy (output, input_buffer);
+                                result = STATE_OK;
+                        }
+                        else {
+                                strcpy (output, "Server not found in ANSWER SECTION");
+                                result = STATE_WARNING;
+                        }
+
+                        continue;
+                }
+
+        }
+
+        if (result != STATE_OK) {
+                strcpy (output, "No ANSWER SECTION found");
+        }
+
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) {
+                /* If we get anything on STDERR, at least set warning */
+                result = max (result, STATE_WARNING);
+                printf ("%s", input_buffer);
+                if (!strcmp (output, ""))
+                        strcpy (output, 1 + index (input_buffer, ':'));
+        }
+
+        (void) fclose (child_stderr);
+
+        /* close the pipe */
+        if (spclose (child_process)) {
+                result = max (result, STATE_WARNING);
+                if (!strcmp (output, ""))
+                        strcpy (output, "nslookup returned error status");
+        }
+
+        (void) time (&end_time);
+
+        if (result == STATE_OK)
+                printf ("DNS ok - %d seconds response time (%s)\n",
+                                                (int) (end_time - start_time), output);
+        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;
+}
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+        if (argc < 2)
+                return ERROR;
+
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (dns_server == NULL) {
+                        if (is_host (argv[c])) {
+                                dns_server = argv[c];
+                        }
+                        else {
+                                usage ("Invalid host name");
+                        }
+                }
+        }
+
+        if (dns_server == NULL)
+                dns_server = strscpy (NULL, "127.0.0.1");
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"query_address", required_argument, 0, 'e'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c = getopt_long (argc, argv, "+hVvt:l:H:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+?hVvt:l:H:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 't':
+                case 'l':
+                case 'H':
+                        i++;
+                }
+
+                switch (c) {
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg)) {
+                                dns_server = optarg;
+                        }
+                        else {
+                                usage ("Invalid host name\n");
+                        }
+                        break;
+                case 'l':                                                                       /* username */
+                        query_address = optarg;
+                        break;
+                case 'v':                                                                       /* verbose */
+                        verbose = TRUE;
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (is_intnonneg (optarg)) {
+                                timeout_interval = atoi (optarg);
+                        }
+                        else {
+                                usage ("Time interval must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        return OK;
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Karl DeBisschop\n\n"
+                 "This plugin use dig to test the DNS service on the specified host.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -H, --hostname=STRING or IPADDRESS\n"
+                 "   Check server on the indicated host\n"
+                 " -l, --lookup=STRING\n"
+                 "   machine name to lookup\n"
+                 " -t, --timeout=INTEGER\n"
+                 "   Seconds before connection attempt times out (default: %d)\n"
+                 " -v, --verbose\n"
+                 "   Print extra information (command-line use only)\n"
+                 " -h, --help\n"
+                 "   Print detailed help screen\n"
+                 " -V, --version\n"
+                 "   Print version information\n\n", DEFAULT_SOCKET_TIMEOUT);
+        support ();
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H host -l lookup [-t timeout] [-v]\n"
+                 "       %s --help\n"
+                 "       %s --version\n", PROGNAME, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_disk.c b/plugins/check_disk.c
new file mode 100644
index 00000000..d7aad072
--- /dev/null
+++ b/plugins/check_disk.c
@@ -0,0 +1,353 @@
+/******************************************************************************
+ *
+ * CHECK_DISK.C
+ *
+ * Program: Disk space plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ * Copyright (c) 2000 Karl DeBisschop (kdebisschop@users.sourceforge.net)
+ *
+ * $Id$
+ *
+ * Description:
+ *
+ * This plugin will use the /bin/df command to check the free space on
+ * currently mounted filesystems.  If the percent used disk space is
+ * above <c_dfp>, a STATE_CRITICAL is returned.  If the percent used
+ * disk space is above <w_dfp>, a STATE_WARNING is returned.  If the
+ * speicified filesystem cannot be read, a STATE_CRITICAL is returned,
+ * other errors with reading the output result in a STATE_UNKNOWN
+ * error.
+ *
+ * Notes:
+ *  - IRIX support added by Charlie Cook 4-16-1999
+ *  - Modifications by Karl DeBisschop 1999-11-24
+ *     reformat code to 80 char screen width
+ *     set STATE_WARNING if stderr is written or spclose status set
+ *     set default result to STAT_UNKNOWN
+ *     initailize usp to -1, eliminate 'found' variable
+ *     accept any filename/filesystem
+ *     use sscanf, drop while loop
+ *
+ *****************************************************************************/
+
+#include "common.h"
+#include "popen.h"
+#include "utils.h"
+#include <stdarg.h>
+
+#define PROGNAME "check_disk"
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+int check_disk (int usp, int free_disk);
+void print_help (void);
+void print_usage (void);
+
+int w_df = -1;
+int c_df = -1;
+float w_dfp = -1.0;
+float c_dfp = -1.0;
+char *path = NULL;
+int verbose = FALSE;
+
+int
+main (int argc, char **argv)
+{
+        int len;
+        int usp = -1;
+        int total_disk = -1;
+        int used_disk = -1;
+        int free_disk = -1;
+        int result = STATE_UNKNOWN;
+        char *command_line = NULL;
+        char input_buffer[MAX_INPUT_BUFFER] = "";
+        char file_system[MAX_INPUT_BUFFER] = "";
+        char outbuf[MAX_INPUT_BUFFER] = "";
+        char *output = NULL;
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Could not parse arguments\n");
+
+        command_line = ssprintf (command_line, "%s %s", DF_COMMAND, path);
+
+        if (verbose)
+                printf ("%s ==> ", command_line);
+
+        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);
+        }
+
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+
+                if (!index (input_buffer, '/'))
+                        continue;
+
+                if (sscanf
+                                (input_buffer, "%s %d %d %d %d%%", file_system, &total_disk,
+                                 &used_disk, &free_disk, &usp) == 5
+                                || sscanf (input_buffer, "%s %*s %d %d %d %d%%", file_system,
+                                                                         &total_disk, &used_disk, &free_disk, &usp) == 5) {
+                        result = max (result, check_disk (usp, free_disk));
+                        len =
+                                snprintf (outbuf, MAX_INPUT_BUFFER - 1,
+                                                                        " [%d kB (%d%%) free on %s]", free_disk, 100 - usp,
+                                                                        file_system);
+                        outbuf[len] = 0;
+                        output = strscat (output, outbuf);
+                }
+                else {
+                        printf ("Unable to read output:\n%s\n%s\n", command_line, input_buffer);
+                        return result;
+                }
+        }
+
+        /* If we get anything on stderr, at least set warning */
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
+                result = max (result, STATE_WARNING);
+
+        /* close stderr */
+        (void) fclose (child_stderr);
+
+        /* close the pipe */
+        if (spclose (child_process))
+                result = max (result, STATE_WARNING);
+
+        else if (usp < 0)
+                printf ("Disk %s not mounted or nonexistant\n", argv[3]);
+        else if (result == STATE_UNKNOWN)
+                printf ("Unable to read output\n%s\n%s\n", command_line, input_buffer);
+        else
+                printf ("DISK %s -%s\n", state_text (result), output);
+
+        return result;
+}
+
+/* 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]))) < argc) {
+
+                if (w_dfp == -1 && is_intnonneg (argv[c]))
+                        w_dfp = (100.0 - atof (argv[c]));
+                else if (c_dfp == -1 && is_intnonneg (argv[c]))
+                        c_dfp = (100.0 - atof (argv[c]));
+                else if (path == NULL || path[0] == 0)
+                        path = strscpy (path, argv[c]);
+        }
+
+        if (path == NULL) {
+                path = malloc (1);
+                if (path == NULL)
+                        terminate (STATE_UNKNOWN, "Could not malloc empty path\n");
+                path[0] = 0;
+        }
+
+        return validate_arguments ();
+}
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"warning", required_argument, 0, 'w'},
+                {"critical", required_argument, 0, 'c'},
+                {"timeout", required_argument, 0, 't'},
+                {"path", required_argument, 0, 'p'},
+                {"partition", required_argument, 0, 'p'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+?Vhvt:c:w:p:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+?Vhvt:c:w:p:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 't':
+                case 'c':
+                case 'w':
+                case 'p':
+                        i++;
+                }
+
+                switch (c) {
+                case 'w':                                                                       /* warning time threshold */
+                        if (is_intnonneg (optarg)) {
+                                w_df = atoi (optarg);
+                                break;
+                        }
+                        else if (strpbrk (optarg, ",:") &&
+                                                         strstr (optarg, "%") &&
+                                                         sscanf (optarg, "%d%*[:,]%f%%", &w_df, &w_dfp) == 2) {
+                                break;
+                        }
+                        else if (strstr (optarg, "%") && sscanf (optarg, "%f%%", &w_dfp) == 1) {
+                                break;
+                        }
+                        else {
+                                usage ("Warning threshold must be integer or percentage!\n");
+                        }
+                case 'c':                                                                       /* critical time threshold */
+                        if (is_intnonneg (optarg)) {
+                                c_df = atoi (optarg);
+                                break;
+                        }
+                        else if (strpbrk (optarg, ",:") &&
+                                                         strstr (optarg, "%") &&
+                                                         sscanf (optarg, "%d%*[,:]%f%%", &c_df, &c_dfp) == 2) {
+                                break;
+                        }
+                        else if (strstr (optarg, "%") && sscanf (optarg, "%f%%", &c_dfp) == 1) {
+                                break;
+                        }
+                        else {
+                                usage ("Critical threshold must be integer or percentage!\n");
+                        }
+                case 't':                                                                       /* timeout period */
+                        if (is_integer (optarg)) {
+                                timeout_interval = atoi (optarg);
+                                break;
+                        }
+                        else {
+                                usage ("Timeout Interval must be an integer!\n");
+                        }
+                case 'p':                                                                       /* path or partition */
+                        path = optarg;
+                        break;
+                case 'v':                                                                       /* verbose */
+                        verbose = TRUE;
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("check_disk: unrecognized option\n");
+                        break;
+                }
+        }
+        return i;
+}
+
+int
+validate_arguments ()
+{
+        if (w_df < 0 && c_df < 0 && w_dfp < 0 && c_dfp < 0) {
+                printf ("INPUT ERROR: Unable to parse command line\n");
+                return ERROR;
+        }
+        else if ((w_dfp >= 0 || c_dfp >= 0)
+                                         && (w_dfp < 0 || c_dfp < 0 || w_dfp > 100 || c_dfp > 100
+                                                         || c_dfp > w_dfp)) {
+                printf
+                        ("INPUT ERROR: C_DFP (%f) should be less than W_DFP (%f) and both should be between zero and 100 percent, inclusive\n",
+                         c_dfp, w_dfp);
+                return ERROR;
+        }
+        else if ((w_df > 0 || c_df > 0) && (w_df < 0 || c_df < 0 || c_df > w_df)) {
+                printf
+                        ("INPUT ERROR: C_DF (%d) should be less than W_DF (%d) and both should be greater than zero\n",
+                         c_df, w_df);
+                return ERROR;
+        }
+        else {
+                return OK;
+        }
+}
+
+int
+check_disk (usp, free_disk)
+{
+        int result = STATE_UNKNOWN;
+        /* check the percent used space against thresholds */
+        if (usp >= 0 && usp >= (100.0 - c_dfp))
+                result = STATE_CRITICAL;
+        else if (c_df >= 0 && free_disk <= c_df)
+                result = STATE_CRITICAL;
+        else if (usp >= 0 && usp >= (100.0 - w_dfp))
+                result = STATE_WARNING;
+        else if (w_df >= 0 && free_disk <= w_df)
+                result = STATE_WARNING;
+        else if (usp >= 0.0)
+                result = STATE_OK;
+        return result;
+}
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Ethan Galstad/Karl DeBisschop\n\n"
+                 "This plugin will check the percent of used disk space on a mounted\n"
+                 "file system and generate an alert if percentage is above one of the\n"
+                 "threshold values.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -w, --warning=INTEGER\n"
+                 "   Exit with WARNING status if less than INTEGER kilobytes of disk are free\n"
+                 " -w, --warning=PERCENT%%\n"
+                 "   Exit with WARNING status if more than PERCENT of disk space is free\n"
+                 " -c, --critical=INTEGER\n"
+                 "   Exit with CRITICAL status if less than INTEGER kilobytes of disk are free\n"
+                 " -c, --critical=PERCENT%%\n"
+                 "   Exit with CRITCAL status if more than PERCENT of disk space is free\n"
+                 " -p, --path=PATH, --partition=PARTTION\n"
+                 "    Path or partition (checks all mounted partitions if unspecified)\n"
+                 " -v, --verbose\n"
+                 "    Show details for command-line debugging (do not use with nagios server)\n"
+                 " -h, --help\n"
+                 "    Print detailed help screen\n"
+                 " -V, --version\n" "    Print version information\n\n");
+        support ();
+}
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -w limit -c limit [-p path] [-t timeout] [--verbose]\n"
+                 "       %s (-h|--help)\n"
+                 "       %s (-V|--version)\n", PROGNAME, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_dns.c b/plugins/check_dns.c
new file mode 100644
index 00000000..eaff4372
--- /dev/null
+++ b/plugins/check_dns.c
@@ -0,0 +1,415 @@
+/******************************************************************************
+ *
+ * CHECK_DNS.C
+ *
+ * Program: DNS plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ *
+ * Last Modified: $Date$
+ *
+ * Notes:
+ *  - Safe popen added by Karl DeBisschop 9-11-99
+ *
+ * Command line: CHECK_DNS <query_address> [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;
+}
+
+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;
+
+}
+
+/* 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]);
+                }
+        }
+
+        return validate_arguments ();
+
+}
+
+int
+call_getopt (int argc, char **argv)
+{
+        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
+                c = getopt (argc, argv, "+?hVvt:H:s:r:");
+#endif
+
+                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$");
+                        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$");
+        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);
+}
diff --git a/plugins/check_dummy.c b/plugins/check_dummy.c
new file mode 100644
index 00000000..c2a5b7eb
--- /dev/null
+++ b/plugins/check_dummy.c
@@ -0,0 +1,100 @@
+/*************************************************************
+ *
+ * CHECK_DUMMY.C
+ *
+ * Program: Dummy plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ *
+ * Last Modified: $Date$
+ *
+ * Command line: CHECK_DUMMY <state>
+ *
+ * Description:
+ *
+ * This plugin will simply return the state corresponding to the
+ * numerical value of the <state> argument.
+ *
+ * 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 "config.h"
+#include "common.h"
+#include "utils.h"
+
+void print_help (char *);
+void print_usage (char *);
+
+int
+main (int argc, char **argv)
+{
+        int result;
+
+        if (argc != 2) {
+                printf ("Incorrect number of arguments supplied\n");
+                exit (STATE_UNKNOWN);
+        }
+        else if (strcmp (argv[1], "-V") == 0 || strcmp (argv[1], "--version") == 0) {
+                print_revision (argv[0], "$Revision$");
+                exit (STATE_OK);
+        }
+        else if (strcmp (argv[1], "-h") == 0 || strcmp (argv[1], "--help") == 0) {
+                print_help (argv[0]);
+                exit (STATE_OK);
+        }
+        else if (!is_integer (argv[1])) {
+                print_usage (argv[0]);
+                exit (STATE_UNKNOWN);
+        }
+        result = atoi (argv[1]);
+
+        switch (result) {
+        case STATE_OK:
+                printf ("Status is OK\n");
+                break;
+        case STATE_WARNING:
+                printf ("Status is at WARNING level\n");
+                break;
+        case STATE_CRITICAL:
+                printf ("Status is CRITICAL\n");
+                break;
+        default:
+                printf ("Status is UNKNOWN\n");
+                result = STATE_UNKNOWN;
+        }
+
+        return result;
+}
+
+void
+print_help (char *cmd)
+{
+        print_revision (cmd, "$Revision$");
+        printf ("Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)\n"
+                                        "License: GPL\n\n");
+        print_usage (cmd);
+        printf
+                ("\nThis plugin will simply return the state corresponding to the numeric value\n"
+                 "of the <state> argument.\n");
+}
+
+void
+print_usage (char *cmd)
+{
+        printf ("Usage: %s <integer state>\n", cmd);
+}
diff --git a/plugins/check_fping.c b/plugins/check_fping.c
new file mode 100644
index 00000000..f6531a54
--- /dev/null
+++ b/plugins/check_fping.c
@@ -0,0 +1,386 @@
+/******************************************************************************
+*
+* CHECK_FPING.C
+*
+* Program: Fping plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Didi Rieder (adrieder@sbox.tu-graz.ac.at)
+* $Id$
+*
+* Modifications:
+*
+* 08-24-1999 Didi Rieder (adrieder@sbox.tu-graz.ac.at)
+*            Intial Coding
+* 09-11-1999 Karl DeBisschop (kdebiss@alum.mit.edu)
+*            Change to spopen
+*            Fix so that state unknown is returned by default
+*            (formerly would give state ok if no fping specified)
+*            Add server_name to output
+*            Reformat to 80-character standard screen
+* 11-18-1999 Karl DeBisschop (kdebiss@alum.mit.edu)
+*            set STATE_WARNING of stderr written or nonzero status returned
+*
+* Description:
+*
+* This plugin will use the /bin/fping command (form saint) to ping
+* the specified host for a fast check if the host is alive. Note that
+* it is necessary to set the suid flag on fping.
+******************************************************************************/
+
+#include "config.h"
+#include "common.h"
+#include "popen.h"
+#include "utils.h"
+
+#define PROGNAME "check_fping"
+#define PACKET_COUNT 1
+#define PACKET_SIZE 56
+#define UNKNOWN_PACKET_LOSS 200 /* 200% */
+#define UNKNOWN_TRIP_TIME -1.0  /* -1 seconds */
+
+#define PL 0
+#define RTA 1
+
+int textscan (char *buf);
+int process_arguments (int, char **);
+int get_threshold (char *arg, char *rv[2]);
+void print_usage (void);
+void print_help (void);
+
+char *server_name = NULL;
+int cpl = UNKNOWN_PACKET_LOSS;
+int wpl = UNKNOWN_PACKET_LOSS;
+double crta = UNKNOWN_TRIP_TIME;
+double wrta = UNKNOWN_TRIP_TIME;
+int packet_size = PACKET_SIZE;
+int packet_count = PACKET_COUNT;
+int verbose = FALSE;
+
+int
+main (int argc, char **argv)
+{
+        int status = STATE_UNKNOWN;
+        char *server = NULL;
+        char *command_line = NULL;
+        char *input_buffer = NULL;
+        input_buffer = malloc (MAX_INPUT_BUFFER);
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments\n");
+
+        server = strscpy (server, server_name);
+
+        /* compose the command */
+        command_line = ssprintf
+                (command_line, "%s -b %d -c %d %s",
+                 PATH_TO_FPING, packet_size, packet_count, server);
+
+        if (verbose)
+                printf ("%s\n", command_line);
+
+        /* run the command */
+        child_process = spopen (command_line);
+        if (child_process == NULL) {
+                printf ("Unable to 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);
+        }
+
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+                if (verbose)
+                        printf ("%s", input_buffer);
+                status = max (status, textscan (input_buffer));
+        }
+
+        /* If we get anything on STDERR, at least set warning */
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) {
+                status = max (status, STATE_WARNING);
+                if (verbose)
+                        printf ("%s", input_buffer);
+                status = max (status, textscan (input_buffer));
+        }
+        (void) fclose (child_stderr);
+
+        /* close the pipe */
+        if (spclose (child_process))
+                status = max (status, STATE_WARNING);
+
+        printf ("FPING %s - %s\n", state_text (status), server_name);
+
+        return status;
+}
+
+
+
+
+int
+textscan (char *buf)
+{
+        char *rtastr = NULL;
+        char *losstr = NULL;
+        double loss;
+        double rta;
+        int status = STATE_UNKNOWN;
+
+        if (strstr (buf, "not found")) {
+                terminate (STATE_CRITICAL, "FPING unknown - %s not found\n", server_name);
+
+        }
+        else if (strstr (buf, "is unreachable") || strstr (buf, "Unreachable")) {
+                terminate (STATE_CRITICAL, "FPING critical - %s is unreachable\n",
+                                                         "host");
+
+        }
+        else if (strstr (buf, "is down")) {
+                terminate (STATE_CRITICAL, "FPING critical - %s is down\n", server_name);
+
+        }
+        else if (strstr (buf, "is alive")) {
+                status = STATE_OK;
+
+        }
+        else if (strstr (buf, "xmt/rcv/%loss") && strstr (buf, "min/avg/max")) {
+                losstr = strstr (buf, "=");
+                losstr = 1 + strstr (losstr, "/");
+                losstr = 1 + strstr (losstr, "/");
+                rtastr = strstr (buf, "min/avg/max");
+                rtastr = strstr (rtastr, "=");
+                rtastr = 1 + index (rtastr, '/');
+                loss = strtod (losstr, NULL);
+                rta = strtod (rtastr, NULL);
+                if (cpl != UNKNOWN_PACKET_LOSS && loss > cpl)
+                        status = STATE_CRITICAL;
+                else if (crta != UNKNOWN_TRIP_TIME && rta > crta)
+                        status = STATE_CRITICAL;
+                else if (wpl != UNKNOWN_PACKET_LOSS && loss > wpl)
+                        status = STATE_WARNING;
+                else if (wrta != UNKNOWN_TRIP_TIME && rta > wrta)
+                        status = STATE_WARNING;
+                else
+                        status = STATE_OK;
+                terminate (status, "FPING %s - %s (loss=%f%%, rta=%f ms)\n",
+                                                         state_text (status), server_name, loss, rta);
+
+        }
+        else {
+                status = max (status, STATE_WARNING);
+        }
+
+        return status;
+}
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+        char *rv[2];
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"bytes", required_argument, 0, 'b'},
+                {"number", required_argument, 0, 'n'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        rv[PL] = NULL;
+        rv[RTA] = NULL;
+
+        if (argc < 2)
+                return ERROR;
+
+        if (!is_option (argv[1])) {
+                server_name = argv[1];
+                argv[1] = argv[0];
+                argv = &argv[1];
+                argc--;
+        }
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVvH:c:w:b:n:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+hVvH:c:w:b:n:");
+#endif
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case '?':                                                                       /* print short usage statement if args not parsable */
+                        printf ("%s: Unknown argument: %s\n\n", my_basename (argv[0]), optarg);
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'v':                                                                       /* verbose mode */
+                        verbose = TRUE;
+                        break;
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg) == FALSE) {
+                                printf ("Invalid host name/address\n\n");
+                                print_usage ();
+                                exit (STATE_UNKNOWN);
+                        }
+                        server_name = strscpy (server_name, optarg);
+                        break;
+                case 'c':
+                        get_threshold (optarg, rv);
+                        if (rv[RTA]) {
+                                crta = strtod (rv[RTA], NULL);
+                                rv[RTA] = NULL;
+                        }
+                        if (rv[PL]) {
+                                cpl = atoi (rv[PL]);
+                                rv[PL] = NULL;
+                        }
+                        break;
+                case 'w':
+                        get_threshold (optarg, rv);
+                        if (rv[RTA]) {
+                                wrta = strtod (rv[RTA], NULL);
+                                rv[RTA] = NULL;
+                        }
+                        if (rv[PL]) {
+                                wpl = atoi (rv[PL]);
+                                rv[PL] = NULL;
+                        }
+                        break;
+                case 'b':                                                                       /* bytes per packet */
+                        if (is_intpos (optarg))
+                                packet_size = atoi (optarg);
+                        else
+                                usage ("Packet size must be a positive integer");
+                        break;
+                case 'n':                                                                       /* number of packets */
+                        if (is_intpos (optarg))
+                                packet_count = atoi (optarg);
+                        else
+                                usage ("Packet count must be a positive integer");
+                        break;
+                }
+        }
+
+
+        if (server_name == NULL)
+                usage ("Host name was not supplied\n\n");
+
+        return OK;
+}
+
+
+
+
+
+int
+get_threshold (char *arg, char *rv[2])
+{
+        char *arg1 = NULL;
+        char *arg2 = NULL;
+
+        arg1 = strscpy (arg1, arg);
+        if (strpbrk (arg1, ",:"))
+                arg2 = 1 + strpbrk (arg1, ",:");
+
+        if (arg2) {
+                arg1[strcspn (arg1, ",:")] = 0;
+                if (strstr (arg1, "%") && strstr (arg2, "%"))
+                        terminate (STATE_UNKNOWN,
+                                                                 "%s: Only one threshold may be packet loss (%s)\n", PROGNAME,
+                                                                 arg);
+                if (!strstr (arg1, "%") && !strstr (arg2, "%"))
+                        terminate (STATE_UNKNOWN,
+                                                                 "%s: Only one threshold must be packet loss (%s)\n",
+                                                                 PROGNAME, arg);
+        }
+
+        if (arg2 && strstr (arg2, "%")) {
+                rv[PL] = arg2;
+                rv[RTA] = arg1;
+        }
+        else if (arg2) {
+                rv[PL] = arg1;
+                rv[RTA] = arg2;
+        }
+        else if (strstr (arg1, "%")) {
+                rv[PL] = arg1;
+        }
+        else {
+                rv[RTA] = arg1;
+        }
+
+        return OK;
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf ("Usage: %s <host_address>\n", PROGNAME);
+}
+
+
+
+
+
+void
+print_help (void)
+{
+
+        print_revision (PROGNAME, "$Revision$");
+
+        printf
+                ("Copyright (c) 1999 Didi Rieder (adrieder@sbox.tu-graz.ac.at)\n\n"
+                 "This plugin will use the /bin/fping command (from saint) to ping the\n"
+                 "specified host for a fast check if the host is alive. Note that it is\n"
+                 "necessary to set the suid flag on fping.\n\n");
+
+        print_usage ();
+
+        printf
+                ("\nOptions:\n"
+                 "-H, --hostname=HOST\n"
+                 "   Name or IP Address of host to ping (IP Address bypasses name lookup,\n"
+                 "   reducing system load)\n"
+                 "-w, --warning=THRESHOLD\n"
+                 "   warning threshold pair\n"
+                 "-c, --critical=THRESHOLD\n"
+                 "   critical threshold pair\n"
+                 "-b, --bytes=INTEGER\n"
+                 "   Size of ICMP packet (default: %d)\n"
+                 "-n, --number=INTEGER\n"
+                 "   Number of ICMP packets to send (default: %d)\n"
+                 "-v, --verbose\n"
+                 "   Show details for command-line debugging (do not use with nagios server)\n"
+                 "-h, --help\n"
+                 "   Print this help screen\n"
+                 "-V, --version\n"
+                 "   Print version information\n"
+                 "THRESHOLD is <rta>,<pl>%% where <rta> is the round trip average travel\n"
+                 "time (ms) which triggers a WARNING or CRITICAL state, and <pl> is the\n"
+                 "percentage of packet loss to trigger an alarm state.\n",
+                 PACKET_SIZE, PACKET_COUNT);
+}
diff --git a/plugins/check_ftp.c b/plugins/check_ftp.c
new file mode 100644
index 00000000..1c65d642
--- /dev/null
+++ b/plugins/check_ftp.c
@@ -0,0 +1,337 @@
+/******************************************************************************
+ *
+ * CHECK_FTP.C
+ *
+ * Program: FTP plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ *
+ * $Id$
+ *
+ * Description:
+ *
+ * This plugin will attempt to open an FTP connection with the host.
+ * Successul connects return STATE_OK, refusals and timeouts return
+ * STATE_CRITICAL, other errors return STATE_UNKNOWN.  Successful
+ * connects, but incorrect reponse messages from the host result in
+ * STATE_WARNING return values.
+ *
+ * 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 "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define PROGNAME "check_ftp"
+
+#define FTP_PORT        21
+#define FTP_EXPECT      "220"
+#define FTP_QUIT        "QUIT\n"
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+void print_usage (void);
+void print_help (void);
+
+time_t start_time, end_time;
+int server_port = FTP_PORT;
+char *server_address = NULL;
+char *server_expect = NULL;
+int warning_time = 0;
+int check_warning_time = FALSE;
+int critical_time = 0;
+int check_critical_time = FALSE;
+int verbose = FALSE;
+
+
+int
+main (int argc, char **argv)
+{
+        int sd;
+        int result;
+        char buffer[MAX_INPUT_BUFFER];
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+
+        /* try to connect to the host at the given port number */
+        time (&start_time);
+        result = my_tcp_connect (server_address, server_port, &sd);
+
+        /* we connected, so close connection before exiting */
+        if (result == STATE_OK) {
+
+                /* watch for the FTP connection string */
+                result = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+
+                /* strip the buffer of carriage returns */
+                strip (buffer);
+
+                /* return a WARNING status if we couldn't read any data */
+                if (result == -1) {
+                        printf ("recv() failed\n");
+                        result = STATE_WARNING;
+                }
+
+                else {
+
+                        /* make sure we find the response we are looking for */
+                        if (!strstr (buffer, server_expect)) {
+
+                                if (server_port == FTP_PORT)
+                                        printf ("Invalid FTP response received from host\n");
+                                else
+                                        printf ("Invalid FTP response received from host on port %d\n",
+                                                                        server_port);
+                                result = STATE_WARNING;
+                        }
+
+                        else {
+                                time (&end_time);
+
+                                result = STATE_OK;
+
+                                if (check_critical_time == TRUE
+                                                && (end_time - start_time) > critical_time) result =
+                                                STATE_CRITICAL;
+                                else if (check_warning_time == TRUE
+                                                                 && (end_time - start_time) > warning_time) result =
+                                                STATE_WARNING;
+
+                                if (verbose == TRUE)
+                                        printf ("FTP %s - %d sec. response time, %s\n",
+                                                                        (result == STATE_OK) ? "ok" : "problem",
+                                                                        (int) (end_time - start_time), buffer);
+                                else
+                                        printf ("FTP %s - %d second response time\n",
+                                                                        (result == STATE_OK) ? "ok" : "problem",
+                                                                        (int) (end_time - start_time));
+                        }
+                }
+
+                /* close the connection */
+                send (sd, FTP_QUIT, strlen (FTP_QUIT), 0);
+                close (sd);
+        }
+
+        /* reset the alarm */
+        alarm (0);
+
+        return result;
+}
+
+
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+        if (argc < 2)
+                usage ("\n");
+
+        for (c = 1; c < argc; c++) {
+                if (strcmp ("-to", argv[c]) == 0)
+                        strcpy (argv[c], "-t");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+        c = 0;
+        while ((c += call_getopt (argc - c, &argv[c])) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (server_address == NULL) {
+                        if (argc > c) {
+                                if (is_host (argv[c]) == FALSE)
+                                        usage ("Invalid host name/address\n");
+                                server_address = argv[c];
+                        }
+                        else {
+                                usage ("Host name was not supplied\n");
+                        }
+                }
+        }
+
+        if (server_expect == NULL)
+                server_expect = strscpy (NULL, FTP_EXPECT);
+
+        return OK;
+}
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"expect", required_argument, 0, 'e'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"timeout", required_argument, 0, 'w'},
+                {"port", required_argument, 0, 'p'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVvH:e:c:w:t:p:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+hVvH:e:c:w:t:p:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 'H':
+                case 'e':
+                case 'c':
+                case 'w':
+                case 't':
+                case 'p':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* print short usage statement if args not parsable */
+                        printf ("%s: Unknown argument: %s\n\n", my_basename (argv[0]), optarg);
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'v':                                                                       /* verbose mode */
+                        verbose = TRUE;
+                        break;
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg) == FALSE)
+                                usage ("Invalid host name/address\n");
+                        server_address = optarg;
+                        break;
+                case 'e':                                                                       /* expect */
+                        server_expect = optarg;
+                        break;
+                case 'c':                                                                       /* critical */
+                        if (!is_intnonneg (optarg))
+                                usage ("Critical threshold must be a nonnegative integer\n");
+                        critical_time = atoi (optarg);
+                        check_critical_time = TRUE;
+                        break;
+                case 'w':                                                                       /* warning */
+                        if (!is_intnonneg (optarg))
+                                usage ("Warning threshold must be a nonnegative integer\n");
+                        warning_time = atoi (optarg);
+                        check_warning_time = TRUE;
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (!is_intnonneg (optarg))
+                                usage ("Timeout interval must be a nonnegative integer\n");
+                        socket_timeout = atoi (optarg);
+                        break;
+                case 'p':                                                                       /* port */
+                        if (!is_intnonneg (optarg))
+                                usage ("Serevr port must be a nonnegative integer\n");
+                        server_port = atoi (optarg);
+                        break;
+                }
+        }
+        return i;
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H <host_address> [-e expect] [-p port] [-w warn_time]\n"
+                 "         [-c crit_time] [-t to_sec] [-v]\n", PROGNAME);
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)\n\n"
+                 "This plugin tests an FTP connection with the specified host.\n\n");
+        print_usage ();
+        printf
+                ("Options:\n"
+                 " -H, --hostname=ADDRESS\n"
+                 "    Host name argument for servers using host headers (use numeric\n"
+                 "    address if possible to bypass DNS lookup).\n"
+                 " -e, --expect=STRING\n"
+                 "    String to expect in first line of server response (default: %s)\n"
+                 " -p, --port=INTEGER\n"
+                 "    Port number (default: %d)\n"
+                 " -w, --warning=INTEGER\n"
+                 "    Response time to result in warning status (seconds)\n"
+                 " -c, --critical=INTEGER\n"
+                 "    Response time to result in critical status (seconds)\n"
+                 " -t, --timeout=INTEGER\n"
+                 "    Seconds before connection times out (default: %d)\n"
+                 " -v"
+                 "    Show details for command-line debugging (do not use with nagios server)\n"
+                 " -h, --help\n"
+                 "    Print detailed help screen\n"
+                 " -V, --version\n"
+                 "    Print version information\n",
+                 FTP_EXPECT, FTP_PORT, DEFAULT_SOCKET_TIMEOUT);
+}
diff --git a/plugins/check_game.c b/plugins/check_game.c
new file mode 100644
index 00000000..63d1be62
--- /dev/null
+++ b/plugins/check_game.c
@@ -0,0 +1,287 @@
+/******************************************************************************
+ *
+ * CHECK_GAME.C
+ *
+ * Program: GAME plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ian Cass (ian@knowledge.com)
+ *
+ * Last Modified: $Date$
+ *
+ * Mod History
+ *
+ * 25-8-99 Ethan Galstad <nagios@nagios.org>
+ *         Integrated with common plugin code, minor cleanup stuff
+ *
+ * 17-8-99 version 1.1b
+ *
+ * 17-8-99 make port a separate argument so we can use something like
+ *         check_game q2s!27910 with the probe set up as
+ *         check_game $ARG1$ $HOSTADDRESS$ $ARG2$
+ *
+ * 17-8-99 Put in sanity check for ppl who enter the wrong server type
+ *
+ * 17-8-99 Release version 1.0b
+ *
+ * Command line: CHECK_GAME <server type> <ip_address> [port]
+ *
+ * server type = a server type that qstat understands (type qstat & look at the -default line)
+ * ip_address  = either a dotted address or a FQD name
+ * port        = defaults game default port
+ *                        
+ *
+ * Description:
+ * 
+ * Needed to explore writing my own probes for nagios. It looked
+ * pretty simple so I thought I'd write one for monitoring the status
+ * of game servers. It uses qstat to do the actual monitoring and
+ * analyses the result. Doing it this way means I can support all the
+ * servers that qstat does and will do in the future.
+ *
+ *
+ * Dependencies:
+ *
+ * This plugin uses the 'qstat' command If you don't
+ * have the package installed you will need to download it from 
+ * http://www.activesw.com/people/steve/qstat.html or any popular files archive
+ * before you can use this plugin.
+ *
+ * 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 "config.h"
+#include "common.h"
+#include "utils.h"
+
+int process_arguments (int, char **);
+
+#define QSTAT_DATA_DELIMITER    ","
+
+#define QSTAT_HOST_ERROR        "ERROR"
+#define QSTAT_HOST_DOWN         "DOWN"
+#define QSTAT_HOST_TIMEOUT      "TIMEOUT"
+#define QSTAT_MAX_RETURN_ARGS   12
+
+char server_ip[MAX_HOST_ADDRESS_LENGTH];
+char game_type[MAX_INPUT_BUFFER];
+char port[MAX_INPUT_BUFFER];
+
+int qstat_game_field = 2;
+int qstat_map_field = 3;
+int qstat_ping_field = 5;
+
+
+int
+main (int argc, char **argv)
+{
+        char command_line[MAX_INPUT_BUFFER];
+        int result;
+        FILE *fp;
+        char input_buffer[MAX_INPUT_BUFFER];
+        char response[MAX_INPUT_BUFFER];
+        char *temp_ptr;
+        int found;
+        char *p, *ret[QSTAT_MAX_RETURN_ARGS];
+        int i;
+
+        result = process_arguments (argc, argv);
+
+        if (result != OK) {
+                printf ("Incorrect arguments supplied\n");
+                printf ("\n");
+                print_revision (argv[0], "$Revision$");
+                printf ("Copyright (c) 1999 Ian Cass, Knowledge Matters Limited\n");
+                printf ("License: GPL\n");
+                printf ("\n");
+                printf
+                        ("Usage: %s <game> <ip_address> [-p port] [-gf game_field] [-mf map_field] [-pf ping_field]\n",
+                         argv[0]);
+                printf ("\n");
+                printf ("Options:\n");
+                printf
+                        (" <game>        = Game type that is recognised by qstat (without the leading dash)\n");
+                printf
+                        (" <ip_address>  = The IP address of the device you wish to query\n");
+                printf (" [port]        = Optional port of which to connect\n");
+                printf
+                        (" [game_field]  = Field number in raw qstat output that contains game name\n");
+                printf
+                        (" [map_field]   = Field number in raw qstat output that contains map name\n");
+                printf
+                        (" [ping_field]  = Field number in raw qstat output that contains ping time\n");
+                printf ("\n");
+                printf ("Notes:\n");
+                printf
+                        ("- This plugin uses the 'qstat' command, the popular game server status query tool .\n");
+                printf
+                        ("  If you don't have the package installed, you will need to download it from\n");
+                printf
+                        ("  http://www.activesw.com/people/steve/qstat.html before you can use this plugin.\n");
+                printf ("\n");
+                return STATE_UNKNOWN;
+        }
+
+        result = STATE_OK;
+
+        /* create the command line to execute */
+        snprintf (command_line, sizeof (command_line) - 1, "%s -raw %s -%s %s%s",
+                                                PATH_TO_QSTAT, QSTAT_DATA_DELIMITER, game_type, server_ip, port);
+        command_line[sizeof (command_line) - 1] = 0;
+
+        /* run the command */
+        fp = popen (command_line, "r");
+        if (fp == NULL) {
+                printf ("Error - Could not open pipe: %s\n", command_line);
+                return STATE_UNKNOWN;
+        }
+
+        found = 0;
+        fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp); /* Only interested in the first line */
+
+        /* strip the newline character from the end of the input */
+        input_buffer[strlen (input_buffer) - 1] = 0;
+
+        /* sanity check */
+        /* was thinking about running qstat without any options, capturing the
+           -default line, parsing it & making an array of all know server types
+           but thought this would be too much hassle considering this is a tool
+           for intelligent sysadmins (ha). Could put a static array of known 
+           server types in a header file but then we'd be limiting ourselves
+
+           In the end, I figured I'd simply let an error occur & then trap it
+         */
+
+        if (!strncmp (input_buffer, "unknown option", 14)) {
+                printf ("ERROR: Host type parameter incorrect!\n");
+                result = STATE_CRITICAL;
+                return result;
+        }
+
+        /* initialize the returned data buffer */
+        for (i = 0; i < QSTAT_MAX_RETURN_ARGS; i++)
+                ret[i] = "";
+
+        i = 0;
+        p = (char *) strtok (input_buffer, QSTAT_DATA_DELIMITER);
+        while (p != NULL) {
+                ret[i] = p;
+                p = (char *) strtok (NULL, QSTAT_DATA_DELIMITER);
+                i++;
+                if (i >= QSTAT_MAX_RETURN_ARGS)
+                        break;
+        }
+
+        if (strstr (ret[2], QSTAT_HOST_ERROR)) {
+                printf ("ERROR: Host not found\n");
+                result = STATE_CRITICAL;
+        }
+        else if (strstr (ret[2], QSTAT_HOST_DOWN)) {
+                printf ("ERROR: Game server down or unavailable\n");
+                result = STATE_CRITICAL;
+        }
+        else if (strstr (ret[2], QSTAT_HOST_TIMEOUT)) {
+                printf ("ERROR: Game server timeout\n");
+                result = STATE_CRITICAL;
+        }
+        else {
+                printf ("OK: %s (%s), Ping: %s ms\n", ret[qstat_game_field],
+                                                ret[qstat_map_field], ret[qstat_ping_field]);
+        }
+
+        /* close the pipe */
+        pclose (fp);
+
+        return result;
+}
+
+
+
+int
+process_arguments (int argc, char **argv)
+{
+        int x;
+
+        /* not enough options were supplied */
+        if (argc < 3)
+                return ERROR;
+
+        /* first option is always the game type */
+        strncpy (game_type, argv[1], sizeof (game_type) - 1);
+        game_type[sizeof (game_type) - 1] = 0;
+
+        /* Second option is always the server name */
+        strncpy (server_ip, argv[2], sizeof (server_ip) - 1);
+        server_ip[sizeof (server_ip) - 1] = 0;
+
+        /* process all remaining arguments */
+        for (x = 4; x <= argc; x++) {
+
+                /* we got the port number to connect to */
+                if (!strcmp (argv[x - 1], "-p")) {
+                        if (x < argc) {
+                                snprintf (port, sizeof (port) - 2, ":%s", argv[x]);
+                                port[sizeof (port) - 1] = 0;
+                                x++;
+                        }
+                        else
+                                return ERROR;
+                }
+
+                /* we got the game field */
+                else if (!strcmp (argv[x - 1], "-gf")) {
+                        if (x < argc) {
+                                qstat_game_field = atoi (argv[x]);
+                                if (qstat_game_field < 0 || qstat_game_field > QSTAT_MAX_RETURN_ARGS)
+                                        return ERROR;
+                                x++;
+                        }
+                        else
+                                return ERROR;
+                }
+
+                /* we got the map field */
+                else if (!strcmp (argv[x - 1], "-mf")) {
+                        if (x < argc) {
+                                qstat_map_field = atoi (argv[x]);
+                                if (qstat_map_field < 0 || qstat_map_field > QSTAT_MAX_RETURN_ARGS)
+                                        return ERROR;
+                                x++;
+                        }
+                        else
+                                return ERROR;
+                }
+
+                /* we got the ping field */
+                else if (!strcmp (argv[x - 1], "-pf")) {
+                        if (x < argc) {
+                                qstat_ping_field = atoi (argv[x]);
+                                if (qstat_ping_field < 0 || qstat_ping_field > QSTAT_MAX_RETURN_ARGS)
+                                        return ERROR;
+                                x++;
+                        }
+                        else
+                                return ERROR;
+                }
+
+                /* else we got something else... */
+                else
+                        return ERROR;
+        }
+
+        return OK;
+}
diff --git a/plugins/check_hpjd.c b/plugins/check_hpjd.c
new file mode 100644
index 00000000..8234abdf
--- /dev/null
+++ b/plugins/check_hpjd.c
@@ -0,0 +1,571 @@
+/******************************************************************************
+*
+* CHECK_HPJD.C
+*
+* Program: HP printer plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+*
+* Last Modified: $Date$
+*
+* Command line: CHECK_HPJD <ip_address> [community]
+*
+* Description:
+*
+* This plugin will attempt to check the status of an HP printer.  The
+* printer must have a JetDirect card installed and TCP/IP protocol
+* stack enabled.  This plugin has only been tested on a few printers
+* and may not work well on all models of JetDirect cards.  Multiple
+* port JetDirect devices must have an IP address assigned to each
+* port in order to be monitored.
+*
+* Dependencies:
+*
+* This plugin used the 'snmpget' command included with the UCD-SNMP
+* package.  If you don't have the package installed you will need to
+* download it from http://ucd-snmp.ucdavis.edu before you can use
+* this plugin.
+*
+* Return Values:
+*
+* UNKNOWN       = The plugin could not read/process the output from the printer
+* OK            = Printer looks normal
+* WARNING       = Low toner, paper jam, intervention required, paper out, etc.
+* CRITICAL      = The printer could not be reached (it's probably turned off)
+*
+* Acknowledgements:
+*
+* The idea for the plugin (as well as some code) were taken from Jim
+* Trocki's pinter alert script in his "mon" utility, found at
+* http://www.kernel.org/software/mon
+*
+* Notes:
+* 'JetDirect' is copyrighted by Hewlett-Packard.  
+*                    HP, please don't sue me... :-)
+*
+* 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"
+
+#define PROGNAME "check_hpjd"
+
+#define HPJD_LINE_STATUS                ".1.3.6.1.4.1.11.2.3.9.1.1.2.1"
+#define HPJD_PAPER_STATUS               ".1.3.6.1.4.1.11.2.3.9.1.1.2.2"
+#define HPJD_INTERVENTION_REQUIRED      ".1.3.6.1.4.1.11.2.3.9.1.1.2.3"
+#define HPJD_GD_PERIPHERAL_ERROR        ".1.3.6.1.4.1.11.2.3.9.1.1.2.6"
+#define HPJD_GD_PAPER_JAM               ".1.3.6.1.4.1.11.2.3.9.1.1.2.8"
+#define HPJD_GD_PAPER_OUT               ".1.3.6.1.4.1.11.2.3.9.1.1.2.9"
+#define HPJD_GD_TONER_LOW               ".1.3.6.1.4.1.11.2.3.9.1.1.2.10"
+#define HPJD_GD_PAGE_PUNT               ".1.3.6.1.4.1.11.2.3.9.1.1.2.11"
+#define HPJD_GD_MEMORY_OUT              ".1.3.6.1.4.1.11.2.3.9.1.1.2.12"
+#define HPJD_GD_DOOR_OPEN               ".1.3.6.1.4.1.11.2.3.9.1.1.2.17"
+#define HPJD_GD_PAPER_OUTPUT            ".1.3.6.1.4.1.11.2.3.9.1.1.2.19"
+#define HPJD_GD_STATUS_DISPLAY          ".1.3.6.1.4.1.11.2.3.9.1.1.3"
+
+#define ONLINE          0
+#define OFFLINE         1
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+void print_help (void);
+void print_usage (void);
+
+char *community = NULL;
+char *address = NULL;
+
+int
+main (int argc, char **argv)
+{
+        char command_line[1024];
+        int result;
+        int line;
+        char input_buffer[MAX_INPUT_BUFFER];
+        char query_string[512];
+        char error_message[MAX_INPUT_BUFFER];
+        char *temp_buffer;
+        int line_status = ONLINE;
+        int paper_status = 0;
+        int intervention_required = 0;
+        int peripheral_error = 0;
+        int paper_jam = 0;
+        int paper_out = 0;
+        int toner_low = 0;
+        int page_punt = 0;
+        int memory_out = 0;
+        int door_open = 0;
+        int paper_output = 0;
+        char display_message[MAX_INPUT_BUFFER];
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* removed ' 2>1' at end of command 10/27/1999 - EG */
+        /* create the query string */
+        sprintf
+                (query_string,
+                 "%s.0 %s.0 %s.0 %s.0 %s.0 %s.0 %s.0 %s.0 %s.0 %s.0 %s.0 %s.0",
+                 HPJD_LINE_STATUS,
+                 HPJD_PAPER_STATUS,
+                 HPJD_INTERVENTION_REQUIRED,
+                 HPJD_GD_PERIPHERAL_ERROR,
+                 HPJD_GD_PAPER_JAM,
+                 HPJD_GD_PAPER_OUT,
+                 HPJD_GD_TONER_LOW,
+                 HPJD_GD_PAGE_PUNT,
+                 HPJD_GD_MEMORY_OUT,
+                 HPJD_GD_DOOR_OPEN, HPJD_GD_PAPER_OUTPUT, HPJD_GD_STATUS_DISPLAY);
+
+        /* get the command to run */
+        sprintf (command_line, "%s -v 1 %s %s %s", PATH_TO_SNMPGET, address,
+                                         community, query_string);
+
+        /* 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);
+        }
+
+        result = STATE_OK;
+
+        line = 0;
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+
+                /* strip the newline character from the end of the input */
+                if (input_buffer[strlen (input_buffer) - 1] == '\n')
+                        input_buffer[strlen (input_buffer) - 1] = 0;
+
+                line++;
+
+                temp_buffer = strtok (input_buffer, "=");
+                temp_buffer = strtok (NULL, "=");
+
+                switch (line) {
+
+                case 1:                                                                         /* 1st line should contain the line status */
+                        if (temp_buffer != NULL)
+                                line_status = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 2:                                                                         /* 2nd line should contain the paper status */
+                        if (temp_buffer != NULL)
+                                paper_status = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 3:                                                                         /* 3rd line should be intervention required */
+                        if (temp_buffer != NULL)
+                                intervention_required = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 4:                                                                         /* 4th line should be peripheral error */
+                        if (temp_buffer != NULL)
+                                peripheral_error = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 5:                                                                         /* 5th line should contain the paper jam status */
+                        if (temp_buffer != NULL)
+                                paper_jam = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 6:                                                                         /* 6th line should contain the paper out status */
+                        if (temp_buffer != NULL)
+                                paper_out = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 7:                                                                         /* 7th line should contain the toner low status */
+                        if (temp_buffer != NULL)
+                                toner_low = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 8:                                                                         /* did data come too slow for engine */
+                        if (temp_buffer != NULL)
+                                page_punt = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 9:                                                                         /* did we run out of memory */
+                        if (temp_buffer != NULL)
+                                memory_out = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 10:                                                                                /* is there a door open */
+                        if (temp_buffer != NULL)
+                                door_open = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 11:                                                                                /* is output tray full */
+                        if (temp_buffer != NULL)
+                                paper_output = atoi (temp_buffer);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                case 12:                                                                                /* display panel message */
+                        if (temp_buffer != NULL)
+                                strcpy (display_message, temp_buffer + 1);
+                        else {
+                                result = STATE_UNKNOWN;
+                                strcpy (error_message, input_buffer);
+                        }
+                        break;
+
+                default:
+                        break;
+                }
+
+                /* break out of the read loop if we encounter an error */
+                if (result != STATE_OK)
+                        break;
+        }
+
+        /* WARNING if output found on stderr */
+        if (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
+                result = max (result, STATE_WARNING);
+
+        /* close stderr */
+        (void) fclose (child_stderr);
+
+        /* close the pipe */
+        if (spclose (child_process))
+                result = max (result, STATE_WARNING);
+
+        /* if there wasn't any output, display an error */
+        if (line == 0) {
+
+                /*
+                   result=STATE_UNKNOWN;
+                   strcpy(error_message,"Error: Could not read plugin output\n");
+                 */
+
+                /* might not be the problem, but most likely is.. */
+                result = STATE_UNKNOWN;
+                sprintf (error_message, "Timeout: No response from %s\n", address);
+        }
+
+        /* if we had no read errors, check the printer status results... */
+        if (result == STATE_OK) {
+
+                if (paper_jam) {
+                        result = STATE_WARNING;
+                        strcpy (error_message, "Paper Jam");
+                }
+                else if (paper_out) {
+                        result = STATE_WARNING;
+                        strcpy (error_message, "Out of Paper");
+                }
+                else if (line_status == OFFLINE) {
+                        if (strcmp (error_message, "POWERSAVE ON") != 0) {
+                                result = STATE_WARNING;
+                                strcpy (error_message, "Printer Offline");
+                        }
+                }
+                else if (peripheral_error) {
+                        result = STATE_WARNING;
+                        strcpy (error_message, "Peripheral Error");
+                }
+                else if (intervention_required) {
+                        result = STATE_WARNING;
+                        strcpy (error_message, "Intervention Required");
+                }
+                else if (toner_low) {
+                        result = STATE_WARNING;
+                        strcpy (error_message, "Toner Low");
+                }
+                else if (memory_out) {
+                        result = STATE_WARNING;
+                        strcpy (error_message, "Insufficient Memory");
+                }
+                else if (door_open) {
+                        result = STATE_WARNING;
+                        strcpy (error_message, "A Door is Open");
+                }
+                else if (paper_output) {
+                        result = STATE_WARNING;
+                        strcpy (error_message, "Output Tray is Full");
+                }
+                else if (page_punt) {
+                        result = STATE_WARNING;
+                        strcpy (error_message, "Data too Slow for Engine");
+                }
+                else if (paper_status) {
+                        result = STATE_WARNING;
+                        strcpy (error_message, "Unknown Paper Error");
+                }
+        }
+
+        if (result == STATE_OK)
+                printf ("Printer ok - (%s)\n", display_message);
+
+        else if (result == STATE_UNKNOWN) {
+
+                printf ("%s\n", error_message);
+
+                /* if printer could not be reached, escalate to critical */
+                if (strstr (error_message, "Timeout"))
+                        result = STATE_CRITICAL;
+        }
+
+        else if (result == STATE_WARNING)
+                printf ("%s (%s)\n", error_message, display_message);
+
+        return result;
+}
+
+
+
+
+
+/* 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");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (address == NULL) {
+                        if (is_host (argv[c])) {
+                                address = argv[c];
+                        }
+                        else {
+                                usage ("Invalid host name");
+                        }
+                }
+                else if (community == NULL) {
+                        community = argv[c];
+                }
+        }
+
+        if (address == NULL)
+                address = strscpy (NULL, "127.0.0.1");
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"expect", required_argument, 0, 'e'},
+/*              {"critical",       required_argument,0,'c'}, */
+/*              {"warning",        required_argument,0,'w'}, */
+/*              {"port",           required_argument,0,'P'}, */
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c = getopt_long (argc, argv, "+hVH:C:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+?hVH:C:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 'H':
+                case 'C':
+                        i++;
+                }
+
+                switch (c) {
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg)) {
+                                address = optarg;
+                        }
+                        else {
+                                usage ("Invalid host name\n");
+                        }
+                        break;
+                case 'C':                                                                       /* community */
+                        community = optarg;
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        return OK;
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Ethan Galstad/Karl DeBisschop\n\n"
+                 "This plugin tests the STATUS of an HP printer with a JetDirect card.\n"
+                 "Ucd-snmp must be installed on the computer running the plugin.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -H, --hostname=STRING or IPADDRESS\n"
+                 "   Check server on the indicated host\n"
+                 " -C, --community=STRING\n"
+                 "   The SNMP community name\n"
+                 " -h, --help\n"
+                 "   Print detailed help screen\n"
+                 " -V, --version\n" "   Print version information\n\n");
+        support ();
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H host [-C community]\n"
+                 "       %s --help\n"
+                 "       %s --version\n", PROGNAME, PROGNAME, PROGNAME);
+}
+
+
+/*
+        if(argc<2||argc>3){
+        printf("Incorrect number of arguments supplied\n");
+        printf("\n");
+        print_revision(argv[0],"$Revision$");
+        printf("Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)\n");
+        printf("License: GPL\n");
+        printf("\n");
+        printf("Usage: %s <ip_address> [community]\n",argv[0]);
+        printf("\n");
+        printf("Note:\n");
+        printf(" <ip_address>     = The IP address of the JetDirect card\n");
+        printf(" [community]      = An optional community string used for SNMP communication\n");
+        printf("                    with the JetDirect card.  The default is 'public'.\n");
+        printf("\n");
+        return STATE_UNKNOWN;
+        }
+
+        // get the IP address of the JetDirect device
+        strcpy(address,argv[1]);
+        
+        // get the community name to use for SNMP communication
+        if(argc>=3)
+        strcpy(community,argv[2]);
+        else
+        strcpy(community,"public");
+*/
diff --git a/plugins/check_http.c b/plugins/check_http.c
new file mode 100644
index 00000000..db5d50dd
--- /dev/null
+++ b/plugins/check_http.c
@@ -0,0 +1,1067 @@
+/****************************************************************************
+ *
+ * Program: HTTP plugin for Nagios
+ * License: GPL
+ *
+ * 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.
+ *
+ * $Id$
+ *
+ *****************************************************************************/
+
+#define PROGNAME "check_http"
+#define REVISION "$Revision$"
+#define COPYRIGHT "1999-2001"
+#define AUTHORS "Ethan Galstad/Karl DeBisschop"
+#define EMAIL "kdebisschop@users.sourceforge.net"
+
+#include "config.h"
+#include "common.h"
+#include "version.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define SUMMARY "\
+This plugin tests the HTTP service on the specified host. It can test\n\
+normal (http) and secure (https) servers, follow redirects, search for\n\
+strings and regular expressions, check connection times, and report on\n\
+certificate expiration times.\n"
+
+#define OPTIONS "\
+\(-H <vhost> | -I <IP-address>) [-u <uri>] [-p <port>]\n\
+            [-w <warn time>] [-c <critical time>] [-t <timeout>] [-L]\n\
+            [-a auth] [-f <ok | warn | critcal | follow>] [-e <expect>]\n\
+            [-s string] [-r <regex> | -R <case-insensitive regex>]\n\
+            [-P string]"
+
+#define LONGOPTIONS "\
+ -H, --hostname=ADDRESS\n\
+    Host name argument for servers using host headers (virtual host)\n\
+ -I, --IP-address=ADDRESS\n\
+   IP address or name (use numeric address if possible to bypass DNS lookup).\n\
+ -e, --expect=STRING\n\
+   String to expect in first line of server response (default: %s)\n\
+ -s, --string=STRING\n\
+   String to expect in the content\n\
+ -u, --url=PATH\n\
+   URL to GET or POST (default: /)\n\
+ -p, --port=INTEGER\n\
+   Port number (default: %d)\n\
+ -P, --post=STRING\n\
+   URL encoded http POST data\n\
+ -w, --warning=INTEGER\n\
+   Response time to result in warning status (seconds)\n\
+ -c, --critical=INTEGER\n\
+   Response time to result in critical status (seconds)\n\
+ -t, --timeout=INTEGER\n\
+   Seconds before connection times out (default: %d)\n\
+ -a, --authorization=AUTH_PAIR\n\
+   Username:password on sites with basic authentication\n\
+ -L, --link=URL\n\
+   Wrap output in HTML link (obsoleted by urlize)\n\
+ -f, --onredirect=<ok|warning|critical|follow>\n\
+   How to handle redirected pages\n%s\
+ -v, --verbose\n\
+    Show details for command-line debugging (do not use with nagios server)\n\
+ -h, --help\n\
+    Print detailed help screen\n\
+ -V, --version\n\
+    Print version information\n"
+
+#ifdef HAVE_SSL
+#define SSLOPTIONS "\
+ -S, --ssl\n\
+    Connect via SSL\n\
+ -C, --certificate=INTEGER\n\
+    Minimum number of days a certificate has to be valid.\n\
+    (when this option is used the url is not checked.)\n"
+#else
+#define SSLOPTIONS ""
+#endif
+
+#define DESCRIPTION "\
+This plugin will attempt to open an HTTP connection with the host. Successul\n\
+connects return STATE_OK, refusals and timeouts return STATE_CRITICAL, other\n\
+errors return STATE_UNKNOWN.  Successful connects, but incorrect reponse\n\
+messages from the host result in STATE_WARNING return values.  If you are\n\
+checking a virtual server that uses \"host headers\" you must supply the FQDN\n\
+\(fully qualified domain name) as the [host_name] argument.\n"
+
+#define SSLDESCRIPTION "\
+This plugin can also check whether an SSL enabled web server is able to\n\
+serve content (optionally within a specified time) or whether the X509 \n\
+certificate is still valid for the specified number of days.\n\n\
+CHECK CONTENT: check_http -w 5 -c 10 --ssl www.verisign.com\n\n\
+When the 'www.verisign.com' server returns its content within 5 seconds, a\n\
+STATE_OK will be returned. When the server returns its content but exceeds\n\
+the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,\n\
+a STATE_CRITICAL will be returned.\n\n\
+CHECK CERTIFICATE: check_http www.verisign.com -C 14\n\n\
+When the certificate of 'www.verisign.com' is valid for more than 14 days, a\n\
+STATE_OK is returned. When the certificate is still valid, but for less than\n\
+14 days, a STATE_WARNING is returned. A STATE_CRITICAL will be returned when\n\
+the certificate is expired.\n"
+
+#ifdef HAVE_SSL_H
+#include <rsa.h>
+#include <crypto.h>
+#include <x509.h>
+#include <pem.h>
+#include <ssl.h>
+#include <err.h>
+#include <rand.h>
+#endif
+
+#ifdef HAVE_OPENSSL_SSL_H
+#include <openssl/rsa.h>
+#include <openssl/crypto.h>
+#include <openssl/x509.h>
+#include <openssl/pem.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#include <openssl/rand.h>
+#endif
+
+#ifdef HAVE_SSL
+int check_cert = FALSE;
+int days_till_exp;
+unsigned char *randbuff;
+SSL_CTX *ctx;
+SSL *ssl;
+X509 *server_cert;
+int connect_SSL (void);
+int check_certificate (X509 **);
+#endif
+
+#ifdef HAVE_REGEX_H
+#define REGS 2
+#define MAX_RE_SIZE 256
+#include <regex.h>
+regex_t preg;
+regmatch_t pmatch[REGS];
+char regexp[MAX_RE_SIZE];
+char errbuf[MAX_INPUT_BUFFER];
+int cflags = REG_NOSUB | REG_EXTENDED | REG_NEWLINE;
+int errcode;
+#endif
+
+#define server_type_check(server_type) \
+(strcmp (server_type, "https") ? FALSE : TRUE)
+
+#define server_port_check(use_ssl) (use_ssl ? HTTPS_PORT : HTTP_PORT)
+
+#define MAX_IPV4_HOSTLENGTH 64
+#define HDR_LOCATION "%*[Ll]%*[Oo]%*[Cc]%*[Aa]%*[Tt]%*[Ii]%*[Oo]%*[Nn]: "
+#define URI_HTTP "%[HTPShtps]://"
+#define URI_HOST "%[a-zA-Z0-9.-]"
+#define URI_PORT ":%[0-9]"
+#define URI_PATH "%[/a-zA-Z0-9._-=@,]"
+
+#define HTTP_PORT 80
+#define HTTPS_PORT 443
+#define HTTP_EXPECT "HTTP/1."
+#define HTTP_URL "/"
+
+time_t start_time, end_time;
+char timestamp[10] = "";
+int specify_port = FALSE;
+int server_port = HTTP_PORT;
+char server_port_text[6] = "";
+char server_type[6] = "http";
+char *server_address = NULL;
+char *host_name = NULL;
+char *server_url = NULL;
+int server_url_length = 0;
+char server_expect[MAX_INPUT_BUFFER] = HTTP_EXPECT;
+char string_expect[MAX_INPUT_BUFFER] = "";
+int warning_time = 0;
+int check_warning_time = FALSE;
+int critical_time = 0;
+int check_critical_time = FALSE;
+char user_auth[MAX_INPUT_BUFFER] = "";
+int display_html = FALSE;
+int onredirect = STATE_OK;
+int use_ssl = FALSE;
+int verbose = FALSE;
+int sd;
+char *http_method = NULL;
+char *http_post_data = NULL;
+char buffer[MAX_INPUT_BUFFER];
+
+void print_usage (void);
+void print_help (void);
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+static char *base64 (char *bin, int len);
+int check_http (void);
+int my_recv (void);
+int my_close (void);
+
+int
+main (int argc, char **argv)
+{
+        int result = STATE_UNKNOWN;
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("check_http: could not parse arguments\n");
+
+        if (strstr (timestamp, ":")) {
+                if (strstr (server_url, "?"))
+                        sprintf (server_url, "%s&%s", server_url, timestamp);
+                else
+                        sprintf (server_url, "%s?%s", server_url, timestamp);
+        }
+
+        if (display_html == TRUE)
+                printf ("<A HREF=\"http://%s:%d%s\" target=\"_blank\">",
+                        host_name, server_port, server_url);
+
+        /* initialize alarm signal handling, set socket timeout, start timer */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+        alarm (socket_timeout);
+        time (&start_time);
+
+#ifdef HAVE_SSL
+        if (use_ssl && check_cert == TRUE) {
+                if (connect_SSL () != OK)
+                        terminate (STATE_CRITICAL,
+                                   "HTTP CRITICAL - Could not make SSL connection\n");
+                if ((server_cert = SSL_get_peer_certificate (ssl)) != NULL) {
+                        result = check_certificate (&server_cert);
+                        X509_free (server_cert);
+                }
+                else {
+                        printf ("ERROR: Cannot retrieve server certificate.\n");
+                        result = STATE_CRITICAL;
+                }
+                SSL_shutdown (ssl);
+                SSL_free (ssl);
+                SSL_CTX_free (ctx);
+                close (sd);
+        }
+        else {
+                result = check_http ();
+        }
+#else
+        result = check_http ();
+#endif
+        return result;
+}
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c, i = 1;
+        char optchars[MAX_INPUT_BUFFER];
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                STD_OPTS_LONG,
+                {"link", no_argument, 0, 'L'},
+                {"nohtml", no_argument, 0, 'n'},
+                {"ssl", no_argument, 0, 'S'},
+                {"verbose", no_argument, 0, 'v'},
+                {"post", required_argument, 0, 'P'},
+                {"IP-address", required_argument, 0, 'I'},
+                {"string", required_argument, 0, 's'},
+                {"regex", required_argument, 0, 'r'},
+                {"ereg", required_argument, 0, 'r'},
+                {"eregi", required_argument, 0, 'R'},
+                {"onredirect", required_argument, 0, 'f'},
+                {"certificate", required_argument, 0, 'C'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        if (argc < 2)
+                return ERROR;
+
+        for (c = 1; c < argc; c++) {
+                if (strcmp ("-to", argv[c]) == 0)
+                        strcpy (argv[c], "-t");
+                if (strcmp ("-hn", argv[c]) == 0)
+                        strcpy (argv[c], "-H");
+                if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+                if (strcmp ("-nohtml", argv[c]) == 0)
+                        strcpy (argv[c], "-n");
+        }
+
+        snprintf (optchars, MAX_INPUT_BUFFER, "%s%s", STD_OPTS,
+                  "P:I:a:e:p:s:R:r:u:f:C:nLS");
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c = getopt_long (argc, argv, optchars, long_options, &option_index);
+#else
+                c = getopt (argc, argv, optchars);
+#endif
+                if (c == -1 || c == EOF)
+                        break;
+
+                switch (c) {
+                case '?': /* usage */
+                        usage2 ("unknown argument", optarg);
+                        break;
+                case 'h': /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                        break;
+                case 'V': /* version */
+                        print_revision (PROGNAME, REVISION);
+                        exit (STATE_OK);
+                        break;
+                case 't': /* timeout period */
+                        if (!is_intnonneg (optarg))
+                                usage2 ("timeout interval must be a non-negative integer", optarg);
+                        socket_timeout = atoi (optarg);
+                        break;
+                case 'c': /* critical time threshold */
+                        if (!is_intnonneg (optarg))
+                                usage2 ("invalid critical threshold", optarg);
+                        critical_time = atoi (optarg);
+                        check_critical_time = TRUE;
+                        break;
+                case 'w': /* warning time threshold */
+                        if (!is_intnonneg (optarg))
+                                usage2 ("invalid warning threshold", optarg);
+                        warning_time = atoi (optarg);
+                        check_warning_time = TRUE;
+                        break;
+                case 'L': /* show html link */
+                        display_html = TRUE;
+                        break;
+                case 'n': /* do not show html link */
+                        display_html = FALSE;
+                        break;
+                case 'S': /* use SSL */
+#ifndef HAVE_SSL
+                        usage ("check_http: invalid option - SSL is not available\n");
+#endif
+                        use_ssl = TRUE;
+                        if (specify_port == FALSE)
+                                server_port = HTTPS_PORT;
+                        break;
+                case 'C': /* warning time threshold */
+#ifdef HAVE_SSL
+                        if (!is_intnonneg (optarg))
+                                usage2 ("invalid certificate expiration period", optarg);
+                        days_till_exp = atoi (optarg);
+                        check_cert = TRUE;
+#else
+                        usage ("check_http: invalid option - SSL is not available\n");
+#endif
+                        break;
+                case 'f': /* onredirect */
+                        if (!strcmp (optarg, "follow"))
+                                onredirect = STATE_DEPENDENT;
+                        if (!strcmp (optarg, "unknown"))
+                                onredirect = STATE_UNKNOWN;
+                        if (!strcmp (optarg, "ok"))
+                                onredirect = STATE_OK;
+                        if (!strcmp (optarg, "warning"))
+                                onredirect = STATE_WARNING;
+                        if (!strcmp (optarg, "critical"))
+                                onredirect = STATE_CRITICAL;
+                        break;
+                /* Note: H, I, and u must be malloc'd or will fail on redirects */
+                case 'H': /* Host Name (virtual host) */
+                        host_name = strscpy (host_name, optarg);
+                        break;
+                case 'I': /* Server IP-address */
+                        server_address = strscpy (server_address, optarg);
+                        break;
+                case 'u': /* Host or server */
+                        server_url = strscpy (server_url, optarg);
+                        server_url_length = strlen (optarg);
+                        break;
+                case 'p': /* Host or server */
+                        if (!is_intnonneg (optarg))
+                                usage2 ("invalid port number", optarg);
+                        server_port = atoi (optarg);
+                        specify_port = TRUE;
+                        break;
+                case 'a': /* authorization info */
+                        strncpy (user_auth, optarg, MAX_INPUT_BUFFER - 1);
+                        user_auth[MAX_INPUT_BUFFER - 1] = 0;
+                        break;
+                case 'P': /* HTTP POST data in URL encoded format */
+                        http_method = strscpy (http_method, "POST");
+                        http_post_data = strscpy (http_post_data, optarg);
+                        break;
+                case 's': /* string or substring */
+                        strncpy (string_expect, optarg, MAX_INPUT_BUFFER - 1);
+                        string_expect[MAX_INPUT_BUFFER - 1] = 0;
+                        break;
+                case 'e': /* string or substring */
+                        strncpy (server_expect, optarg, MAX_INPUT_BUFFER - 1);
+                        server_expect[MAX_INPUT_BUFFER - 1] = 0;
+                        break;
+                case 'R': /* regex */
+#ifdef HAVE_REGEX_H
+                        cflags = REG_ICASE;
+#else
+                        usage ("check_http: call for regex which was not a compiled option\n");
+#endif
+                case 'r': /* regex */
+#ifdef HAVE_REGEX_H
+                        cflags |= REG_EXTENDED | REG_NOSUB | REG_NEWLINE;
+                        strncpy (regexp, optarg, MAX_INPUT_BUFFER - 1);
+                        regexp[MAX_INPUT_BUFFER - 1] = 0;
+                        errcode = regcomp (&preg, regexp, cflags);
+                        if (errcode != 0) {
+                                regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
+                                printf ("Could Not Compile Regular Expression: %s", errbuf);
+                                return ERROR;
+                        }
+#else
+                        usage ("check_http: call for regex which was not a compiled option\n");
+#endif
+                        break;
+                case 'v': /* verbose */
+                        verbose = TRUE;
+                        break;
+                }
+        }
+
+        c = optind;
+
+        if (server_address == NULL && host_name == NULL) {
+                server_address = strscpy (NULL, argv[c]);
+                host_name = strscpy (NULL, argv[c++]);
+        }
+
+        if (server_address == NULL && host_name == NULL)
+                usage ("check_http: you must specify a host name\n");
+
+        if (server_address == NULL)
+                server_address = strscpy (NULL, host_name);
+
+        if (host_name == NULL)
+                host_name = strscpy (NULL, server_address);
+
+        if (http_method == NULL)
+                http_method = strscpy (http_method, "GET");
+
+        if (server_url == NULL) {
+                server_url = strscpy (NULL, "/");
+                server_url_length = strlen(HTTP_URL);
+        }
+
+        return TRUE;
+}
+
+
+
+/* written by lauri alanko */
+static char *
+base64 (char *bin, int len)
+{
+
+        char *buf = (char *) malloc ((len + 2) / 3 * 4 + 1);
+        int i = 0, j = 0;
+
+        char BASE64_END = '=';
+        char base64_table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                "abcdefghijklmnopqrstuvwxyz"
+                "0123456789+/";
+
+        while (j < len - 2) {
+                buf[i++] = base64_table[bin[j] >> 2];
+                buf[i++] = base64_table[((bin[j] & 3) << 4) | (bin[j + 1] >> 4)];
+                buf[i++] = base64_table[((bin[j + 1] & 15) << 2) | (bin[j + 2] >> 6)];
+                buf[i++] = base64_table[bin[j + 2] & 63];
+                j += 3;
+        }
+
+        switch (len - j) {
+        case 1:
+                buf[i++] = base64_table[bin[j] >> 2];
+                buf[i++] = base64_table[(bin[j] & 3) << 4];
+                buf[i++] = BASE64_END;
+                buf[i++] = BASE64_END;
+                break;
+        case 2:
+                buf[i++] = base64_table[bin[j] >> 2];
+                buf[i++] = base64_table[((bin[j] & 3) << 4) | (bin[j + 1] >> 4)];
+                buf[i++] = base64_table[(bin[j + 1] & 15) << 2];
+                buf[i++] = BASE64_END;
+                break;
+        case 0:
+                break;
+        }
+
+        buf[i] = '\0';
+        return buf;
+}
+
+
+
+int
+check_http (void)
+{
+        char *msg = NULL;
+        char *status_line = NULL;
+        char *header = NULL;
+        char *page = NULL;
+        char *auth = NULL;
+        int i = 0;
+        size_t pagesize = 0;
+        char *full_page = NULL;
+        char *pos = NULL;
+
+        /* try to connect to the host at the given port number */
+#ifdef HAVE_SSL
+        if (use_ssl == TRUE) {
+
+                if (connect_SSL () != OK) {
+                        msg = ssprintf (msg, "Unable to open TCP socket");
+                        terminate (STATE_CRITICAL, msg);
+                }
+
+                if ((server_cert = SSL_get_peer_certificate (ssl)) != NULL) {
+                        X509_free (server_cert);
+                }
+                else {
+                        printf ("ERROR: Cannot retrieve server certificate.\n");
+                        return STATE_CRITICAL;
+                }
+
+                sprintf (buffer, "%s %s HTTP/1.0\r\n", http_method, server_url);
+                if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
+                        ERR_print_errors_fp (stderr);
+                        return STATE_CRITICAL;
+                }
+
+                /* optionally send the host header info (not clear if it's usable) */
+                if (strcmp (host_name, "")) {
+                        sprintf (buffer, "Host: %s\r\n", host_name);
+                        if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
+                                ERR_print_errors_fp (stderr);
+                                return STATE_CRITICAL;
+                        }
+                }
+
+                /* send user agent */
+                sprintf (buffer, "User-Agent: check_http/%s (nagios-plugins %s)\r\n",
+                         clean_revstring (REVISION), PACKAGE_VERSION);
+                if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
+                        ERR_print_errors_fp (stderr);
+                        return STATE_CRITICAL;
+                }
+
+                /* optionally send the authentication info */
+                if (strcmp (user_auth, "")) {
+                        auth = base64 (user_auth, strlen (user_auth));
+                        sprintf (buffer, "Authorization: Basic %s\r\n", auth);
+                        if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
+                                ERR_print_errors_fp (stderr);
+                                return STATE_CRITICAL;
+                        }
+                }
+
+                /* optionally send http POST data */
+                if (http_post_data) {
+                        sprintf (buffer, "Content-Type: application/x-www-form-urlencoded\r\n");
+                        if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
+                                ERR_print_errors_fp (stderr);
+                                return STATE_CRITICAL;
+                        }
+                        sprintf (buffer, "Content-Length: %i\r\n\r\n", strlen (http_post_data));
+                        if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
+                                ERR_print_errors_fp (stderr);
+                                return STATE_CRITICAL;
+                        }
+                        http_post_data = strscat (http_post_data, "\r\n");
+                        if (SSL_write (ssl, http_post_data, strlen (http_post_data)) == -1) {
+                                ERR_print_errors_fp (stderr);
+                                return STATE_CRITICAL;
+                        }
+                }
+
+                /* send a newline so the server knows we're done with the request */
+                sprintf (buffer, "\r\n\r\n");
+                if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
+                        ERR_print_errors_fp (stderr);
+                        return STATE_CRITICAL;
+                }
+
+        }
+        else {
+#endif
+                if (my_tcp_connect (server_address, server_port, &sd) != STATE_OK) {
+                        msg = ssprintf (msg, "Unable to open TCP socket");
+                        terminate (STATE_CRITICAL, msg);
+                }
+                sprintf (buffer, "%s %s HTTP/1.0\r\n", http_method, server_url);
+                send (sd, buffer, strlen (buffer), 0);
+
+                /* optionally send the host header info */
+                if (strcmp (host_name, "")) {
+                        sprintf (buffer, "Host: %s\r\n", host_name);
+                        send (sd, buffer, strlen (buffer), 0);
+                }
+
+                /* send user agent */
+                sprintf (buffer,
+                         "User-Agent: check_http/%s (nagios-plugins %s)\r\n",
+                         clean_revstring (REVISION), PACKAGE_VERSION);
+                send (sd, buffer, strlen (buffer), 0);
+
+                /* optionally send the authentication info */
+                if (strcmp (user_auth, "")) {
+                        auth = base64 (user_auth, strlen (user_auth));
+                        sprintf (buffer, "Authorization: Basic %s\r\n", auth);
+                        send (sd, buffer, strlen (buffer), 0);
+                }
+
+                /* optionally send http POST data */
+                /* written by Chris Henesy <lurker@shadowtech.org> */
+                if (http_post_data) {
+                        sprintf (buffer, "Content-Type: application/x-www-form-urlencoded\r\n");
+                        send (sd, buffer, strlen (buffer), 0);
+                        sprintf (buffer, "Content-Length: %i\r\n\r\n", strlen (http_post_data));
+                        send (sd, buffer, strlen (buffer), 0);
+                        http_post_data = strscat (http_post_data, "\r\n");
+                        send (sd, http_post_data, strlen (http_post_data), 0);
+                }
+
+                /* send a newline so the server knows we're done with the request */
+                sprintf (buffer, "\r\n\r\n");
+                send (sd, buffer, strlen (buffer), 0);
+#ifdef HAVE_SSL
+        }
+#endif
+
+        /* fetch the page */
+        pagesize = (size_t) 0;
+        while ((i = my_recv ()) > 0) {
+                full_page = strscat (full_page, buffer);
+                pagesize += i;
+        }
+
+        if (i < 0)
+                terminate (STATE_CRITICAL, "Error in recv()");
+
+        /* return a CRITICAL status if we couldn't read any data */
+        if (pagesize == (size_t) 0)
+                terminate (STATE_CRITICAL, "No data received %s", timestamp);
+
+        /* close the connection */
+        my_close ();
+
+        /* reset the alarm */
+        alarm (0);
+
+        /* leave full_page untouched so we can free it later */
+        page = full_page;
+
+        if (verbose)
+                printf ("Page is %d characters\n", pagesize);
+
+        /* find status line and null-terminate it */
+        status_line = page;
+        page += (size_t) strcspn (page, "\r\n");
+        pos = page;
+        page += (size_t) strspn (page, "\r\n");
+        status_line[pos - status_line] = 0;
+        strip (status_line);
+        if (verbose)
+                printf ("STATUS: %s\n", status_line);
+
+        /* find header info and null terminate it */
+        header = page;
+        while (strcspn (page, "\r\n") > 0) {
+                page += (size_t) strcspn (page, "\r\n");
+                pos = page;
+                if ((strspn (page, "\r") == 1 && strspn (page, "\r\n") >= 2) ||
+                    (strspn (page, "\n") == 1 && strspn (page, "\r\n") >= 2))
+                        page += (size_t) 2;
+                else
+                        page += (size_t) 1;
+        }
+        page += (size_t) strspn (page, "\r\n");
+        header[pos - header] = 0;
+        if (verbose)
+                printf ("**** HEADER ****\n%s\n**** CONTENT ****\n%s\n", header, page);
+
+        /* make sure the status line matches the response we are looking for */
+        if (!strstr (status_line, server_expect)) {
+                if (server_port == HTTP_PORT)
+                        msg = ssprintf (msg, "Invalid HTTP response received from host\n");
+                else
+                        msg = ssprintf (msg,
+                                        "Invalid HTTP response received from host on port %d\n",
+                                        server_port);
+                terminate (STATE_CRITICAL, msg);
+        }
+
+        /* check the return code */
+        /* server errors result in a critical state */
+        if (strstr (status_line, "500") ||
+            strstr (status_line, "501") ||
+            strstr (status_line, "502") ||
+            strstr (status_line, "503")) {
+                msg = ssprintf (msg, "HTTP CRITICAL: %s\n", status_line);
+                terminate (STATE_CRITICAL, msg);
+        }
+
+        /* client errors result in a warning state */
+        if (strstr (status_line, "400") ||
+            strstr (status_line, "401") ||
+            strstr (status_line, "402") ||
+            strstr (status_line, "403") ||
+            strstr (status_line, "404")) {
+                msg = ssprintf (msg, "HTTP WARNING: %s\n", status_line);
+                terminate (STATE_WARNING, msg);
+        }
+
+        /* check redirected page if specified */
+        if (strstr (status_line, "300") ||
+            strstr (status_line, "301") ||
+            strstr (status_line, "302") ||
+            strstr (status_line, "303") ||
+            strstr (status_line, "304")) {
+                if (onredirect == STATE_DEPENDENT) {
+                        
+                        pos = header;
+                        while (pos) {
+                                server_address = realloc (server_address, MAX_IPV4_HOSTLENGTH);
+                                if (server_address == NULL)
+                                        terminate (STATE_UNKNOWN,
+                                                                                 "HTTP UNKNOWN: could not allocate server_address");
+                                if (strspn (pos, "\r\n") > server_url_length) {
+                                        server_url = realloc (server_url, strspn (pos, "\r\n"));
+                                        if (server_url == NULL)
+                                                terminate (STATE_UNKNOWN,
+                                                                                         "HTTP UNKNOWN: could not allocate server_url");
+                                        server_url_length = strspn (pos, "\r\n");
+                                }
+                                if (sscanf (pos, HDR_LOCATION URI_HTTP URI_HOST URI_PORT URI_PATH, server_type, server_address, server_port_text, server_url) == 4) {
+                                        host_name = strscpy (host_name, server_address);
+                                        use_ssl = server_type_check (server_type);
+                                        server_port = atoi (server_port_text);
+                                        check_http ();
+                                }
+                                else if (sscanf (pos, HDR_LOCATION URI_HTTP URI_HOST URI_PATH, server_type, server_address, server_url) == 3) {
+                                        host_name = strscpy (host_name, server_address);
+                                        use_ssl = server_type_check (server_type);
+                                        server_port = server_port_check (use_ssl);
+                                        check_http ();
+                                }
+                                else if (sscanf (pos, HDR_LOCATION URI_HTTP URI_HOST URI_PORT, server_type, server_address, server_port_text) == 3) {
+                                        host_name = strscpy (host_name, server_address);
+                                        strcpy (server_url, "/");
+                                        use_ssl = server_type_check (server_type);
+                                        server_port = atoi (server_port_text);
+                                        check_http ();
+                                }
+                                else if (sscanf (pos, HDR_LOCATION URI_HTTP URI_HOST, server_type, server_address) == 2) {
+                                        host_name = strscpy (host_name, server_address);
+                                        strcpy (server_url, "/");
+                                        use_ssl = server_type_check (server_type);
+                                        server_port = server_port_check (use_ssl);
+                                        check_http ();
+                                }
+                                else if (sscanf (pos, HDR_LOCATION URI_PATH, server_url) == 1) {
+                                        check_http ();
+                                }
+                                pos += (size_t) strcspn (pos, "\r\n");
+                                pos += (size_t) strspn (pos, "\r\n");
+                        } /* end while (pos) */
+                        printf ("HTTP UNKNOWN: Could not find redirect location - %s%s",
+                                status_line, (display_html ? "</A>" : ""));
+                        exit (STATE_UNKNOWN);
+                } /* end if (onredirect == STATE_DEPENDENT) */
+                else if (onredirect == STATE_UNKNOWN)
+                        printf ("HTTP UNKNOWN");
+                else if (onredirect == STATE_OK)
+                        printf ("HTTP ok");
+                else if (onredirect == STATE_WARNING)
+                        printf ("HTTP WARNING");
+                else if (onredirect == STATE_CRITICAL)
+                        printf ("HTTP CRITICAL");
+                time (&end_time);
+                msg = ssprintf (msg, ": %s - %d second response time %s%s\n",
+                                status_line, (int) (end_time - start_time),
+                                timestamp, (display_html ? "</A>" : ""));
+                terminate (onredirect, msg);
+        } /* end if (strstr (status_line, "30[0-4]") */
+
+        /* check elapsed time */
+        time (&end_time);
+        msg = ssprintf (msg, "HTTP problem: %s - %d second response time %s%s\n",
+                        status_line, (int) (end_time - start_time),
+                        timestamp, (display_html ? "</A>" : ""));
+        if (check_critical_time == TRUE && (end_time - start_time) > critical_time)
+                terminate (STATE_CRITICAL, msg);
+        if (check_warning_time == TRUE && (end_time - start_time) > warning_time)
+                terminate (STATE_WARNING, msg);
+
+        /* Page and Header content checks go here */
+        /* these checks should be last */
+
+        if (strlen (string_expect)) {
+                if (strstr (page, string_expect)) {
+                        printf ("HTTP ok: %s - %d second response time %s%s\n",
+                                status_line, (int) (end_time - start_time),
+                                timestamp, (display_html ? "</A>" : ""));
+                        exit (STATE_OK);
+                }
+                else {
+                        printf ("HTTP CRITICAL: string not found%s\n",
+                                (display_html ? "</A>" : ""));
+                        exit (STATE_CRITICAL);
+                }
+        }
+#ifdef HAVE_REGEX_H
+        if (strlen (regexp)) {
+                errcode = regexec (&preg, page, REGS, pmatch, 0);
+                if (errcode == 0) {
+                        printf ("HTTP ok: %s - %d second response time %s%s\n",
+                                status_line, (int) (end_time - start_time),
+                                timestamp, (display_html ? "</A>" : ""));
+                        exit (STATE_OK);
+                }
+                else {
+                        if (errcode == REG_NOMATCH) {
+                                printf ("HTTP CRITICAL: pattern not found%s\n",
+                                        (display_html ? "</A>" : ""));
+                                exit (STATE_CRITICAL);
+                        }
+                        else {
+                                regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
+                                printf ("Execute Error: %s\n", errbuf);
+                                exit (STATE_CRITICAL);
+                        }
+                }
+        }
+#endif
+
+        /* We only get here if all tests have been passed */
+        msg = ssprintf (msg, "HTTP ok: %s - %d second response time %s%s\n",
+                        status_line, (int) (end_time - start_time),
+                        timestamp, (display_html ? "</A>" : ""));
+        terminate (STATE_OK, msg);
+        return STATE_UNKNOWN;
+}
+
+
+
+#ifdef HAVE_SSL
+int
+connect_SSL (void)
+{
+        SSL_METHOD *meth;
+
+        randbuff = strscpy (NULL, "qwertyuiopasdfghjkl");
+        RAND_seed (randbuff, strlen (randbuff));
+        /* Initialize SSL context */
+        SSLeay_add_ssl_algorithms ();
+        meth = SSLv23_client_method ();
+        SSL_load_error_strings ();
+        if ((ctx = SSL_CTX_new (meth)) == NULL) {
+                printf ("ERROR: Cannot create SSL context.\n");
+                return STATE_CRITICAL;
+        }
+
+        /* Initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* Set socket timeout */
+        alarm (socket_timeout);
+
+        /* Save start time */
+        time (&start_time);
+
+        /* Make TCP connection */
+        if (my_tcp_connect (server_address, server_port, &sd) == STATE_OK) {
+                /* Do the SSL handshake */
+                if ((ssl = SSL_new (ctx)) != NULL) {
+                        SSL_set_cipher_list(ssl, "ALL");
+                        SSL_set_fd (ssl, sd);
+                        if (SSL_connect (ssl) != -1)
+                                return OK;
+                        ERR_print_errors_fp (stderr);
+                }
+                else {
+                        printf ("ERROR: Cannot initiate SSL handshake.\n");
+                }
+                SSL_free (ssl);
+        }
+
+        SSL_CTX_free (ctx);
+        close (sd);
+
+        return STATE_CRITICAL;
+}
+#endif
+
+#ifdef HAVE_SSL
+int
+check_certificate (X509 ** certificate)
+{
+        ASN1_STRING *tm;
+        int offset;
+        struct tm stamp;
+        int days_left;
+        /* int result = STATE_OK; */
+        /* char timestamp[14]; */
+
+
+        /* Retrieve timestamp of certificate */
+        tm = X509_get_notAfter (*certificate);
+
+        /* Generate tm structure to process timestamp */
+        if (tm->type == V_ASN1_UTCTIME) {
+                if (tm->length < 10) {
+                        printf ("ERROR: Wrong time format in certificate.\n");
+                        return STATE_CRITICAL;
+                }
+                else {
+                        stamp.tm_year = (tm->data[0] - '0') * 10 + (tm->data[1] - '0');
+                        if (stamp.tm_year < 50)
+                                stamp.tm_year += 100;
+                        offset = 0;
+                }
+        }
+        else {
+                if (tm->length < 12) {
+                        printf ("ERROR: Wrong time format in certificate.\n");
+                        return STATE_CRITICAL;
+                }
+                else {
+                        stamp.tm_year =
+                                (tm->data[0] - '0') * 1000 + (tm->data[1] - '0') * 100 +
+                                (tm->data[2] - '0') * 10 + (tm->data[3] - '0');
+                        stamp.tm_year -= 1900;
+                        offset = 2;
+                }
+        }
+        stamp.tm_mon =
+                (tm->data[2 + offset] - '0') * 10 + (tm->data[3 + offset] - '0') - 1;
+        stamp.tm_mday =
+                (tm->data[4 + offset] - '0') * 10 + (tm->data[5 + offset] - '0');
+        stamp.tm_hour =
+                (tm->data[6 + offset] - '0') * 10 + (tm->data[7 + offset] - '0');
+        stamp.tm_min =
+                (tm->data[8 + offset] - '0') * 10 + (tm->data[9 + offset] - '0');
+        stamp.tm_sec = 0;
+        stamp.tm_isdst = -1;
+
+        days_left = (mktime (&stamp) - time (NULL)) / 86400;
+        sprintf
+                (timestamp, "%02d/%02d/%04d %02d:%02d",
+                 stamp.tm_mon + 1,
+                 stamp.tm_mday, stamp.tm_year + 1900, stamp.tm_hour, stamp.tm_min);
+
+        if (days_left > 0 && days_left <= days_till_exp) {
+                printf ("Certificate expires in %d day(s) (%s).\n", days_left, timestamp);
+                return STATE_WARNING;
+        }
+        if (days_left < 0) {
+                printf ("Certificate expired on %s.\n", timestamp);
+                return STATE_CRITICAL;
+        }
+
+        if (days_left == 0) {
+                printf ("Certificate expires today (%s).\n", timestamp);
+                return STATE_WARNING;
+        }
+
+        printf ("Certificate will expire on %s.\n", timestamp);
+
+        return STATE_OK;
+}
+#endif
+
+
+
+int
+my_recv (void)
+{
+        int i;
+#ifdef HAVE_SSL
+        if (use_ssl) {
+                i = SSL_read (ssl, buffer, MAX_INPUT_BUFFER - 1);
+        }
+        else {
+                i = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+        }
+#else
+        i = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+#endif
+        return i;
+}
+
+
+int
+my_close (void)
+{
+#ifdef HAVE_SSL
+        if (use_ssl == TRUE) {
+                SSL_shutdown (ssl);
+                SSL_free (ssl);
+                SSL_CTX_free (ctx);
+                return 0;
+        }
+        else {
+#endif
+                return close (sd);
+#ifdef HAVE_SSL
+        }
+#endif
+}
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, REVISION);
+        printf
+                ("Copyright (c) %s %s <%s>\n\n%s\n",
+                 COPYRIGHT, AUTHORS, EMAIL, SUMMARY);
+        print_usage ();
+        printf ("NOTE: One or both of -H and -I must be specified\n");
+        printf ("\nOptions:\n" LONGOPTIONS "\n", HTTP_EXPECT, HTTP_PORT,
+                DEFAULT_SOCKET_TIMEOUT, SSLOPTIONS);
+#ifdef HAVE_SSL
+        printf (SSLDESCRIPTION);
+#endif
+}
+
+
+void
+print_usage (void)
+{
+        printf ("Usage:\n" " %s %s\n"
+#ifdef HAVE_GETOPT_H
+                " %s (-h | --help) for detailed help\n"
+                " %s (-V | --version) for version information\n",
+#else
+                " %s -h for detailed help\n"
+                " %s -V for version information\n",
+#endif
+        PROGNAME, OPTIONS, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_ide-smart.c b/plugins/check_ide-smart.c
new file mode 100644
index 00000000..869f7dc0
--- /dev/null
+++ b/plugins/check_ide-smart.c
@@ -0,0 +1,448 @@
+/*
+ *  check_ide-smart v.1 - hacked version of ide-smart for Nagios
+ *  Copyright (C) 2000 Robert Dale <rdale@digital-mission.com>
+ *
+ *  Net Saint - http://www.nagios.org
+ *
+ *  Notes:
+ *         ide-smart has the same functionality as before. Some return
+ *         values were changed, otherwise the --net-saint option was added.
+ *
+ *         Run with:  check_ide-smart --net-saint [-d] <DRIVE>
+ *         Where DRIVE is an IDE drive, ie. /dev/hda, /dev/hdb, /dev/hdc
+ *
+ *           - Returns 0 on no errors
+ *           - Returns 1 on advisories
+ *           - Returns 2 on prefailure
+ *           - Returns -1 not too often
+ *
+ *  ide-smart 1.3 - IDE S.M.A.R.T. cheking tool
+ *  Copyright (C) 1998-1999 Ragnar Hojland Espinosa <ragnar@lightside.dhis.org>
+ *                1998      Gadi Oxman <gadio@netvision.net.il>
+ *
+ *  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 <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <linux/hdreg.h>
+#include <linux/types.h>
+#include <getopt.h>
+#include <errno.h>
+        
+#define NR_ATTRIBUTES   30
+        
+#ifndef TRUE
+#define TRUE 1
+#endif  /*  */
+        
+#define PREFAILURE 2
+#define ADVISORY 1
+#define OPERATIONAL 0
+#define UNKNOWN -1
+        typedef struct threshold_s
+{
+        __u8 id;
+        __u8 threshold;
+        __u8 reserved[10];
+}
+__attribute__ ((packed)) threshold_t;
+typedef struct thresholds_s
+{
+        __u16 revision;
+        threshold_t thresholds[NR_ATTRIBUTES];
+        __u8 reserved[18];
+        __u8 vendor[131];
+        __u8 checksum;
+}
+__attribute__ ((packed)) thresholds_t;
+typedef struct value_s
+{
+        __u8 id;
+        __u16 status;
+        __u8 value;
+        __u8 vendor[8];
+}
+__attribute__ ((packed)) value_t;
+typedef struct values_s
+{
+        __u16 revision;
+        value_t values[NR_ATTRIBUTES];
+        __u8 offline_status;
+        __u8 vendor1;
+        __u16 offline_timeout;
+        __u8 vendor2;
+        __u8 offline_capability;
+        __u16 smart_capability;
+        __u8 reserved[16];
+        __u8 vendor[125];
+        __u8 checksum;
+}
+__attribute__ ((packed)) values_t;
+struct
+{
+        __u8 value;
+        char *text;
+ }
+offline_status_text[] =
+{
+         {
+        0x00, "NeverStarted"}
+        ,  {
+        0x02, "Completed"}
+        ,  {
+        0x04, "Suspended"}
+        ,  {
+        0x05, "Aborted"}
+        ,  {
+        0x06, "Failed"}
+        ,  {
+        0, 0}
+};
+struct
+{
+        __u8 value;
+        char *text;
+ }
+smart_command[] =
+{
+         {
+        SMART_ENABLE, "SMART_ENABLE"}
+        ,  {
+        SMART_DISABLE, "SMART_DISABLE"}
+        ,  {
+        SMART_IMMEDIATE_OFFLINE, "SMART_IMMEDIATE_OFFLINE"}
+        ,  {
+        SMART_AUTO_OFFLINE, "SMART_AUTO_OFFLINE"}
+, };
+
+
+/* Index to smart_command table, keep in order */ 
+enum SmartCommand 
+{ SMART_CMD_ENABLE, SMART_CMD_DISABLE, SMART_CMD_IMMEDIATE_OFFLINE,
+                SMART_CMD_AUTO_OFFLINE 
+};
+char *
+get_offline_text (int status) 
+{
+        int i;
+        for (i = 0; offline_status_text[i].text; i++) {
+                if (offline_status_text[i].value == status) {
+                        return offline_status_text[i].text;
+                }
+        }
+        return "unknown";
+}
+int
+smart_read_values (int fd, values_t * values) 
+{
+        __u8 args[4 + 512] = {
+        WIN_SMART, 0, SMART_READ_VALUES, 1,};
+        if (ioctl (fd, HDIO_DRIVE_CMD, &args)) {
+                int e = errno;
+                printf ("Critical: SMART_READ_VALUES: %s\n", strerror (errno));
+                return e;
+        }
+        memcpy (values, args + 4, 512);
+        return 0;
+}
+int
+values_not_passed (values_t * p, thresholds_t * t) 
+{
+        value_t * value = p->values;
+        threshold_t * threshold = t->thresholds;
+        int failed = 0;
+        int passed = 0;
+        int i;
+        for (i = 0; i < NR_ATTRIBUTES; i++) {
+                if (value->id && threshold->id && value->id == threshold->id) {
+                        if (value->value <= threshold->threshold) {
+                                ++failed;
+                        }
+                        else {
+                                ++passed;
+                        }
+                }
+                ++value;
+                ++threshold;
+        }
+        return (passed ? -failed : 2);
+}
+int
+net_saint (values_t * p, thresholds_t * t) 
+{
+        value_t * value = p->values;
+        threshold_t * threshold = t->thresholds;
+        int status = OPERATIONAL;
+        int prefailure = 0;
+        int advisory = 0;
+        int failed = 0;
+        int passed = 0;
+        int total = 0;
+        int i;
+        for (i = 0; i < NR_ATTRIBUTES; i++) {
+                if (value->id && threshold->id && value->id == threshold->id) {
+                        if (value->value <= threshold->threshold) {
+                                ++failed;
+                                if (value->status & 1) {
+                                        status = PREFAILURE;
+                                        ++prefailure;
+                                }
+                                else {
+                                        status = ADVISORY;
+                                        ++advisory;
+                                }
+                        }
+                        else {
+                                ++passed;
+                        }
+                        ++total;
+                }
+                ++value;
+                ++threshold;
+        }
+        switch (status) {
+        case PREFAILURE:
+                printf ("Critical: %d Harddrive PreFailure%cDetected! " 
+                                                 "%d/%d tests failed.\n", prefailure, prefailure > 1 ? 's' : ' ',
+                                                 failed, total);
+                break;
+        case ADVISORY:
+                printf ("Warning: %d Harddrive Advisor%s Detected. " 
+                                                 "%d/%d tests failed.\n", advisory, advisory > 1 ? "ies" : "y",
+                                                 failed, total);
+                break;
+        case OPERATIONAL:
+                printf ("Status: Operational (%d/%d tests passed)\n", passed, total);
+                break;
+        default:
+                printf ("Error: Status '%d' uknown. %d/%d tests passed\n", status,
+                                                 passed, total);
+                status = -1;
+                break;
+        }
+        return status;
+}
+void
+print_value (value_t * p, threshold_t * t) 
+{
+        printf ("Id=%3d, Status=%2d {%s , %s}, Value=%3d, Threshold=%3d, %s\n",
+                                         p->id, p->status, p->status & 1 ? "PreFailure" : "Advisory   ",
+                                         p->status & 2 ? "OnLine " : "OffLine", p->value, t->threshold,
+                                         p->value > t->threshold ? "Passed" : "Failed");
+}
+void
+print_values (values_t * p, thresholds_t * t) 
+{
+        value_t * value = p->values;
+        threshold_t * threshold = t->thresholds;
+        int i;
+        for (i = 0; i < NR_ATTRIBUTES; i++) {
+                if (value->id && threshold->id && value->id == threshold->id) {
+                        print_value (value++, threshold++);
+                }
+        }
+        printf
+                ("OffLineStatus=%d {%s}, AutoOffLine=%s, OffLineTimeout=%d minutes\n",
+                 p->offline_status, get_offline_text (p->offline_status & 0x7f),
+                 (p->offline_status & 0x80 ? "Yes" : "No"), p->offline_timeout / 60);
+        printf ("OffLineCapability=%d {%s %s %s}\n", p->offline_capability,
+                                         p->offline_capability & 1 ? "Immediate" : "",
+                                         p->offline_capability & 2 ? "Auto" : "",
+                                         p->offline_capability & 4 ? "AbortOnCmd" : "SuspendOnCmd");
+        printf ("SmartRevision=%d, CheckSum=%d, SmartCapability=%d {%s %s}\n",
+                                         p->revision, p->checksum, p->smart_capability,
+                                         p->smart_capability & 1 ? "SaveOnStandBy" : "",
+                                         p->smart_capability & 2 ? "AutoSave" : "");
+}
+void
+print_thresholds (thresholds_t * p) 
+{
+        threshold_t * threshold = p->thresholds;
+        int i;
+        printf ("\n");
+        printf ("SmartRevision=%d\n", p->revision);
+        for (i = 0; i < NR_ATTRIBUTES; i++) {
+                if (threshold->id) {
+                        printf ("Id=%3d, Threshold=%3d\n", threshold->id,
+                                                         threshold->threshold); }
+                ++threshold;
+        }
+        printf ("CheckSum=%d\n", p->checksum);
+}
+int
+smart_cmd_simple (int fd, enum SmartCommand command, __u8 val0,
+                                                                        char show_error) 
+{
+        __u8 args[4] = {
+        WIN_SMART, val0, smart_command[command].value, 0};
+        int e = 0;
+        if (ioctl (fd, HDIO_DRIVE_CMD, &args)) {
+                e = errno;
+                if (show_error) {
+                        printf ("Critical: %s: %s\n", smart_command[command].text,
+                                                         strerror (errno)); }
+        }
+        return e;
+}
+int
+smart_read_thresholds (int fd, thresholds_t * thresholds) 
+{
+        __u8 args[4 + 512] = {
+        WIN_SMART, 0, SMART_READ_THRESHOLDS, 1,};
+        if (ioctl (fd, HDIO_DRIVE_CMD, &args)) {
+                int e = errno;
+                printf ("Critical: SMART_READ_THRESHOLDS: %s\n", strerror (errno));
+                return e;
+        }
+        memcpy (thresholds, args + 4, 512);
+        return 0;
+}
+void
+show_version () 
+{
+        printf ("check_ide-smart v.1 - FREE Software with NO WARRANTY\n");
+        printf ("Nagios feature - Robert Dale <rdale@digital-mission.com>\n");
+        printf ("(C) 1999 Ragnar Hojland Espinosa <ragnar@lightside.dhis.org>\n");
+}
+void
+show_help () 
+{
+        printf ("Usage: check_ide-smart [DEVICE] [OPTION]\n" 
+                                         "         -d, --device=DEVICE  Select device DEVICE\n" 
+                                         "         -i, --immediate      Perform immediately offline tests\n" 
+                                         "         -q, --quiet-check    Returns the number of failed tests\n" 
+                                         "         -1, --auto-on        Turn on automatic offline tests\n" 
+                                         "         -0, --auto-off       Turn off automatic offline tests\n" 
+                                         "         -n, --net-saint      Output suitable for Net Saint\n" 
+                                         "         -h, --help\n"  "        -V, --version\n");
+}
+int
+main (int argc, char *argv[]) 
+{
+        char *device = NULL;
+        int command = -1;
+        int o, longindex;
+        int retval = 0;
+        
+#ifdef HAVE_GETOPT_H
+        const struct option longopts[] = { 
+                        {"device", required_argument, 0, 'd'}, 
+                {"immediate", no_argument, 0, 'i'}, 
+                {"quiet-check", no_argument, 0, 'q'}, 
+                {"auto-on", no_argument, 0, '1'}, 
+                {"auto-off", no_argument, 0, '0'}, 
+                {"net-saint", no_argument, 0, 'n'}, 
+                {"help", no_argument, 0, 'h'}, 
+                {"version", no_argument, 0, 'V'}, {0, 0, 0, 0} 
+        };
+        
+#endif  /*  */
+                while (1) {
+                
+#ifdef HAVE_GETOPT_H
+                        o = getopt_long (argc, argv, "+d:iq10nhV", longopts, &longindex);
+                
+#else   /*  */
+                        o = getopt (argc, argv, "+d:iq10nhV");
+                
+#endif  /*  */
+                        if (o == -1 || o == EOF)
+                        break;
+                switch (o) {
+                case 'd':
+                        device = optarg;
+                        break;
+                case 'q':
+                        command = 3;
+                        break;
+                case 'i':
+                        command = 2;
+                        break;
+                case '1':
+                        command = 1;
+                        break;
+                case '0':
+                        command = 0;
+                        break;
+                case 'n':
+                        command = 4;
+                        break;
+                case 'h':
+                        show_help ();
+                        return 0;
+                case 'V':
+                        show_version ();
+                        return 0;
+                default:
+                        printf ("Try `%s --help' for more information.\n", argv[0]);
+                        return 1;
+                }
+                if (optind < argc) {
+                        device = argv[optind];
+                }
+                if (!device) {
+                        show_help ();
+                        show_version ();
+                        return -1;
+                }
+                if (1) {
+                        thresholds_t thresholds;
+                        values_t values;
+                        int fd = open (device, O_RDONLY);
+                        if (fd < 0) {
+                                printf ("Critical: Couldn't open device: %s\n", strerror (errno));
+                                return 2;
+                        }
+                        if (smart_cmd_simple (fd, SMART_CMD_ENABLE, 0, TRUE)) {
+                                printf ("Critical: SMART_CMD_ENABLE\n");
+                                return 2;
+                        }
+                        switch (command) {
+                        case 0:
+                                retval = smart_cmd_simple (fd, SMART_CMD_AUTO_OFFLINE, 0, TRUE);
+                                break;
+                        case 1:
+                                retval = smart_cmd_simple (fd, SMART_CMD_AUTO_OFFLINE, 0xF8, TRUE);
+                                break;
+                        case 2:
+                                retval = smart_cmd_simple (fd, SMART_CMD_IMMEDIATE_OFFLINE, 0, TRUE);
+                                break;
+                        case 3:
+                                smart_read_values (fd, &values);
+                                smart_read_thresholds (fd, &thresholds);
+                                retval = values_not_passed (&values, &thresholds);
+                                break;
+                        case 4:
+                                smart_read_values (fd, &values);
+                                smart_read_thresholds (fd, &thresholds);
+                                retval = net_saint (&values, &thresholds);
+                                break;
+                        default:
+                                smart_read_values (fd, &values);
+                                smart_read_thresholds (fd, &thresholds);
+                                print_values (&values, &thresholds);
+                                break;
+                        }
+                        close (fd);
+                }
+                return retval;
+        }
+        
diff --git a/plugins/check_imap.c b/plugins/check_imap.c
new file mode 100644
index 00000000..5ec0439b
--- /dev/null
+++ b/plugins/check_imap.c
@@ -0,0 +1,340 @@
+/******************************************************************************
+*
+* CHECK_IMAP.C
+*
+* Program: IMAP4 plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Tom Shields (tom.shields@basswood.com)
+*
+* $Id$
+*
+* Description:
+*
+* This plugin will attempt to open an IMAP connection with the host.
+* Successul connects return STATE_OK, refusals and timeouts return
+* STATE_CRITICAL, other errors return STATE_UNKNOWN.  Successful
+* connects, but incorrect reponse messages from the host result in
+* STATE_WARNING return values.
+*
+* Modifications:
+* 04-13-1999 Tom Shields
+*       Initial code
+* 08-18-1999 Ethan Galstad <nagios@nagios.org>
+*       Modified code to work with common plugin functions, added socket
+*       timeout, string * length checking
+* 09-19-1999 Ethan Galstad <nagios@nagios.org>
+*       Changed expect string from "+OK" to "* OK" and default port to 143
+*****************************************************************************/
+
+#include "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define PROGNAME "check_imap"
+
+#define PORT   143
+#define EXPECT "* OK"
+#define QUIT   "a1 LOGOUT\n"
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+int check_disk (int usp, int free_disk);
+void print_help (void);
+void print_usage (void);
+
+int server_port = PORT;
+char *server_address = NULL;
+char *server_expect = NULL;
+int warning_time = 0;
+int check_warning_time = FALSE;
+int critical_time = 0;
+int check_critical_time = FALSE;
+int verbose = FALSE;
+
+int
+main (int argc, char **argv)
+{
+        int sd;
+        int result;
+        char buffer[MAX_INPUT_BUFFER];
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+
+        /* try to connect to the host at the given port number */
+        time (&start_time);
+        result = my_tcp_connect (server_address, server_port, &sd);
+
+        /* we connected, so close connection before exiting */
+        if (result == STATE_OK) {
+
+                /* watch for the IMAP connection string */
+                result = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+
+                /* strip carriange returns */
+                strip (buffer);
+
+                /* return a WARNING status if we couldn't read any data */
+                if (result == -1) {
+                        printf ("recv() failed\n");
+                        result = STATE_WARNING;
+                }
+
+                else {
+
+                        /* make sure we find the response we are looking for */
+                        if (!strstr (buffer, server_expect)) {
+                                if (server_port == server_port)
+                                        printf ("Invalid IMAP response received from host\n");
+                                else
+                                        printf ("Invalid IMAP response received from host on port %d\n",
+                                                                        server_port);
+                                result = STATE_WARNING;
+                        }
+
+                        else {
+                                time (&end_time);
+                                printf ("IMAP ok - %d second response time\n",
+                                                                (int) (end_time - start_time));
+                                result = STATE_OK;
+                        }
+                }
+
+                /* close the connection */
+                send (sd, QUIT, strlen (QUIT), 0);
+                close (sd);
+        }
+
+        /* reset the alarm handler */
+        alarm (0);
+
+        return result;
+}
+
+
+
+
+
+/* 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");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (server_address == NULL) {
+                        if (is_host (argv[c])) {
+                                server_address = argv[c];
+                        }
+                        else {
+                                usage ("Invalid host name");
+                        }
+                }
+        }
+
+        if (server_address == NULL)
+                server_address = strscpy (NULL, "127.0.0.1");
+
+        if (server_expect == NULL)
+                server_expect = strscpy (NULL, EXPECT);
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"expect", required_argument, 0, 'e'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"port", required_argument, 0, 'P'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVvt:p:e:c:w:H:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+?hVvt:p:e:c:w:H:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 't':
+                case 'p':
+                case 'e':
+                case 'c':
+                case 'w':
+                case 'H':
+                        i++;
+                }
+
+                switch (c) {
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg)) {
+                                server_address = optarg;
+                        }
+                        else {
+                                usage ("Invalid host name\n");
+                        }
+                        break;
+                case 'p':                                                                       /* port */
+                        if (is_intpos (optarg)) {
+                                server_port = atoi (optarg);
+                        }
+                        else {
+                                usage ("Server port must be a positive integer\n");
+                        }
+                        break;
+                case 'e':                                                                       /* username */
+                        server_expect = optarg;
+                        break;
+                case 'c':                                                                       /* critical time threshold */
+                        if (is_intnonneg (optarg)) {
+                                critical_time = atoi (optarg);
+                                check_critical_time = TRUE;
+                        }
+                        else {
+                                usage ("Critical time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'w':                                                                       /* warning time threshold */
+                        if (is_intnonneg (optarg)) {
+                                warning_time = atoi (optarg);
+                                check_warning_time = TRUE;
+                        }
+                        else {
+                                usage ("Warning time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'v':                                                                       /* verbose */
+                        verbose = TRUE;
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (is_intnonneg (optarg)) {
+                                socket_timeout = atoi (optarg);
+                        }
+                        else {
+                                usage ("Time interval must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        return OK;
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Tom Shields/Karl DeBisschop\n\n"
+                 "This plugin tests the IMAP4 service on the specified host.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -H, --hostname=STRING or IPADDRESS\n"
+                 "   Check server on the indicated host\n"
+                 " -p, --port=INTEGER\n"
+                 "   Make connection on the indicated port (default: %d)\n"
+                 " -e, --expect=STRING\n"
+                 "   String to expect in first line of server response (default: %s)\n"
+                 " -w, --warning=INTEGER\n"
+                 "   Seconds necessary to result in a warning status\n"
+                 " -c, --critical=INTEGER\n"
+                 "   Seconds necessary to result in a critical status\n"
+                 " -t, --timeout=INTEGER\n"
+                 "   Seconds before connection attempt times out (default: %d)\n"
+                 " -v, --verbose\n"
+                 "   Print extra information (command-line use only)\n"
+                 " -h, --help\n"
+                 "   Print detailed help screen\n"
+                 " -V, --version\n"
+                 "   Print version information\n\n",
+                 PORT, EXPECT, DEFAULT_SOCKET_TIMEOUT);
+        support ();
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H host [-e expect] [-p port] [-w warn] [-c crit]\n"
+                 "            [-t timeout] [-v]\n"
+                 "       %s --help\n"
+                 "       %s --version\n", PROGNAME, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_ldap.c b/plugins/check_ldap.c
new file mode 100644
index 00000000..d3f06158
--- /dev/null
+++ b/plugins/check_ldap.c
@@ -0,0 +1,291 @@
+/***************************************************************************** *
+ * CHECK_LDAP.C
+ *
+ * Program: Ldap plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Didi Rieder (adrieder@sbox.tu-graz.ac.at)
+ * 
+ * Last Modified: $Date$
+ *
+ * Command line: check_ldap -h <host> -b <base_dn> -p <port> -w <warn_time> -w <crit_time>
+ *
+ * Description:
+ *
+ * This plugin is for testing a ldap server.
+ *
+ * Modifications:
+ *
+ * 08-25-1999 Ethan Galstad (nagios@nagios.org)
+ *            Modified to use common plugin include file
+ *
+ *****************************************************************************/
+
+#define PROGNAME "check_ldap"
+#define REVISION "$Revision$"
+
+#include "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#include <lber.h>
+#include <ldap.h>
+
+#define UNKNOWN -1
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+static void print_help (void);
+static void print_usage (void);
+
+char ld_defattr[] = "(objectclass=*)";
+char *ld_attr = ld_defattr;
+char *ld_host = NULL, *ld_base = NULL, *ld_passwd = NULL, *ld_binddn = NULL;
+unsigned int ld_port = 389;
+int warn_time = UNKNOWN, crit_time = UNKNOWN;
+
+int
+main (int argc, char *argv[])
+{
+
+        LDAP *ld;
+        LDAPMessage *result;
+
+        int t_diff;
+        time_t time0, time1;
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("check_ldap: could not parse arguments\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+
+        /* get the start time */
+        time (&time0);
+
+        /* initialize ldap */
+        if (!(ld = ldap_open (ld_host, ld_port))) {
+                /*ldap_perror(ld, "ldap_open"); */
+                printf ("Could not connect to the server at port %i\n", ld_port);
+                return STATE_CRITICAL;
+        }
+
+        /* bind to the ldap server */
+        if (ldap_bind_s (ld, ld_binddn, ld_passwd, LDAP_AUTH_SIMPLE) !=
+                        LDAP_SUCCESS) {
+                /*ldap_perror(ld, "ldap_bind"); */
+                printf ("Could not bind to the ldap-server\n");
+                return STATE_CRITICAL;
+        }
+
+        /* do a search of all objectclasses in the base dn */
+        if (ldap_search_s (ld, ld_base, LDAP_SCOPE_BASE, ld_attr, NULL, 0, &result)
+                        != LDAP_SUCCESS) {
+                /*ldap_perror(ld, "ldap_search"); */
+                printf ("Could not search/find objectclasses in %s\n", ld_base);
+                return STATE_CRITICAL;
+        }
+
+        /* unbind from the ldap server */
+        ldap_unbind (ld);
+
+        /* reset the alarm handler */
+        alarm (0);
+
+        /* get the finish time */
+        time (&time1);
+
+        /* calcutate the elapsed time */
+        t_diff = time1 - time0;
+
+        /* check if warn_time or crit_time was exceeded */
+        if ((t_diff >= warn_time) && (t_diff < crit_time)) {
+                printf ("LDAP warning - %i seconds response time\n", t_diff);
+                return STATE_WARNING;
+        }
+        if (t_diff >= crit_time) {
+                printf ("LDAP critical - %i seconds response time\n", t_diff);
+                return STATE_CRITICAL;
+        }
+
+        /* print out the result */
+        printf ("LDAP ok - %i seconds response time\n", t_diff);
+
+        return STATE_OK;
+}
+
+/* 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 (ld_host[0] == 0) {
+                        strncpy (ld_host, argv[c], sizeof (ld_host) - 1);
+                        ld_host[sizeof (ld_host) - 1] = 0;
+                }
+        }
+
+        return c;
+}
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 1;
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        /* initialize the long option struct */
+        static struct option long_options[] = {
+                {"help", no_argument, 0, 'h'},
+                {"version", no_argument, 0, 'V'},
+                {"timeout", required_argument, 0, 't'},
+                {"host", required_argument, 0, 'H'},
+                {"base", required_argument, 0, 'b'},
+                {"attr", required_argument, 0, 'a'},
+                {"bind", required_argument, 0, 'D'},
+                {"pass", required_argument, 0, 'P'},
+                {"port", required_argument, 0, 'p'},
+                {"warn", required_argument, 0, 'w'},
+                {"crit", required_argument, 0, 'c'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        for (c = 1; c < argc; c++)
+                if (strcmp ("-to", argv[c]) == 0)
+                        strcpy (argv[c], "-t");
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVt:c:w:H:b:p:a:D:P:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+?hVt:c:w:H:b:p:a:D:P:");
+#endif
+
+                if (c == -1 || c == EOF)
+                        break;
+
+                i++;
+                switch (c) {
+                case 't':
+                case 'c':
+                case 'w':
+                case 'H':
+                case 'b':
+                case 'p':
+                case 'a':
+                case 'D':
+                case 'P':
+                        i++;
+                }
+
+                switch (c) {
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, REVISION);
+                        exit (STATE_OK);
+                case 't':                                                                       /* timeout period */
+                        if (!is_intnonneg (optarg))
+                                usage2 ("timeout interval must be an integer", optarg);
+                        socket_timeout = atoi (optarg);
+                        break;
+                case 'H':
+                        ld_host = optarg;
+                        break;
+                case 'b':
+                        ld_base = optarg;
+                        break;
+                case 'p':
+                        ld_port = atoi (optarg);
+                        break;
+                case 'a':
+                        ld_attr = optarg;
+                        break;
+                case 'D':
+                        ld_binddn = optarg;
+                        break;
+                case 'P':
+                        ld_passwd = optarg;
+                        break;
+                case 'w':
+                        warn_time = atoi (optarg);
+                        break;
+                case 'c':
+                        crit_time = atoi (optarg);
+                        break;
+                default:
+                        usage ("check_ldap: could not parse arguments\n");
+                        break;
+                }
+        }
+        return i;
+}
+
+int
+validate_arguments ()
+{
+        if (ld_host[0] == 0 ||
+                        ld_base[0] == 0 ||
+                        ld_port == UNKNOWN || warn_time == UNKNOWN || crit_time == UNKNOWN) {
+                return ERROR;
+        }
+        else {
+                return OK;
+        }
+}
+
+
+
+/* function print_help */
+static void
+print_help ()
+{
+        print_revision (PROGNAME, REVISION);
+        printf
+                ("Copyright (c) 1999 Didi Rieder (adrieder@sbox.tu-graz.ac.at)\n"
+                 "License: GPL\n" "\n");
+        print_usage ();
+        printf
+                ("\n"
+                 "Options:\n"
+                 "\t-H [--host] ... host\n"
+                 "\t-a [--attr] ... ldap attribute to search (default: \"(objectclass=*)\"\n"
+                 "\t-b [--base] ... ldap base (eg. ou=my unit, o=my org, c=at)\n"
+                 "\t-D [--bind] ... ldap bind DN (if required)\n"
+                 "\t-P [--pass] ... ldap password (if required)\n"
+                 "\t-p [--port] ... ldap port (normaly 389)\n"
+                 "\t-w [--warn] ... time in secs. - if the exceeds <warn> the STATE_WARNING will be returned\n"
+                 "\t-c [--crit] ... time in secs. - if the exceeds <crit> the STATE_CRITICAL will be returned\n"
+                 "\n");
+}
+
+
+static void
+print_usage ()
+{
+        printf
+                ("Usage: %s -H <host> -b <base_dn> -p <port> [-a <attr>] [-D <binddn>]\n"
+                 "         [-P <password>] [-w <warn_time>] [-c <crit_time>] [-t timeout]\n"
+                 "(Note: all times are in seconds.)\n", PROGNAME);
+}
diff --git a/plugins/check_load.c b/plugins/check_load.c
new file mode 100644
index 00000000..6673b1dc
--- /dev/null
+++ b/plugins/check_load.c
@@ -0,0 +1,321 @@
+/******************************************************************************
+ *
+ * CHECK_LOAD.C
+ *
+ * Written by Felipe Gustavo de Almeida <galmeida@linux.ime.usp.br>
+ * License: GPL
+ * Command line: CHECK_LOAD <wload1> <cload1> <wload5> <cload5> <wload15> <cload15>
+ * First Written: 04/17/99 
+ *
+ * Modifications:
+ * 
+ * 05/18/1999 - Modified to work getloadavg where available, and use uptime
+ *              where neither proc or getloadavg are found.  Also use autoconf.
+ *                 mods by Karl DeBisschop (kdebiss@alum.mit.edu)
+ * 07/01/1999 - Added some #DEFINEs to allow compilation under NetBSD, as
+ *              suggested by Andy Doran.
+ *                 mods by Ethan Galstad (nagios@nagios.org)
+ * 07/17/1999 - Initialized la[] array to prevent NetBSD from complaining
+ *                 mods by Ethan Galstad (nagios@nagios.org)
+ * 08/18/1999 - Integrated some code with common plugin utilities
+ *                 mods by Ethan Galstad (nagios@nagios.org)
+ * $Date$
+ * Note: The load format is the same used by "uptime" and "w"
+ *
+ *****************************************************************************/
+
+#include "config.h"
+#include "common.h"
+#include "utils.h"
+
+#ifdef HAVE_SYS_LOADAVG_H
+#include <sys/loadavg.h>
+#endif
+
+/* needed for compilation under NetBSD, as suggested by Andy Doran */
+#ifndef LOADAVG_1MIN
+#define LOADAVG_1MIN    0
+#define LOADAVG_5MIN    1
+#define LOADAVG_15MIN   2
+#endif /* !defined LOADAVG_1MIN */
+
+#include "popen.h"
+#ifdef HAVE_PROC_LOADAVG
+
+#endif
+
+#define PROGNAME "check_load"
+
+int process_arguments (int argc, char **argv);
+int call_getopt (int argc, char **argv);
+int validate_arguments (void);
+void print_usage (void);
+void print_help (void);
+
+float wload1 = -1, wload5 = -1, wload15 = -1;
+float cload1 = -1, cload5 = -1, cload15 = -1;
+
+int
+main (int argc, char **argv)
+{
+#if HAVE_GETLOADAVG==1
+        int result;
+        double la[3] = { 0.0, 0.0, 0.0 };       /* NetBSD complains about unitialized arrays */
+#elif HAVE_PROC_LOADAVG==1
+        FILE *fp;
+        char input_buffer[MAX_INPUT_BUFFER];
+        char *tmp_ptr;
+#else
+        int result;
+        char input_buffer[MAX_INPUT_BUFFER];
+#endif
+
+        float la1, la5, la15;
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("\n");
+
+#if HAVE_GETLOADAVG==1
+        result = getloadavg (la, 3);
+        if (result == -1)
+                return STATE_UNKNOWN;
+        la1 = la[LOADAVG_1MIN];
+        la5 = la[LOADAVG_5MIN];
+        la15 = la[LOADAVG_15MIN];
+#elif HAVE_PROC_LOADAVG==1
+        fp = fopen (PROC_LOADAVG, "r");
+        if (fp == NULL) {
+                printf ("Error opening %s\n", PROC_LOADAVG);
+                return STATE_UNKNOWN;
+        }
+
+        la1 = la5 = la15 = -1;
+
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
+                tmp_ptr = strtok (input_buffer, " ");
+                la1 = atof (tmp_ptr);
+                tmp_ptr = strtok (NULL, " ");
+                la5 = atof (tmp_ptr);
+                tmp_ptr = strtok (NULL, " ");
+                la15 = atof (tmp_ptr);
+        }
+
+        fclose (fp);
+#else
+        child_process = spopen (PATH_TO_UPTIME);
+        if (child_process == NULL) {
+                printf ("Error opening %s\n", PATH_TO_UPTIME);
+                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", PATH_TO_UPTIME);
+        }
+        fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process);
+        sscanf (input_buffer, "%*[^l]load average: %f, %f, %f", &la1, &la5, &la15);
+
+        result = spclose (child_process);
+        if (result) {
+                printf ("Error code %d returned in %s\n", result, PATH_TO_UPTIME);
+                return STATE_UNKNOWN;
+        }
+#endif
+
+        if ((la1 == -1) || (la5 == -1) || (la15 == -1)) {
+#if HAVE_GETLOADAVG==1
+                printf ("Error in getloadavg()\n");
+#elif HAVE_PROC_LOADAVG==1
+                printf ("Error processing %s\n", PROC_LOADAVG);
+#else
+                printf ("Error processing %s\n", PATH_TO_UPTIME);
+#endif
+                return STATE_UNKNOWN;
+        }
+        printf ("load average: %.2f, %.2f, %.2f", la1, la5, la15);
+        if ((la1 >= cload1) || (la5 >= cload5) || (la15 >= cload15)) {
+                printf (" CRITICAL\n");
+                return STATE_CRITICAL;
+        }
+        if ((la1 >= wload1) || (la5 >= wload5) || (la15 >= wload15)) {
+                printf (" WARNING\n");
+                return STATE_WARNING;
+        }
+        printf ("\n");
+        return STATE_OK;
+}
+
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+        if (argc < 2)
+                return ERROR;
+
+        c = 0;
+        while (c += (call_getopt (argc - c, &argv[c]))) {
+                if (argc <= c)
+                        break;
+
+                if (wload1 < 0 && is_nonnegative (argv[c]))
+                        wload1 = atof (argv[c]);
+                else if (cload1 < 0 && is_nonnegative (argv[c]))
+                        cload1 = atof (argv[c]);
+                else if (wload5 < 0 && is_nonnegative (argv[c]))
+                        wload5 = atof (argv[c]);
+                else if (cload5 < 0 && is_nonnegative (argv[c]))
+                        cload5 = atof (argv[c]);
+                else if (wload15 < 0 && is_nonnegative (argv[c]))
+                        wload15 = atof (argv[c]);
+                else if (cload15 < 0 && is_nonnegative (argv[c]))
+                        cload15 = atof (argv[c]);
+        }
+
+        return validate_arguments ();
+}
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"warning", required_argument, 0, 'w'},
+                {"critical", required_argument, 0, 'c'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c = getopt_long (argc, argv, "+?Vhc:w:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+?Vhc:w:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF)
+                        break;
+
+                switch (c) {
+                case 'c':
+                case 'w':
+                        i++;
+                }
+
+                switch (c) {
+                case 'w':                                                                       /* warning time threshold */
+                        if (is_intnonneg (optarg)) {
+                                if (wload1 < 0 && is_nonnegative (argv[c]))
+                                        wload1 = atof (argv[c]);
+                                else if (wload5 < 0 && is_nonnegative (argv[c]))
+                                        wload5 = atof (argv[c]);
+                                else if (wload15 < 0 && is_nonnegative (argv[c]))
+                                        wload15 = atof (argv[c]);
+                                break;
+                        }
+                        else if (strstr (optarg, ",") &&
+                                                         sscanf (optarg, "%f,%f,%f", &wload1, &wload5, &wload15) == 3) {
+                                break;
+                        }
+                        else {
+                                usage ("Warning threshold must be float or float triplet!\n");
+                        }
+                case 'c':                                                                       /* critical time threshold */
+                        if (is_intnonneg (optarg)) {
+                                if (cload1 < 0 && is_nonnegative (argv[c]))
+                                        cload1 = atof (argv[c]);
+                                else if (cload5 < 0 && is_nonnegative (argv[c]))
+                                        cload5 = atof (argv[c]);
+                                else if (cload15 < 0 && is_nonnegative (argv[c]))
+                                        cload15 = atof (argv[c]);
+                                break;
+                        }
+                        else if (strstr (optarg, ",") &&
+                                                         sscanf (optarg, "%f,%f,%f", &cload1, &cload5, &cload15) == 3) {
+                                break;
+                        }
+                        else {
+                                usage ("Critical threshold must be float or float triplet!\n");
+                        }
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        if ((wload1 > cload1) || (wload5 > cload5) || (wload15 > cload15)) {
+                printf
+                        ("Inconsistence in parameters: \"warning load\" greater than \"critical load\".\n");
+                return STATE_UNKNOWN;
+        }
+
+        return OK;
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: check_load -w WLOAD1,WLOAD5,WLOAD15 -c CLOAD1,CLOAD5,CLOAD15\n"
+                 "       check_load --version\n" "       check_load --help\n");
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 1999 Felipe Gustavo de Almeida <galmeida@linux.ime.usp.br>\n"
+                 "Copyright (c) 2000 Karl DeBisschop\n\n"
+                 "This plugin tests the current system load average.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -w, --warning=WLOAD1,WLOAD5,WLOAD15\n"
+                 "   Exit with WARNING status if load average exceeds WLOADn\n"
+                 " -c, --critical=CLOAD1,CLOAD5,CLOAD15\n"
+                 "   Exit with CRITICAL status if load average exceed CLOADn\n"
+                 " -h, --help\n"
+                 "    Print detailed help screen\n"
+                 " -V, --version\n"
+                 "    Print version information\n\n"
+                 "the load average format is the same used by \"uptime\" and \"w\"\n\n");
+        support ();
+}
diff --git a/plugins/check_mrtg.c b/plugins/check_mrtg.c
new file mode 100644
index 00000000..b86686d7
--- /dev/null
+++ b/plugins/check_mrtg.c
@@ -0,0 +1,413 @@
+/******************************************************************************
+ *
+ * Program: MRTG (Multi-Router Traffic Grapher) generic plugin for Nagios
+ * License: GPL
+ *
+ * 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.
+ *
+ * $Id$
+ *
+ *****************************************************************************/
+
+#define PROGNAME "check_mrtg"
+#define REVISION "$Revision$"
+#define COPYRIGHT "Copyright (c) 1999-2001 Ethan Galstad"
+
+#define SUMMARY "\
+This plugin will check either the average or maximum value of one of the\n\
+two variables recorded in an MRTG log file.\n"
+
+/* old command line: 
+         <log_file> <expire_minutes> <AVG|MAX> <variable> <vwl> <vcl> <label> [units] */
+#define OPTIONS "\
+-F log_file -a <AVG | MAX> -v variable -w warning -c critical\n\
+            [-l label] [-u units] [-e expire_minutes] [-t timeout] [-v]"
+
+#define LONGOPTIONS "\
+ -F, --logfile=FILE\n\
+   The MRTG log file containing the data you want to monitor\n\
+ -e, --expires=MINUTES\n\
+   Minutes before MRTG data is considered to be too old\n\
+ -a, --aggregation=AVG|MAX\n\
+   Should we check average or maximum values?\n\
+ -v, --variable=INTEGER\n\
+   Which variable set should we inspect? 1 or 2?\n\
+ -w, --warning=INTEGER\n\
+   Threshold value for data to result in WARNING status\n\
+ -c, --critical=INTEGER\n\
+   Threshold value for data to result in CRITICAL status\n\
+ -l, --label=STRING\n\
+   Type label for data (Examples: Conns, \"Processor Load\", In, Out)\n\
+ -u, --units=STRING\n\
+   Option units label for data (Example: Packets/Sec, Errors/Sec, \n\
+   \"Bytes Per Second\", \"%% Utilization\")\n\
+ -h, --help\n\
+   Print detailed help screen\n\
+ -V, --version\n\
+   Print version information\n"
+
+#define DESCRIPTION "\
+If the value exceeds the <vwl> threshold, a WARNING status is returned.  If\n\
+the value exceeds the <vcl> threshold, a CRITICAL status is returned.  If\n\
+the data in the log file is older than <expire_minutes> old, a WARNING\n\
+status is returned and a warning message is printed.\n\
+\n\
+This plugin is useful for monitoring MRTG data that does not correspond to\n\
+bandwidth usage.  (Use the check_mrtgtraf plugin for monitoring bandwidth).\n\
+It can be used to monitor any kind of data that MRTG is monitoring - errors,\n\
+packets/sec, etc.  I use MRTG in conjuction with the Novell NLM that allows\n\
+me to track processor utilization, user connections, drive space, etc and\n\
+this plugin works well for monitoring that kind of data as well.\n\
+\n\
+Notes:\n\
+- This plugin only monitors one of the two variables stored in the MRTG log\n\
+  file.  If you want to monitor both values you will have to define two\n\
+  commands with different values for the <variable> argument.  Of course,\n\
+  you can always hack the code to make this plugin work for you...\n\
+- MRTG stands for the Multi Router Traffic Grapher.  It can be downloaded from\n\
+  http://ee-staff.ethz.ch/~oetiker/webtools/mrtg/mrtg.html\n"
+
+#include "config.h"
+#include "common.h"
+#include "utils.h"
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+void print_help (void);
+void print_usage (void);
+
+char *log_file = NULL;
+int expire_minutes = 0;
+int use_average = TRUE;
+int variable_number = -1;
+unsigned long value_warning_threshold = 0L;
+unsigned long value_critical_threshold = 0L;
+char *value_label = NULL;
+char *units_label = NULL;
+
+int
+main (int argc, char **argv)
+{
+        int result = STATE_OK;
+        FILE *fp;
+        int line;
+        char input_buffer[MAX_INPUT_BUFFER];
+        char *temp_buffer;
+        time_t current_time;
+        char error_message[MAX_INPUT_BUFFER];
+        time_t timestamp = 0L;
+        unsigned long average_value_rate = 0L;
+        unsigned long maximum_value_rate = 0L;
+        unsigned long value_rate = 0L;
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* open the MRTG log file for reading */
+        fp = fopen (log_file, "r");
+        if (fp == NULL) {
+                printf ("Unable to open MRTG log file\n");
+                return STATE_UNKNOWN;
+        }
+
+        line = 0;
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
+
+                line++;
+
+                /* skip the first line of the log file */
+                if (line == 1)
+                        continue;
+
+                /* break out of read loop if we've passed the number of entries we want to read */
+                if (line > 2)
+                        break;
+
+                /* grab the timestamp */
+                temp_buffer = strtok (input_buffer, " ");
+                timestamp = strtoul (temp_buffer, NULL, 10);
+
+                /* grab the average value 1 rate */
+                temp_buffer = strtok (NULL, " ");
+                if (variable_number == 1)
+                        average_value_rate = strtoul (temp_buffer, NULL, 10);
+
+                /* grab the average value 2 rate */
+                temp_buffer = strtok (NULL, " ");
+                if (variable_number == 2)
+                        average_value_rate = strtoul (temp_buffer, NULL, 10);
+
+                /* grab the maximum value 1 rate */
+                temp_buffer = strtok (NULL, " ");
+                if (variable_number == 1)
+                        maximum_value_rate = strtoul (temp_buffer, NULL, 10);
+
+                /* grab the maximum value 2 rate */
+                temp_buffer = strtok (NULL, " ");
+                if (variable_number == 2)
+                        maximum_value_rate = strtoul (temp_buffer, NULL, 10);
+        }
+
+        /* close the log file */
+        fclose (fp);
+
+        /* if we couldn't read enough data, return an unknown error */
+        if (line <= 2) {
+                result = STATE_UNKNOWN;
+                sprintf (error_message, "Unable to process MRTG log file\n");
+        }
+
+        /* make sure the MRTG data isn't too old */
+        if (result == STATE_OK) {
+                time (&current_time);
+                if (expire_minutes > 0
+                                && (current_time - timestamp) > (expire_minutes * 60)) {
+                        result = STATE_WARNING;
+                        sprintf (error_message, "MRTG data has expired (%d minutes old)\n",
+                                                         (int) ((current_time - timestamp) / 60));
+                }
+        }
+
+        /* else check the incoming/outgoing rates */
+        if (result == STATE_OK) {
+
+                if (use_average == TRUE)
+                        value_rate = average_value_rate;
+                else
+                        value_rate = maximum_value_rate;
+
+                if (value_rate > value_critical_threshold)
+                        result = STATE_CRITICAL;
+                else if (value_rate > value_warning_threshold)
+                        result = STATE_WARNING;
+        }
+
+        sprintf (error_message, "%s. %s = %lu %s",
+                                         (use_average == TRUE) ? "Ave" : "Max", value_label, value_rate,
+                                         units_label);
+        printf ("%s\n", error_message);
+
+        return result;
+}
+
+
+
+
+
+/* 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");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (log_file == NULL) {
+                        log_file = argv[c];
+                }
+                else if (expire_minutes <= 0) {
+                        if (is_intpos (argv[c]))
+                                expire_minutes = atoi (argv[c]);
+                        else
+                                terminate (STATE_UNKNOWN,
+                                                                         "%s is not a valid expiration time\nUse '%s -h' for additional help\n",
+                                                                         argv[c], PROGNAME);
+                }
+                else if (strcmp (argv[c], "MAX") == 0) {
+                        use_average = FALSE;
+                }
+                else if (strcmp (argv[c], "AVG") == 0) {
+                        use_average = TRUE;
+                }
+                else if (variable_number == -1) {
+                        variable_number = atoi (argv[c]);
+                        if (variable_number < 1 || variable_number > 2) {
+                                printf ("%s :", argv[c]);
+                                usage ("Invalid variable number\n");
+                        }
+                }
+                else if (value_warning_threshold == 0) {
+                        value_warning_threshold = strtoul (argv[c], NULL, 10);
+                }
+                else if (value_critical_threshold == 0) {
+                        value_critical_threshold = strtoul (argv[c], NULL, 10);
+                }
+                else if (value_label == NULL) {
+                        value_label = argv[c];
+                }
+                else if (units_label == NULL) {
+                        units_label = argv[c];
+                }
+        }
+
+        if (value_label == NULL)
+                value_label = strscpy (NULL, "");
+
+        if (units_label == NULL)
+                units_label = strscpy (NULL, "");
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"logfile", required_argument, 0, 'F'},
+                {"expires", required_argument, 0, 'e'},
+                {"aggregation", required_argument, 0, 'a'},
+                {"variable", required_argument, 0, 'v'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"label", required_argument, 0, 'l'},
+                {"units", required_argument, 0, 'u'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVF:e:a:v:c:w:l:u:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+?hVF:e:a:v:c:w:l:u:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 'F':
+                case 'e':
+                case 'a':
+                case 'v':
+                case 'c':
+                case 'w':
+                case 'l':
+                case 'u':
+                        i++;
+                }
+
+                switch (c) {
+                case 'F':                                                                       /* input file */
+                        log_file = optarg;
+                        break;
+                case 'e':                                                                       /* ups name */
+                        expire_minutes = atoi (optarg);
+                        break;
+                case 'a':                                                                       /* port */
+                        if (!strcmp (optarg, "MAX"))
+                                use_average = FALSE;
+                        else
+                                use_average = TRUE;
+                        break;
+                case 'v':
+                        variable_number = atoi (optarg);
+                        if (variable_number < 1 || variable_number > 2)
+                                usage ("Invalid variable number\n");
+                        break;
+                case 'w':                                                                       /* critical time threshold */
+                        value_warning_threshold = strtoul (optarg, NULL, 10);
+                        break;
+                case 'c':                                                                       /* warning time threshold */
+                        value_critical_threshold = strtoul (optarg, NULL, 10);
+                        break;
+                case 'l':                                                                       /* label */
+                        value_label = optarg;
+                        break;
+                case 'u':                                                                       /* timeout */
+                        units_label = optarg;
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+int
+validate_arguments (void)
+{
+        if (variable_number == -1)
+                usage ("You must supply the variable number\n");
+
+        return OK;
+}
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, REVISION);
+        printf ("%s\n\n%s\n", COPYRIGHT, SUMMARY);
+        print_usage ();
+        printf ("\nOptions:\n" LONGOPTIONS "\n" DESCRIPTION "\n");
+        support ();
+}
+
+void
+print_usage (void)
+{
+        printf ("Usage:\n" " %s %s\n"
+#ifdef HAVE_GETOPT_H
+                                        " %s (-h | --help) for detailed help\n"
+                                        " %s (-V | --version) for version information\n",
+#else
+                                        " %s -h for detailed help\n"
+                                        " %s -V for version information\n",
+#endif
+                                        PROGNAME, OPTIONS, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_mrtgtraf.c b/plugins/check_mrtgtraf.c
new file mode 100644
index 00000000..11f5146b
--- /dev/null
+++ b/plugins/check_mrtgtraf.c
@@ -0,0 +1,419 @@
+/******************************************************************************
+ *
+ * CHECK_MRTGTRAF.C
+ *
+ * Program: MRTG (Multi-Router Traffic Grapher) traffic plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ *
+ * Last Modified: $Date$
+ *
+ * Command line: CHECK_MRTGTRAF <log_file> <expire_minutes> <AVG|MAX> <iwl> <icl> <owl> <ocl>
+ *
+ * Description:
+ *
+ * This plugin will check the incoming/outgoing transfer rates of a
+ * router, switch, etc recorded in an MRTG log.  If the newest log
+ * entry is older than <expire_minutes>, a WARNING status is returned.
+ * If either the incoming or outgoing rates exceed the <icl> or <ocl>
+ * thresholds (in Bytes/sec), a CRITICAL status results.  If either of
+ * the rates exceed the <iwl> or <owl> thresholds (in Bytes/sec), a
+ * WARNING status results.
+ *
+ * Notes:
+ * - MRTG stands for the Multi Router Traffic Grapher.  It can be
+ *   downloaded from
+ *   http://ee-staff.ethz.ch/~oetiker/webtools/mrtg/mrtg.html
+ * - While MRTG can monitor things other than traffic rates, this
+ *   plugin probably won't work with much else without modification.
+ * - The calculated i/o rates are a little off from what MRTG actually
+ *   reports.  I'm not sure why this is right now, but will look into it
+ *   for future enhancements of this plugin.
+ *
+ * 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 "config.h"
+#include "common.h"
+#include "utils.h"
+
+#define PROGNAME "check_mrtgtraf"
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+void print_help (void);
+void print_usage (void);
+
+char *log_file = NULL;
+int expire_minutes = -1;
+int use_average = TRUE;
+unsigned long incoming_warning_threshold = 0L;
+unsigned long incoming_critical_threshold = 0L;
+unsigned long outgoing_warning_threshold = 0L;
+unsigned long outgoing_critical_threshold = 0L;
+
+int
+main (int argc, char **argv)
+{
+        int result = STATE_OK;
+        FILE *fp;
+        int line;
+        char input_buffer[MAX_INPUT_BUFFER];
+        char *temp_buffer;
+        time_t current_time;
+        char error_message[MAX_INPUT_BUFFER];
+        time_t timestamp = 0L;
+        unsigned long average_incoming_rate = 0L;
+        unsigned long average_outgoing_rate = 0L;
+        unsigned long maximum_incoming_rate = 0L;
+        unsigned long maximum_outgoing_rate = 0L;
+        unsigned long incoming_rate = 0L;
+        unsigned long outgoing_rate = 0L;
+        double adjusted_incoming_rate = 0.0;
+        double adjusted_outgoing_rate = 0.0;
+        char incoming_speed_rating[8];
+        char outgoing_speed_rating[8];
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* open the MRTG log file for reading */
+        fp = fopen (log_file, "r");
+        if (fp == NULL)
+                usage ("Unable to open MRTG log file\n");
+
+        line = 0;
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
+
+                line++;
+
+                /* skip the first line of the log file */
+                if (line == 1)
+                        continue;
+
+                /* break out of read loop */
+                /* if we've passed the number of entries we want to read */
+                if (line > 2)
+                        break;
+
+                /* grab the timestamp */
+                temp_buffer = strtok (input_buffer, " ");
+                timestamp = strtoul (temp_buffer, NULL, 10);
+
+                /* grab the average incoming transfer rate */
+                temp_buffer = strtok (NULL, " ");
+                average_incoming_rate = strtoul (temp_buffer, NULL, 10);
+
+                /* grab the average outgoing transfer rate */
+                temp_buffer = strtok (NULL, " ");
+                average_outgoing_rate = strtoul (temp_buffer, NULL, 10);
+
+                /* grab the maximum incoming transfer rate */
+                temp_buffer = strtok (NULL, " ");
+                maximum_incoming_rate = strtoul (temp_buffer, NULL, 10);
+
+                /* grab the maximum outgoing transfer rate */
+                temp_buffer = strtok (NULL, " ");
+                maximum_outgoing_rate = strtoul (temp_buffer, NULL, 10);
+        }
+
+        /* close the log file */
+        fclose (fp);
+
+        /* if we couldn't read enough data, return an unknown error */
+        if (line <= 2)
+                usage ("Unable to process MRTG log file\n");
+
+        /* make sure the MRTG data isn't too old */
+        time (&current_time);
+        if (expire_minutes > 0
+                        && (current_time - timestamp) >
+                        (expire_minutes * 60)) terminate (STATE_WARNING,
+                                                                                                                                                                "MRTG data has expired (%d minutes old)\n",
+                                                                                                                                                                (int) ((current_time - timestamp) /
+                                                                                                                                                                                         60));
+
+        /* else check the incoming/outgoing rates */
+        if (use_average == TRUE) {
+                incoming_rate = average_incoming_rate;
+                outgoing_rate = average_outgoing_rate;
+        }
+        else {
+                incoming_rate = maximum_incoming_rate;
+                outgoing_rate = maximum_outgoing_rate;
+        }
+
+        /* report incoming traffic in Bytes/sec */
+        if (incoming_rate < 1024) {
+                strcpy (incoming_speed_rating, "B/s");
+                adjusted_incoming_rate = (double) incoming_rate;
+        }
+
+        /* report incoming traffic in KBytes/sec */
+        else if (incoming_rate < (1024 * 1024)) {
+                strcpy (incoming_speed_rating, "KB/s");
+                adjusted_incoming_rate = (double) (incoming_rate / 1024.0);
+        }
+
+        /* report incoming traffic in MBytes/sec */
+        else {
+                strcpy (incoming_speed_rating, "MB/s");
+                adjusted_incoming_rate = (double) (incoming_rate / 1024.0 / 1024.0);
+        }
+
+        /* report outgoing traffic in Bytes/sec */
+        if (outgoing_rate < 1024) {
+                strcpy (outgoing_speed_rating, "B/s");
+                adjusted_outgoing_rate = (double) outgoing_rate;
+        }
+
+        /* report outgoing traffic in KBytes/sec */
+        else if (outgoing_rate < (1024 * 1024)) {
+                strcpy (outgoing_speed_rating, "KB/s");
+                adjusted_outgoing_rate = (double) (outgoing_rate / 1024.0);
+        }
+
+        /* report outgoing traffic in MBytes/sec */
+        else {
+                strcpy (outgoing_speed_rating, "MB/s");
+                adjusted_outgoing_rate = (double) (outgoing_rate / 1024.0 / 1024.0);
+        }
+
+        if (incoming_rate > incoming_critical_threshold
+                        || outgoing_rate > outgoing_critical_threshold) {
+                result = STATE_CRITICAL;
+                sprintf (error_message, "%s. In = %0.1f %s, %s. Out = %0.1f %s",
+                                                 (use_average == TRUE) ? "Ave" : "Max", adjusted_incoming_rate,
+                                                 incoming_speed_rating, (use_average == TRUE) ? "Ave" : "Max",
+                                                 adjusted_outgoing_rate, outgoing_speed_rating);
+        }
+        else if (incoming_rate > incoming_warning_threshold
+                                         || outgoing_rate > outgoing_warning_threshold) {
+                result = STATE_WARNING;
+                sprintf (error_message, "%s. In = %0.1f %s, %s. Out = %0.1f %s",
+                                                 (use_average == TRUE) ? "Ave" : "Max", adjusted_incoming_rate,
+                                                 incoming_speed_rating, (use_average == TRUE) ? "Ave" : "Max",
+                                                 adjusted_outgoing_rate, outgoing_speed_rating);
+        }
+
+        if (result == STATE_OK)
+                printf ("Traffic ok - %s. In = %0.1f %s, %s. Out = %0.1f %s\n",
+                                                (use_average == TRUE) ? "Ave" : "Max", adjusted_incoming_rate,
+                                                incoming_speed_rating, (use_average == TRUE) ? "Ave" : "Max",
+                                                adjusted_outgoing_rate, outgoing_speed_rating);
+        else
+                printf ("%s\n", error_message);
+
+        return result;
+}
+
+
+
+
+
+/* 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");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (log_file == NULL) {
+                        log_file = argv[c];
+                }
+                else if (expire_minutes == -1) {
+                        expire_minutes = atoi (optarg);
+                }
+                else if (strcmp (argv[c], "MAX") == 0) {
+                        use_average = FALSE;
+                }
+                else if (strcmp (argv[c], "AVG") == 0) {
+                        use_average = TRUE;
+                }
+                else if (incoming_warning_threshold == 0) {
+                        incoming_warning_threshold = strtoul (argv[c], NULL, 10);
+                }
+                else if (incoming_critical_threshold == 0) {
+                        incoming_critical_threshold = strtoul (argv[c], NULL, 10);
+                }
+                else if (outgoing_warning_threshold == 0) {
+                        outgoing_warning_threshold = strtoul (argv[c], NULL, 10);
+                }
+                else if (outgoing_critical_threshold == 0) {
+                        outgoing_critical_threshold = strtoul (argv[c], NULL, 10);
+                }
+        }
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"logfile", required_argument, 0, 'F'},
+                {"expires", required_argument, 0, 'e'},
+                {"aggregation", required_argument, 0, 'a'},
+                {"variable", required_argument, 0, 'v'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVF:e:a:c:w:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+hVF:e:a:c:w:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 'F':
+                case 'e':
+                case 'a':
+                case 'c':
+                case 'w':
+                        i++;
+                }
+
+                switch (c) {
+                case 'F':                                                                       /* input file */
+                        log_file = optarg;
+                        break;
+                case 'e':                                                                       /* expiration time */
+                        expire_minutes = atoi (optarg);
+                        break;
+                case 'a':                                                                       /* aggregation (AVE or MAX) */
+                        if (!strcmp (optarg, "MAX"))
+                                use_average = FALSE;
+                        else
+                                use_average = TRUE;
+                        break;
+                case 'c':                                                                       /* warning threshold */
+                        sscanf (optarg, "%lu,%lu", &incoming_critical_threshold,
+                                                        &outgoing_critical_threshold);
+                        break;
+                case 'w':                                                                       /* critical threshold */
+                        sscanf (optarg, "%lu,%lu", &incoming_warning_threshold,
+                                                        &outgoing_warning_threshold);
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        return OK;
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Tom Shields/Karl DeBisschop\n\n"
+                 "This plugin tests the UPS service on the specified host.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -F, --filename=STRING\n"
+                 "   File to read log from\n"
+                 " -e, --expires=INTEGER\n"
+                 "   Minutes after which log expires\n"
+                 " -a, --aggregation=(AVG|MAX)\n"
+                 "   Test average or maximum"
+                 " -w, --warning\n"
+                 "   Warning threshold pair \"<incoming>,<outgoing>\"\n"
+                 " -c, --critical\n"
+                 "   Critical threshold pair \"<incoming>,<outgoing>\"\n"
+                 " -h, --help\n"
+                 "   Print detailed help screen\n"
+                 " -V, --version\n" "   Print version information\n\n");
+        support ();
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s  -F <log_file> -a <AVG | MAX> -v <variable> -w <warning_pair> -c <critical_pair>\n"
+                 "            [-e expire_minutes] [-t timeout] [-v]\n"
+                 "       %s --help\n"
+                 "       %s --version\n", PROGNAME, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_mysql.c b/plugins/check_mysql.c
new file mode 100644
index 00000000..50836f91
--- /dev/null
+++ b/plugins/check_mysql.c
@@ -0,0 +1,297 @@
+/******************************************************************************
+*
+* CHECK_MYSQL.C
+*
+* Program: Mysql plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Didi Rieder (adrieder@sbox.tu-graz.ac.at)
+*  portions (c) 2000 Karl DeBisschop (kdebisschop@users.sourceforge.net)
+* 
+* $Id$
+*
+* Description:
+*
+* This plugin is for testing a mysql server.
+******************************************************************************/
+
+#define PROGNAME "check_mysql"
+
+#include "common.h"
+#include "utils.h"
+
+#include <mysql/mysql.h>
+#include <mysql/errmsg.h>
+
+char *db_user = NULL;
+char *db_host = NULL;
+char *db_pass = NULL;
+char *db = NULL;
+unsigned int db_port = MYSQL_PORT;
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+int check_disk (int usp, int free_disk);
+void print_help (void);
+void print_usage (void);
+
+int
+main (int argc, char **argv)
+{
+
+        MYSQL mysql;
+        char result[1024];
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* initialize mysql  */
+        mysql_init (&mysql);
+
+        /* establish a connection to the server and error checking */
+        if (!mysql_real_connect
+                        (&mysql, db_host, db_user, db_pass, db, db_port, NULL, 0)) {
+
+                if (mysql_errno (&mysql) == CR_UNKNOWN_HOST) {
+                        printf ("%s\n", mysql_error (&mysql));
+                        return STATE_WARNING;
+
+                }
+                else if (mysql_errno (&mysql) == CR_VERSION_ERROR) {
+                        printf ("%s\n", mysql_error (&mysql));
+                        return STATE_WARNING;
+
+                }
+                else if (mysql_errno (&mysql) == CR_OUT_OF_MEMORY) {
+                        printf ("%s\n", mysql_error (&mysql));
+                        return STATE_WARNING;
+
+                }
+                else if (mysql_errno (&mysql) == CR_IPSOCK_ERROR) {
+                        printf ("%s\n", mysql_error (&mysql));
+                        return STATE_WARNING;
+
+                }
+                else if (mysql_errno (&mysql) == CR_SOCKET_CREATE_ERROR) {
+                        printf ("%s\n", mysql_error (&mysql));
+                        return STATE_WARNING;
+
+                }
+                else {
+                        printf ("%s\n", mysql_error (&mysql));
+                        return STATE_CRITICAL;
+                }
+
+        }
+
+        /* get the server stats */
+        sprintf (result, mysql_stat (&mysql));
+
+        /* error checking once more */
+        if (mysql_error (&mysql)) {
+
+                if (mysql_errno (&mysql) == CR_SERVER_GONE_ERROR) {
+                        printf ("%s\n", mysql_error (&mysql));
+                        return STATE_CRITICAL;
+
+                }
+                else if (mysql_errno (&mysql) == CR_SERVER_LOST) {
+                        printf ("%s\n", mysql_error (&mysql));
+                        return STATE_CRITICAL;
+
+                }
+                else if (mysql_errno (&mysql) == CR_UNKNOWN_ERROR) {
+                        printf ("%s\n", mysql_error (&mysql));
+                        return STATE_UNKNOWN;
+                }
+
+        }
+
+        /* close the connection */
+        mysql_close (&mysql);
+
+        /* print out the result of stats */
+        printf ("%s\n", result);
+
+        return STATE_OK;
+}
+
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+        if (argc < 1)
+                return ERROR;
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (db_host == NULL)
+                        if (is_host (argv[c])) {
+                                db_host = argv[c];
+                        }
+                        else {
+                                usage ("Invalid host name");
+                        }
+                else if (db_user == NULL)
+                        db_user = argv[c];
+                else if (db_pass == NULL)
+                        db_pass = argv[c];
+                else if (db == NULL)
+                        db = argv[c];
+                else if (is_intnonneg (argv[c]))
+                        db_port = atoi (argv[c]);
+        }
+
+        if (db_host == NULL)
+                db_host = strscpy (db_host, "127.0.0.1");
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"database", required_argument, 0, 'd'},
+                {"username", required_argument, 0, 'u'},
+                {"password", required_argument, 0, 'p'},
+                {"port", required_argument, 0, 'P'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVP:p:u:d:H:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+?hVP:p:u:d:H:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 'P':
+                case 'p':
+                case 'u':
+                case 'd':
+                case 'H':
+                        i++;
+                }
+
+                switch (c) {
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg)) {
+                                db_host = optarg;
+                        }
+                        else {
+                                usage ("Invalid host name\n");
+                        }
+                        break;
+                case 'd':                                                                       /* hostname */
+                        db = optarg;
+                        break;
+                case 'u':                                                                       /* username */
+                        db_user = optarg;
+                        break;
+                case 'p':                                                                       /* authentication information: password */
+                        db_pass = optarg;
+                        break;
+                case 'P':                                                                       /* critical time threshold */
+                        db_port = atoi (optarg);
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        return OK;
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Didi Rieder/Karl DeBisschop\n\n"
+                 "This plugin is for testing a mysql server.\n");
+        print_usage ();
+        printf
+                ("\nThere are no required arguments. By default, the local database with\n"
+                 "a server listening on MySQL standard port %d will be checked\n\n"
+                 "Options:\n"
+                 " -d, --database=STRING\n"
+                 "   Check database with indicated name\n"
+                 " -H, --hostname=STRING or IPADDRESS\n"
+                 "   Check server on the indicated host\n"
+                 " -P, --port=INTEGER\n"
+                 "   Make connection on the indicated port\n"
+                 " -u, --username=STRING\n"
+                 "   Connect using the indicated username\n"
+                 " -p, --password=STRING\n"
+                 "   Use the indicated password to authenticate the connection\n"
+                 "   ==> IMPORTANT: THIS FORM OF AUTHENTICATION IS NOT SECURE!!! <==\n"
+                 "   Your clear-text password will be visible as a process table entry\n"
+                 " -h, --help\n"
+                 "    Print detailed help screen\n"
+                 " -V, --version\n" "    Print version information\n\n", MYSQL_PORT);
+        support ();
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s [-d database] [-H host] [-P port] [-u user] [-p password]\n"
+                 "       %s --help\n"
+                 "       %s --version\n", PROGNAME, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_nagios.c b/plugins/check_nagios.c
new file mode 100644
index 00000000..04258354
--- /dev/null
+++ b/plugins/check_nagios.c
@@ -0,0 +1,267 @@
+/******************************************************************************
+ *
+ * CHECK_NAGIOS.C
+ *
+ * Program: Nagios process plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ *
+ * $Id$
+ *
+ * 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"
+
+#define PROGNAME "check_nagios"
+
+int process_arguments (int, char **);
+void print_usage (void);
+void print_help (void);
+
+char *status_log = NULL;
+char *process_string = NULL;
+int expire_minutes = 0;
+
+int
+main (int argc, char **argv)
+{
+        int result = STATE_UNKNOWN;
+        char input_buffer[MAX_INPUT_BUFFER];
+        unsigned long latest_entry_time = 0L;
+        unsigned long temp_entry_time = 0L;
+        int proc_entries = 0;
+        time_t current_time;
+        char *temp_ptr;
+        FILE *fp;
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments\n");
+
+        /* Set signal handling and alarm */
+        if (signal (SIGALRM, timeout_alarm_handler) == SIG_ERR) {
+                printf ("Cannot catch SIGALRM");
+                return STATE_UNKNOWN;
+        }
+
+        /* handle timeouts gracefully... */
+        alarm (timeout_interval);
+
+        /* open the status log */
+        fp = fopen (status_log, "r");
+        if (fp == NULL) {
+                printf ("Error: Cannot open status log for reading!\n");
+                return STATE_CRITICAL;
+        }
+
+        /* get the date/time of the last item updated in the log */
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
+                temp_ptr = strtok (input_buffer, "]");
+                temp_entry_time =
+                        (temp_ptr == NULL) ? 0L : strtoul (temp_ptr + 1, NULL, 10);
+                if (temp_entry_time > latest_entry_time)
+                        latest_entry_time = temp_entry_time;
+        }
+        fclose (fp);
+
+        /* run the command to check for the Nagios process.. */
+        child_process = spopen (PS_RAW_COMMAND);
+        if (child_process == NULL) {
+                printf ("Could not open pipe: %s\n", PS_RAW_COMMAND);
+                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", PS_RAW_COMMAND);
+        }
+
+        /* cound the number of matching Nagios processes... */
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+                if (strstr (input_buffer, process_string))
+                        proc_entries++;
+        }
+
+        /* If we get anything on stderr, at least set warning */
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
+                result = max (result, STATE_WARNING);
+
+        /* close stderr */
+        (void) fclose (child_stderr);
+
+        /* close the pipe */
+        if (spclose (child_process))
+                result = max (result, STATE_WARNING);
+
+        /* reset the alarm handler */
+        alarm (0);
+
+        if (proc_entries == 0) {
+                printf ("Could not locate a running Nagios process!\n");
+                return STATE_CRITICAL;
+        }
+
+        result = STATE_OK;
+
+        time (&current_time);
+        if ((current_time - latest_entry_time) > (expire_minutes * 60))
+                result = STATE_WARNING;
+
+        printf
+                ("Nagios %s: located %d process%s, status log updated %d second%s ago\n",
+                 (result == STATE_OK) ? "ok" : "problem", proc_entries,
+                 (proc_entries == 1) ? "" : "es",
+                 (int) (current_time - latest_entry_time),
+                 ((int) (current_time - latest_entry_time) == 1) ? "" : "s");
+
+        return result;
+}
+
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"filename", required_argument, 0, 'F'},
+                {"expires", required_argument, 0, 'e'},
+                {"command", required_argument, 0, 'C'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        if (argc < 2)
+                return ERROR;
+
+        if (!is_option (argv[1])) {
+                status_log = argv[1];
+                if (is_intnonneg (argv[2]))
+                        expire_minutes = atoi (argv[2]);
+                else
+                        terminate (STATE_UNKNOWN,
+                                                                 "Expiration time must be an integer (seconds)\nType '%s -h' for additional help\n",
+                                                                 PROGNAME);
+                process_string = argv[3];
+                return OK;
+        }
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c = getopt_long (argc, argv, "+hVF:C:e:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+hVF:C:e:");
+#endif
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case '?':                                                                       /* print short usage statement if args not parsable */
+                        printf ("%s: Unknown argument: %c\n\n", my_basename (argv[0]), optopt);
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'F':                                                                       /* hostname */
+                        status_log = optarg;
+                        break;
+                case 'C':                                                                       /* hostname */
+                        process_string = optarg;
+                        break;
+                case 'e':                                                                       /* hostname */
+                        if (is_intnonneg (optarg))
+                                expire_minutes = atoi (optarg);
+                        else
+                                terminate (STATE_UNKNOWN,
+                                                                         "Expiration time must be an integer (seconds)\nType '%s -h' for additional help\n",
+                                                                         PROGNAME);
+                        break;
+                }
+        }
+
+
+        if (status_log == NULL)
+                terminate (STATE_UNKNOWN,
+                                                         "You must provide the status_log\nType '%s -h' for additional help\n",
+                                                         PROGNAME);
+        else if (process_string == NULL)
+                terminate (STATE_UNKNOWN,
+                                                         "You must provide a process string\nType '%s -h' for additional help\n",
+                                                         PROGNAME);
+
+        return OK;
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -F <status log file> -e <expire_minutes> -C <process_string>\n",
+                 PROGNAME);
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Ethan Galstad/Karl DeBisschop\n\n"
+                 "This plugin attempts to check the status of the Nagios process on the local\n"
+                 "machine. The plugin will check to make sure the Nagios status log is no older\n"
+                 "than the number of minutes specified by the <expire_minutes> option.  It also\n"
+                 "uses the /bin/ps command to check for a process matching whatever you specify\n"
+                 "by the <process_string> argument.\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 "-F, --filename=FILE\n"
+                 "   Name of the log file to check\n"
+                 "-e, --expires=INTEGER\n"
+                 "   Seconds aging afterwhich logfile is condsidered stale\n"
+                 "-C, --command=STRING\n"
+                 "   Command to search for in process table\n"
+                 "-h, --help\n"
+                 "   Print this help screen\n"
+                 "-V, --version\n"
+                 "   Print version information\n\n"
+                 "Example:\n"
+                 "   ./check_nagios -H /usr/local/nagios/var/status.log -e 5 -C /usr/local/nagios/bin/nagios\n");
+}
diff --git a/plugins/check_nntp.c b/plugins/check_nntp.c
new file mode 100644
index 00000000..4bdc83ab
--- /dev/null
+++ b/plugins/check_nntp.c
@@ -0,0 +1,418 @@
+/******************************************************************************
+ *
+ * CHECK_NNTP.C
+ *
+ * Program: NNTP plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ *
+ * $Id$
+ *
+ * Description:
+ *
+ * This plugin will attempt to open an NNTP connection with the host.
+ * Successul connects return STATE_OK, refusals and timeouts return
+ * STATE_CRITICAL, other errors return STATE_UNKNOWN.  Successful
+ * connects, but incorrect reponse messages from the host result in
+ * STATE_WARNING return values.  An invalid newsgroup (if the -g
+ * option is used) results in a STATE_WARNING value.
+ *
+ * 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 "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define PROGNAME "check_nntp"
+
+#define PORT 119
+#define EXPECT1A "200"                                  /* posting allowed */
+#define EXPECT1B "201"                                  /* posting not allowed */
+#define EXPECT "NNTP"
+#define QUIT "QUIT\r\n"
+#define MODEREADER "MODE READER\r\n"
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+int check_disk (int usp, int free_disk);
+void print_help (void);
+void print_usage (void);
+
+int server_port = PORT;
+char *server_expect = NULL;
+char *server_address = NULL;
+char *newsgroup = NULL;
+int check_newsgroup = FALSE;
+int send_modereader = FALSE;
+int warning_time = 0;
+int check_warning_time = FALSE;
+int critical_time = 0;
+int check_critical_time = FALSE;
+int verbose = FALSE;
+
+
+int
+main (int argc, char **argv)
+{
+        char buffer[MAX_INPUT_BUFFER] = "";
+        int sd;
+        int result;
+        int recv_result;
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+
+        /* try to connect to the host at the given port number */
+        time (&start_time);
+        result = my_tcp_connect (server_address, server_port, &sd);
+
+        /* we connected */
+        if (result == STATE_OK) {
+
+                /* watch for the NNTP connection string */
+                recv_result = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+
+                /* return a WARNING status if we couldn't read any data */
+                if (recv_result == -1) {
+
+                        printf ("recv() failed\n");
+                        result = STATE_WARNING;
+
+                }
+                else {
+
+                        /* strip carriage returns from buffer */
+                        strip (buffer);
+
+                        /* make sure we find the response we are looking for */
+                        if (strstr (buffer, EXPECT1A) != buffer
+                                        && strstr (buffer, EXPECT1B) != buffer) {
+                                printf ("Invalid NNTP response received from host: %s\n", buffer);
+                                result = STATE_WARNING;
+                        }
+
+                        /* optionally send mode reader */
+                        /* added 2000-09-18 by Andreas M. Kirchwitz <amk@krell.snafu.de> including some other minor fixes */
+                        if (send_modereader == TRUE) {
+                                send (sd, MODEREADER, strlen (MODEREADER), 0);
+                                recv_result = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+                                if (recv_result == -1)
+                                        strcpy (buffer, "");
+                                else
+                                        buffer[recv_result] = 0;
+                                strip (buffer);
+                                if ((strstr (buffer, EXPECT1A) != buffer)
+                                                && (strstr (buffer, EXPECT1B) != buffer)) {
+                                        printf ("Unexpected NNTP response received from host");
+                                        result = STATE_WARNING;
+                                }
+                        }
+
+                        if (server_expect && !strstr (buffer, server_expect)) {
+                                printf ("Invalid NNTP header received from host: %s\n", buffer);
+                                result = STATE_WARNING;
+                        }
+
+                        if (check_newsgroup == TRUE) {
+                                sprintf (buffer, "GROUP %s\r\n", newsgroup);
+                                send (sd, buffer, strlen (buffer), 0);
+                                recv_result = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+                                if (recv_result == -1)
+                                        strcpy (buffer, "");
+                                else
+                                        buffer[recv_result] = 0;
+                                strip (buffer);
+                                if (strstr (buffer, "211") != buffer) {
+                                        printf ("NNTP problem - newsgroup '%s' not found\n", newsgroup);
+                                        result = STATE_WARNING;
+                                }
+                        }
+
+                        if (result == STATE_OK) {
+                                time (&end_time);
+                                if (check_critical_time == TRUE
+                                                && (end_time - start_time) > critical_time) result =
+                                                STATE_CRITICAL;
+                                else if (check_warning_time == TRUE
+                                                                 && (end_time - start_time) > warning_time) result =
+                                                STATE_WARNING;
+                                if (verbose)
+                                        printf ("NNTP %s - %d sec. response time, %s\n",
+                                                                        (result == STATE_OK) ? "ok" : "problem",
+                                                                        (int) (end_time - start_time), buffer);
+                                else
+                                        printf ("NNTP %s - %d second response time\n",
+                                                                        (result == STATE_OK) ? "ok" : "problem",
+                                                                        (int) (end_time - start_time));
+                        }
+
+                }
+
+                /* close the connection */
+                send (sd, QUIT, strlen (QUIT), 0);
+                close (sd);
+
+        }
+
+        /* reset the alarm timeout */
+        alarm (0);
+
+        return result;
+}
+
+
+
+
+
+
+/* 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");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (server_address == NULL) {
+                        if (is_host (argv[c])) {
+                                server_address = argv[c];
+                        }
+                        else {
+                                usage ("Invalid host name");
+                        }
+                }
+        }
+
+        if (server_address == NULL)
+                server_address = strscpy (NULL, "127.0.0.1");
+
+/*      if (server_expect==NULL) */
+/*              server_expect=strscpy(NULL,EXPECT); */
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"expect", required_argument, 0, 'e'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"port", required_argument, 0, 'P'},
+                {"modereader", required_argument, 0, 'M'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVMvt:p:e:c:w:H:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+?hVMvt:p:e:c:w:H:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 't':
+                case 'p':
+                case 'e':
+                case 'c':
+                case 'w':
+                case 'H':
+                        i++;
+                }
+
+                switch (c) {
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg)) {
+                                server_address = optarg;
+                        }
+                        else {
+                                usage ("Invalid host name\n");
+                        }
+                        break;
+                case 'p':                                                                       /* port */
+                        if (is_intpos (optarg)) {
+                                server_port = atoi (optarg);
+                        }
+                        else {
+                                usage ("Server port must be a positive integer\n");
+                        }
+                        break;
+                case 'M':                                                                       /* mode reader */
+                        send_modereader = TRUE;
+                        break;
+                case 'e':                                                                       /* expect */
+                        server_expect = optarg;
+                        break;
+                case 'g':                                                                       /* newsgroup */
+                        newsgroup = optarg;
+                        check_newsgroup = TRUE;
+                        break;
+                case 'c':                                                                       /* critical time threshold */
+                        if (is_intnonneg (optarg)) {
+                                critical_time = atoi (optarg);
+                                check_critical_time = TRUE;
+                        }
+                        else {
+                                usage ("Critical time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'w':                                                                       /* warning time threshold */
+                        if (is_intnonneg (optarg)) {
+                                warning_time = atoi (optarg);
+                                check_warning_time = TRUE;
+                        }
+                        else {
+                                usage ("Warning time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'v':                                                                       /* verbose */
+                        verbose = TRUE;
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (is_intnonneg (optarg)) {
+                                socket_timeout = atoi (optarg);
+                        }
+                        else {
+                                usage ("Time interval must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        return OK;
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Ethan Galstad/Karl DeBisschop\n\n"
+                 "This plugin tests the NNTP service on the specified host.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -H, --hostname=STRING or IPADDRESS\n"
+                 "   Check server on the indicated host\n"
+                 " -p, --port=INTEGER\n"
+                 "   Make connection on the indicated port (default: %d)\n"
+                 " -e, --expect=STRING\n"
+                 "   String to expect in first line of server response (default: %s)\n"
+                 " -g, --group=STRING\n"
+                 "   Newsgroup to poll\n"
+                 " -w, --warning=INTEGER\n"
+                 "   Seconds necessary to result in a warning status\n"
+                 " -c, --critical=INTEGER\n"
+                 "   Seconds necessary to result in a critical status\n"
+                 " -t, --timeout=INTEGER\n"
+                 "   Seconds before connection attempt times out (default: %d)\n"
+                 " -M\n"
+                 "   Send \"MODE READER\" after initial connect.\n"
+                 " -v, --verbose\n"
+                 "   Print extra information (command-line use only)\n"
+                 " -h, --help\n"
+                 "   Print detailed help screen\n"
+                 " -V, --version\n"
+                 "   Print version information\n\n",
+                 PORT, EXPECT, DEFAULT_SOCKET_TIMEOUT);
+        support ();
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H host [-e expect] [-g group] [-p port] [-w warn] [-c crit]\n"
+                 "            [-t timeout] [-v]\n"
+                 "       %s --help\n"
+                 "       %s --version\n", PROGNAME, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_nt.c b/plugins/check_nt.c
new file mode 100644
index 00000000..ed0dc98b
--- /dev/null
+++ b/plugins/check_nt.c
@@ -0,0 +1,548 @@
+/******************************************************************************
+ *
+ * This file is part of the Nagios Plugins.
+ *
+ * Copyright (c) 2000 Yves Rubin <rubiyz@yahoo.com>
+ *
+ * The Nagios Plugins are free software; you can redistribute them
+ * and/or modify them 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.
+ *
+ * $Id$
+ *
+ *****************************************************************************/
+ 
+#define PROGRAM check_nt
+#define DESCRIPTION "Windows NT plugin for Nagios"
+#define AUTHOR "Yves Rubin"
+#define EMAIL "rubiyz@yahoo.com"
+#define COPYRIGHTDATE "2000"
+
+//#include "stdlib.h"
+#include "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define CHECK_NONE      0
+#define CHECK_CLIENTVERSION     1
+#define CHECK_CPULOAD   2
+#define CHECK_UPTIME    3
+#define CHECK_USEDDISKSPACE     4
+#define CHECK_SERVICESTATE      5
+#define CHECK_PROCSTATE 6
+#define CHECK_MEMUSE    7
+#define CHECK_COUNTER   8
+#define MAX_VALUE_LIST 30
+
+#define PORT    1248    
+
+char *server_address=NULL;
+char *volume_name=NULL;
+int server_port=PORT;
+char *value_list=NULL;
+char *req_password=NULL;
+unsigned long lvalue_list[MAX_VALUE_LIST];
+unsigned long warning_value=0L;
+unsigned long critical_value=0L;
+int check_value_list=FALSE;
+int check_warning_value=FALSE;
+int check_critical_value=FALSE;
+int vars_to_check=CHECK_NONE;
+int show_all=FALSE;
+
+#define PROGNAME "check_nt"
+
+int process_arguments(int, char **);
+void print_usage(void);
+void print_help(void);
+void preparelist(char *string);
+
+int main(int argc, char **argv){
+        int result;
+        int return_code;
+        char *send_buffer=NULL;
+        char recv_buffer[MAX_INPUT_BUFFER];
+        char *output_message=NULL;
+        char *temp_buffer=NULL;
+        char *temp_string=NULL;
+        char *sep_string=NULL;
+        char *description=NULL;
+
+        double total_disk_space=0;
+        double free_disk_space=0;
+        double percent_used_space=0;
+        double mem_commitLimit=0;
+        double mem_commitByte=0;
+        unsigned long current_connections=0;
+        unsigned long utilization;
+        unsigned long uptime;
+        unsigned long cache_hits;
+        unsigned long cache_buffers;
+        unsigned long lru_time;
+        double counter_value;
+        int offset=0;
+        int updays=0;
+        int uphours=0;
+        int upminutes=0;
+        req_password=strscpy(req_password,"None");
+
+        if(process_arguments(argc,argv)==ERROR)
+                usage("Could not parse arguments\n");
+
+        /* initialize alarm signal handling */
+        signal(SIGALRM,socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm(socket_timeout);
+
+        if (vars_to_check==CHECK_CLIENTVERSION) {
+                        
+                send_buffer = strscpy(send_buffer,strcat(req_password,"&1"));
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                output_message = strscpy(output_message,recv_buffer);
+                return_code=STATE_OK;
+        }
+        else if(vars_to_check==CHECK_CPULOAD){
+
+                if (check_value_list==TRUE) {                                                                                                                                                   
+                        if (strtolarray(&lvalue_list,value_list,",")==TRUE) {
+                                // -l parameters is present with only integers
+                                return_code=STATE_OK;
+                                temp_string = strscpy(temp_string,"CPU Load");
+                                while (lvalue_list[0+offset]>0 && lvalue_list[0+offset]<=17280 && 
+                                                        lvalue_list[1+offset]>=0 && lvalue_list[1+offset]<=100 && 
+                                                        lvalue_list[2+offset]>=0 && lvalue_list[2+offset]<=100) {
+                                        // loop until one of the parameters is wrong or not present
+
+                                        // Send request and retrieve data
+                                        send_buffer = ssprintf(send_buffer,"%s&2&%lu",req_password,lvalue_list[0+offset]);
+                                        result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                                        if(result!=STATE_OK)
+                                                return result;
+
+                                        if (!strncmp(recv_buffer,"ERROR",5)) {
+                                                printf("NSClient - %s\n",recv_buffer);
+                                                exit(STATE_UNKNOWN);
+                                        }
+
+                                        utilization=strtoul(recv_buffer,NULL,10);
+
+                                        // Check if any of the request is in a warning or critical state
+                                        if(utilization >= lvalue_list[2+offset])
+                                                return_code=STATE_CRITICAL;
+                                        else if(utilization >= lvalue_list[1+offset] && return_code<STATE_WARNING)
+                                                return_code=STATE_WARNING;
+
+                                        output_message = ssprintf(output_message," (%lu min. %lu%)",lvalue_list[0+offset], utilization);
+                                        temp_string = strscat(temp_string,output_message);
+                                        offset+=3;      //move accross the array 
+                                }               
+                                if (strlen(temp_string)>10) {
+                                        // we had at least on loop
+                                        output_message = ssprintf(output_message,"%s",temp_string);
+                                }       
+                                else
+                                        output_message = strscpy(output_message,"not enough values for -l parameters");
+                                        
+                        } else 
+                                output_message = strscpy(output_message,"wrong -l parameter.");
+
+                } else
+                        output_message = strscpy(output_message,"missing -l parameters");
+        }
+
+        else if(vars_to_check==CHECK_UPTIME){
+
+                send_buffer = strscpy(send_buffer,strcat(req_password,"&3"));
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+
+                if (!strncmp(recv_buffer,"ERROR",5)) {
+                        printf("NSClient - %s\n",recv_buffer);
+                        exit(STATE_UNKNOWN);
+                }
+
+                uptime=strtoul(recv_buffer,NULL,10);
+                updays = uptime / 86400;                        
+                uphours = (uptime % 86400) / 3600;
+                upminutes = ((uptime % 86400) % 3600) / 60;
+                output_message = ssprintf(output_message,"System Uptime : %u day(s) %u hour(s) %u minute(s)",updays,uphours, upminutes);
+                return_code=STATE_OK;
+        }
+
+        else if(vars_to_check==CHECK_USEDDISKSPACE){
+
+                return_code=STATE_UNKNOWN;      
+                if (check_value_list==TRUE) {
+                        if (strlen(value_list)==1) {
+                                send_buffer = ssprintf(send_buffer,"%s&4&%s", req_password, value_list);
+                                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                                if(result!=STATE_OK)
+                                        return result;
+                
+                                if (!strncmp(recv_buffer,"ERROR",5)) {
+                                        printf("NSClient - %s\n",recv_buffer);
+                                        exit(STATE_UNKNOWN);
+                                }
+
+                                free_disk_space=atof(strtok(recv_buffer,"&"));
+                                total_disk_space=atof(strtok(NULL,"&"));
+                                percent_used_space = ((total_disk_space - free_disk_space) / total_disk_space) * 100;
+
+                                if (free_disk_space>=0) {
+                                        temp_string = ssprintf(temp_string,"%s:\\ - total: %.2f Gb - used: %.2f Gb (%.0f%%) - free %.2f Gb (%.0f%%)",
+                                                        value_list, total_disk_space / 1073741824, (total_disk_space - free_disk_space) / 1073741824, percent_used_space,
+                                                         free_disk_space / 1073741824, (free_disk_space / total_disk_space)*100); 
+
+
+                                        if(check_critical_value==TRUE && percent_used_space >= critical_value)
+                                                return_code=STATE_CRITICAL;
+                                        else if (check_warning_value==TRUE && percent_used_space >= warning_value)
+                                                return_code=STATE_WARNING;      
+                                        else
+                                                return_code=STATE_OK;   
+
+                                        output_message = ssprintf(output_message,"%s",temp_string);
+
+                                }
+                                else {
+                                        output_message = ssprintf(output_message,"Free disk space : Invalid drive ");
+                                        return_code=STATE_UNKNOWN;
+                                }               
+                        }
+                        else 
+                                output_message = strscpy(output_message,"wrong -l argument");
+                } else 
+                        output_message = strscpy(output_message,"missing -l parameters");
+                        
+        }
+
+        else if(vars_to_check==CHECK_SERVICESTATE || vars_to_check==CHECK_PROCSTATE){
+
+                if (check_value_list==TRUE) {
+                        preparelist(value_list);                // replace , between services with & to send the request
+                        send_buffer = ssprintf(send_buffer,"%s&%u&%s&%s", req_password,(vars_to_check==CHECK_SERVICESTATE)?5:6,
+                                (show_all==TRUE)?"ShowAll":"ShowFail",value_list);
+                        result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                        if(result!=STATE_OK)
+                                return result;
+        
+                        if (!strncmp(recv_buffer,"ERROR",5)) {
+                                printf("NSClient - %s\n",recv_buffer);
+                                exit(STATE_UNKNOWN);
+                        }
+                        return_code=atoi(strtok(recv_buffer,"&"));
+                        temp_string=strtok(NULL,"&");
+                        output_message = ssprintf(output_message, "%s",temp_string);
+                }
+                else 
+                        output_message = strscpy(output_message,"No service/process specified");
+        }
+
+        else if(vars_to_check==CHECK_MEMUSE) {
+                
+                send_buffer = ssprintf(send_buffer,"%s&7", req_password);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if (result!=STATE_OK)
+                        return result;
+
+                if (!strncmp(recv_buffer,"ERROR",5)) {
+                        printf("NSClient - %s\n",recv_buffer);
+                        exit(STATE_UNKNOWN);
+                }
+
+                mem_commitLimit=atof(strtok(recv_buffer,"&"));
+                mem_commitByte=atof(strtok(NULL,"&"));
+                percent_used_space = (mem_commitByte / mem_commitLimit) * 100;
+                output_message = ssprintf(output_message,"Memory usage: total:%.2f Mb - used: %.2f Mb (%.0f%%) - free: %.2f Mb (%.0f%%)", 
+                        mem_commitLimit / 1048576, mem_commitByte / 1048567, percent_used_space,  
+                        (mem_commitLimit - mem_commitByte) / 1048576, (mem_commitLimit - mem_commitByte) / mem_commitLimit * 100);
+        
+                if(check_critical_value==TRUE && percent_used_space >= critical_value)
+                        return_code=STATE_CRITICAL;
+                else if (check_warning_value==TRUE && percent_used_space >= warning_value)
+                        return_code=STATE_WARNING;      
+                else
+                        return_code=STATE_OK;   
+                
+        }
+
+        else if(vars_to_check==CHECK_COUNTER) {
+
+                if (check_value_list==TRUE) {                                                                                                                                                   
+                        preparelist(value_list);                // replace , between services with & to send the request
+                        send_buffer = ssprintf(send_buffer,"%s&8&%s", req_password,value_list);
+                        result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                        if (result!=STATE_OK)
+                                return result;
+        
+                        if (!strncmp(recv_buffer,"ERROR",5)) {
+                                printf("NSClient - %s\n",recv_buffer);
+                                exit(STATE_UNKNOWN);
+                        }
+
+                        strtok(value_list,"&");                 // burn the first parameters
+                        description = strtok(NULL,"&");
+                        counter_value = atof(recv_buffer);
+                        if (description == NULL) 
+                                output_message = ssprintf(output_message, "%.f", counter_value);
+                        else
+                                output_message = ssprintf(output_message, description, counter_value);
+        
+                        if (critical_value > warning_value) {
+                                // Normal thresholds            
+                                if(check_critical_value==TRUE && counter_value >= critical_value)
+                                        return_code=STATE_CRITICAL;
+                                else if (check_warning_value==TRUE && counter_value >= warning_value)
+                                        return_code=STATE_WARNING;      
+                                else
+                                        return_code=STATE_OK;   
+                        } 
+                        else {
+                                // inverse thresholds           
+                                if(check_critical_value==TRUE && counter_value <= critical_value)
+                                        return_code=STATE_CRITICAL;
+                                else if (check_warning_value==TRUE && counter_value <= warning_value)
+                                        return_code=STATE_WARNING;      
+                                else
+                                        return_code=STATE_OK;   
+                        }       
+                
+                }
+                else {
+                        output_message = strscpy(output_message,"No counter specified");
+                        result=STATE_UNKNOWN;
+                }
+        }
+
+        /* reset timeout */
+        alarm(0);
+
+        printf("%s\n",output_message);
+
+        return return_code;
+}
+
+
+/* process command-line arguments */
+int process_arguments(int argc, char **argv){
+        int c;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] =
+        { 
+                {"port",     required_argument,0,'p'},
+                {"timeout",  required_argument,0,'t'},
+                {"critical", required_argument,0,'c'},
+                {"warning",  required_argument,0,'w'},
+                {"variable", required_argument,0,'v'},
+                {"hostname", required_argument,0,'H'},
+                {"version",  no_argument,      0,'V'},
+                {"help",     no_argument,      0,'h'},
+                {0,0,0,0}
+        };
+#endif
+
+        /* no options were supplied */
+        if(argc<2) return ERROR;
+
+        /* backwards compatibility */
+        if (! is_option(argv[1])) {
+                server_address=argv[1];
+                argv[1]=argv[0];
+                argv=&argv[1];
+                argc--;
+        }
+
+  for (c=1;c<argc;c++) {
+    if(strcmp("-to",argv[c])==0)
+      strcpy(argv[c],"-t");
+    else if (strcmp("-wv",argv[c])==0)
+      strcpy(argv[c],"-w");
+    else if (strcmp("-cv",argv[c])==0)
+      strcpy(argv[c],"-c");
+        }
+
+        while (1){
+#ifdef HAVE_GETOPT_H
+                c = getopt_long(argc,argv,"+hVH:t:c:w:p:v:l:s:d:",long_options,&option_index);
+#else
+                c = getopt(argc,argv,"+hVH:t:c:w:p:v:l:s:d:");
+#endif
+
+                if (c==-1||c==EOF||c==1)
+                        break;
+
+                switch (c)
+                        {
+                        case '?': /* print short usage statement if args not parsable */
+                                printf("%s: Unknown argument: %s\n\n",my_basename(argv[0]),optarg);
+                                print_usage();
+                                exit(STATE_UNKNOWN);
+                        case 'h': /* help */
+                                print_help();
+                                exit(STATE_OK);
+                        case 'V': /* version */
+                                print_revision(my_basename(argv[0]),"$Revision$");
+                                exit(STATE_OK);
+                        case 'H': /* hostname */
+                                server_address=optarg;
+                                break;
+                        case 's': /* password */
+                                req_password=strscpy(req_password,optarg);
+                                break;
+                        case 'p': /* port */
+                                if (is_intnonneg(optarg))
+                                        server_port=atoi(optarg);
+                                else
+                                        terminate(STATE_UNKNOWN,"Server port an integer (seconds)\nType '%s -h' for additional help\n",PROGNAME);
+                                break;
+                        case 'v':
+                                if(strlen(optarg)<4)
+                                        return ERROR;
+                                if(!strcmp(optarg,"CLIENTVERSION"))
+                                        vars_to_check=CHECK_CLIENTVERSION;
+                                else if(!strcmp(optarg,"CPULOAD"))
+                                        vars_to_check=CHECK_CPULOAD;
+                                else if(!strcmp(optarg,"UPTIME"))
+                                        vars_to_check=CHECK_UPTIME;
+                                else if(!strcmp(optarg,"USEDDISKSPACE"))
+                                        vars_to_check=CHECK_USEDDISKSPACE;
+                                else if(!strcmp(optarg,"SERVICESTATE"))
+                                        vars_to_check=CHECK_SERVICESTATE;
+                                else if(!strcmp(optarg,"PROCSTATE"))
+                                        vars_to_check=CHECK_PROCSTATE;
+                                else if(!strcmp(optarg,"MEMUSE"))
+                                        vars_to_check=CHECK_MEMUSE;
+                                else if(!strcmp(optarg,"COUNTER"))
+                                        vars_to_check=CHECK_COUNTER;
+                                else
+                                        return ERROR;
+                                break;
+                        case 'l': /* value list */
+                                value_list=strscpy(value_list,optarg);
+                                check_value_list=TRUE;
+                                break;
+                        case 'w': /* warning threshold */
+                                warning_value=strtoul(optarg,NULL,10);
+                                check_warning_value=TRUE;
+                                break;
+                        case 'c': /* critical threshold */
+                                critical_value=strtoul(optarg,NULL,10);
+                                check_critical_value=TRUE;
+                                break;
+                        case 'd': /* Display select for services */
+                                if (!strcmp(optarg,"SHOWALL"))
+                                        show_all = TRUE;
+                                break;
+                        case 't': /* timeout */
+                                socket_timeout=atoi(optarg);
+                                if(socket_timeout<=0)
+                                        return ERROR;
+                        }
+
+        }
+
+        return OK;
+}
+
+
+void print_usage(void)
+{
+        printf("Usage: %s -H host [-p port] [-v variable] [-w warning] [-c critical] [-l params] [-d SHOWALL] [-t timeout]\n",PROGNAME);
+}
+
+
+void print_help(void)
+{
+        print_revision(PROGNAME,"$Revision$");
+        printf
+                ("Copyright (c) 2000 Yves Rubin (rubiyz@yahoo.com)\n\n"
+                 "This plugin attempts to contact the NSClient service running on a Windows NT or Windows 2000 server to\n"
+                 "gather the requested system information.\n\n");
+        print_usage();
+  printf
+                ("\nOptions:\n"
+                 "-H, --hostname=HOST\n"
+                 "   Name of the host to check\n"
+                 "-p, --port=INTEGER\n"
+                 "   Optional port number (default: %d)\n"
+                 "-s <password>\n"
+                 "   Password needed for the request\n"
+                 "-v, --variable=STRING\n"
+                 "   Variable to check.  Valid variables are:\n"
+                 "      CLIENTVERSION = Get the NSClient version\n"
+                 "      CPULOAD = Average CPU load on last x minutes. Request a -l parameter with the following syntax:\n"
+                 "        -l <minutes range>,<warning threshold>,<critical threshold>. <minute range> should be less than 24*60.\n"
+                 "        Thresholds are percentage and up to 10 requests can be done in one shot. ie: -l 60,90,95,120,90,95\n"
+                 "      UPTIME = Get the uptime of the machine. No specific parameters. No warning or critical threshold\n"
+                 "      USEDDISKSPACE = Size and percentage of disk use. Request a -l parameter containing the drive letter only.\n"
+                 "                      Warning and critical thresholds can be specified with -w and -c.\n"
+                 "      MEMUSE = Memory use. Warning and critical thresholds can be specified with -w and -c.\n" 
+                 "      SERVICESTATE = Check the state of one or several services. Request a -l parameters with the following syntax:\n"
+                 "        -l <service1>,<service2>,<service3>,... You can specify -d SHOWALL in case you want to see working services\n"
+                 "        in the returned string.\n"
+                 "      PROCSTATE = Check if one or several process are running. Same syntax as SERVICESTATE.\n"
+                 "      COUNTER = Check any performance counter of Windows NT/2000. Request a -l parameters with the following syntax:\n"
+                 "        -l \"\\\\<performance object>\\\\counter\",\"<description>\"  The <description> parameter is optional and \n"
+                 "        is given to a printf output command which require a float parameters. Some examples:\n"
+                 "          \"Paging file usage is %%.2f %%%%\" or \"%%.f %%%% paging file used.\"\n"
+                 " -w, --warning=INTEGER\n"
+                 "   Threshold which will result in a warning status\n"
+                 " -c, --critical=INTEGER\n"
+                 "   Threshold which will result in a critical status\n"
+                 " -t, --timeout=INTEGER\n"
+                 "   Seconds before connection attempt times out (default: %d)\n"
+                 "-h, --help\n"
+                 "   Print this help screen\n"
+                 "-V, --version\n"
+                 "   Print version information\n\n"
+                 "Notes:\n"
+                 " - The NSClient service should be running on the server to get any information.\n"
+                 " - Critical thresholds should be lower than warning thresholds\n", PORT, DEFAULT_SOCKET_TIMEOUT);
+}
+
+int strtolarray(unsigned long *array, char *string, char *delim) {
+        // split a <delim> delimited string into a long array
+        int idx=0;
+        char *t1;
+
+        for (idx=0;idx<MAX_VALUE_LIST;idx++)
+                array[idx]=-1;
+        
+        idx=0;
+        for(t1 = strtok(string,delim);t1 != NULL; t1 = strtok(NULL, delim)) {
+                if (is_numeric(t1) && idx<MAX_VALUE_LIST) {
+                        array[idx]=strtoul(t1,NULL,10);
+                        idx++;
+                } else  
+                        return FALSE;
+        }               
+        return TRUE;
+}
+
+void preparelist(char *string) {
+        // Replace all , with & which is the delimiter for the request
+        int i;
+
+        for (i = 0; i < strlen(string); i++)
+                if (string[i] == ',') {
+                        string[i]='&';
+                }
+}
+
diff --git a/plugins/check_nwstat.c b/plugins/check_nwstat.c
new file mode 100644
index 00000000..e1426702
--- /dev/null
+++ b/plugins/check_nwstat.c
@@ -0,0 +1,821 @@
+/******************************************************************************
+ *
+ * Program: NetWare statistics plugin for Nagios
+ * License: GPL
+ *
+ * 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.
+ *
+ * $Id$
+ *
+ *****************************************************************************/
+
+#define PROGNAME "check_nwstat"
+#define REVISION "$Revision$"
+#define COPYRIGHT "Copyright (c) 1999-2001 Ethan Galstad"
+
+#define SUMMARY "\
+This plugin attempts to contact the MRTGEXT NLM running on a Novell server\n\
+to gather the requested system information.\n"
+
+#define OPTIONS "\
+-H host [-v variable] [-w warning] [-c critical]\n\
+              [-p port] [-t timeout]"
+
+#define LONGOPTIONS "\
+-H, --hostname=HOST\n\
+  Name of the host to check\n\
+-v, --variable=STRING\n\
+  Variable to check.  Valid variables include:\n\
+     LOAD1    = 1 minute average CPU load\n\
+     LOAD5    = 5 minute average CPU load\n\
+     LOAD15   = 15 minute average CPU load\n\
+     CONNS    = number of currently licensed connections\n\
+     VPF<vol> = percent free space on volume <vol>\n\
+     VKF<vol> = KB of free space on volume <vol>\n\
+     LTCH     = percent long term cache hits\n\
+     CBUFF    = current number of cache buffers\n\
+     CDBUFF   = current number of dirty cache buffers\n\
+     LRUM     = LRU sitting time in minutes\n\
+     DSDB     = check to see if DS Database is open\n\
+     LOGINS   = check to see if logins are enabled\n\
+     UPRB     = used packet receive buffers\n\
+     PUPRB    = percent (of max) used packet receive buffers\n\
+     SAPENTRIES = number of entries in the SAP table\n\
+     SAPENTRIES<n> = number of entries in the SAP table for SAP type <n>\n\
+     OFILES   = number of open files\n\
+     VPP<vol> = percent purgeable space on volume <vol>\n\
+     VKP<vol> = KB of purgeable space on volume <vol>\n\
+     VPNP<vol> = percent not yet purgeable space on volume <vol>\n\
+     VKNP<vol> = KB of not yet purgeable space on volume <vol>\n\
+     ABENDS   = number of abended threads (NW 5.x only)\n\
+     CSPROCS  = number of current service processes (NW 5.x only)\n\
+-w, --warning=INTEGER\n\
+  Threshold which will result in a warning status\n\
+-c, --critical=INTEGER\n\
+  Threshold which will result in a critical status\n\
+-p, --port=INTEGER\n\
+  Optional port number (default: %d)\n\
+-t, --timeout=INTEGER\n\
+  Seconds before connection attempt times out (default: %d)\n\
+-o, --osversion\n\
+  Include server version string in results\n\
+-h, --help\n\
+  Print this help screen\n\
+-V, --version\n\
+  Print version information\n"
+
+#define DESCRIPTION "\
+Notes:\n\
+- This plugin requres that the MRTGEXT.NLM file from James Drews' MRTG\n\
+  extension for NetWare be loaded on the Novell servers you wish to check.\n\
+  (available from http://www.engr.wisc.edu/~drews/mrtg/)\n\
+- Values for critical thresholds should be lower than warning thresholds\n\
+  when the following variables are checked: VPF, VKF, LTCH, CBUFF, and LRUM.\n"
+
+#include "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define CHECK_NONE           0
+#define CHECK_LOAD1          1 /* check 1 minute CPU load */
+#define CHECK_LOAD5          2 /* check 5 minute CPU load */
+#define CHECK_LOAD15         3 /* check 15 minute CPU load */
+#define CHECK_CONNS          4 /* check number of connections */
+#define CHECK_VPF            5 /* check % free space on volume */
+#define CHECK_VKF            6 /* check KB free space on volume */
+#define CHECK_LTCH           7 /* check long-term cache hit percentage */
+#define CHECK_CBUFF          8 /* check total cache buffers */
+#define CHECK_CDBUFF         9 /* check dirty cache buffers */
+#define CHECK_LRUM          10 /* check LRU sitting time in minutes */
+#define CHECK_DSDB          11 /* check to see if DS Database is open */
+#define CHECK_LOGINS        12 /* check to see if logins are enabled */
+#define CHECK_PUPRB         13 /* check % of used packet receive buffers */
+#define CHECK_UPRB          14 /* check used packet receive buffers */
+#define CHECK_SAPENTRIES    15 /* check SAP entries */
+#define CHECK_OFILES        16 /* check number of open files */
+#define CHECK_VKP           17 /* check KB purgeable space on volume */
+#define CHECK_VPP           18 /* check % purgeable space on volume */
+#define CHECK_VKNP          19 /* check KB not yet purgeable space on volume */
+#define CHECK_VPNP          20 /* check % not yet purgeable space on volume */
+#define CHECK_ABENDS        21 /* check abended thread count */
+#define CHECK_CSPROCS       22 /* check number of current service processes */
+
+#define PORT 9999
+
+char *server_address=NULL;
+char *volume_name=NULL;
+int server_port=PORT;
+unsigned long warning_value=0L;
+unsigned long critical_value=0L;
+int check_warning_value=FALSE;
+int check_critical_value=FALSE;
+int check_netware_version=FALSE;
+unsigned long vars_to_check=CHECK_NONE;
+int sap_number=-1;
+
+#define PROGNAME "check_nwstat"
+
+int process_arguments(int, char **);
+void print_usage(void);
+void print_help(void);
+
+int main(int argc, char **argv){
+        int result;
+        char *send_buffer=NULL;
+        char recv_buffer[MAX_INPUT_BUFFER];
+        char *output_message=NULL;
+        char *temp_buffer=NULL;
+        char *netware_version=NULL;
+
+        int open_files=0;
+        int abended_threads=0;
+        int max_service_processes=0;
+        int current_service_processes=0;
+        unsigned long free_disk_space=0L;
+        unsigned long total_disk_space=0L;
+        unsigned long purgeable_disk_space=0L;
+        unsigned long non_purgeable_disk_space=0L;
+        int percent_free_space=0;
+        int percent_purgeable_space=0;
+        int percent_non_purgeable_space=0;
+        unsigned long current_connections=0L;
+        unsigned long utilization=0L;
+        int cache_hits=0;
+        unsigned long cache_buffers=0L;
+        unsigned long lru_time=0L;
+        char uptime[MAX_INPUT_BUFFER];
+        int max_packet_receive_buffers=0;
+        int used_packet_receive_buffers=0;
+        unsigned long percent_used_packet_receive_buffers=0L;
+        int sap_entries=0;
+
+        if(process_arguments(argc,argv)==ERROR)
+                usage("Could not parse arguments\n");
+
+        /* initialize alarm signal handling */
+        signal(SIGALRM,socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm(socket_timeout);
+        
+        /* get OS version string */
+        if (check_netware_version==TRUE) {
+                send_buffer = strscpy(send_buffer,"S19\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                if(!strcmp(recv_buffer,"-1\n"))
+                        netware_version = ssprintf(netware_version,"");
+                else {
+                        recv_buffer[strlen(recv_buffer)-1]=0;
+                        netware_version = ssprintf(netware_version,"NetWare %s: ",recv_buffer);
+                }
+        } else
+                netware_version = ssprintf(netware_version,"");
+
+
+        /* check CPU load */
+        if (vars_to_check==CHECK_LOAD1 || vars_to_check==CHECK_LOAD5 || vars_to_check==CHECK_LOAD15) {
+                        
+                switch(vars_to_check){
+                case CHECK_LOAD1:
+                        temp_buffer = strscpy(temp_buffer,"1");
+                        break;
+                case CHECK_LOAD5:
+                        temp_buffer = strscpy(temp_buffer,"5");
+                        break;
+                default:
+                        temp_buffer = strscpy(temp_buffer,"15");
+                        break;
+                }
+
+                send_buffer = ssprintf(send_buffer,"UTIL%s\r\n",temp_buffer);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                utilization=strtoul(recv_buffer,NULL,10);
+                send_buffer = strscpy(send_buffer,"UPTIME\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                recv_buffer[strlen(recv_buffer)-1]=0;
+                sprintf(uptime,"Up %s,",recv_buffer);
+
+                if(check_critical_value==TRUE && utilization >= critical_value)
+                        result=STATE_CRITICAL;
+                else if(check_warning_value==TRUE && utilization >= warning_value)
+                        result=STATE_WARNING;
+
+                output_message = ssprintf(output_message,"Load %s - %s %s-min load average = %lu%%",(result==STATE_OK)?"ok":"problem",uptime,temp_buffer,utilization);
+
+        /* check number of user connections */
+        } else if (vars_to_check==CHECK_CONNS) {
+
+                send_buffer = strscpy(send_buffer,"CONNECT\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                current_connections=strtoul(recv_buffer,NULL,10);
+
+                if(check_critical_value==TRUE && current_connections >= critical_value)
+                        result=STATE_CRITICAL;
+                else if(check_warning_value==TRUE && current_connections >= warning_value)
+                        result=STATE_WARNING;
+                output_message = ssprintf(output_message,"Conns %s - %lu current connections",(result==STATE_OK)?"ok":"problem",current_connections);
+
+        /* check % long term cache hits */
+        } else if (vars_to_check==CHECK_LTCH) {
+
+                send_buffer = strscpy(send_buffer,"S1\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                cache_hits=atoi(recv_buffer);
+
+                if(check_critical_value==TRUE && cache_hits <= critical_value)
+                        result=STATE_CRITICAL;
+                else if(check_warning_value==TRUE && cache_hits <= warning_value)
+                        result=STATE_WARNING;
+                output_message = ssprintf(output_message,"Long term cache hits = %d%%",cache_hits);
+
+        /* check cache buffers */
+        } else if (vars_to_check==CHECK_CBUFF) {
+
+                send_buffer = strscpy(send_buffer,"S2\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                cache_buffers=strtoul(recv_buffer,NULL,10);
+
+                if(check_critical_value==TRUE && cache_buffers <= critical_value)
+                        result=STATE_CRITICAL;
+                else if(check_warning_value==TRUE && cache_buffers <= warning_value)
+                        result=STATE_WARNING;
+                output_message = ssprintf(output_message,"Total cache buffers = %lu",cache_buffers);
+
+        /* check dirty cache buffers */
+        } else if (vars_to_check==CHECK_CDBUFF) {
+
+                send_buffer = strscpy(send_buffer,"S3\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                cache_buffers=strtoul(recv_buffer,NULL,10);
+
+                if(check_critical_value==TRUE && cache_buffers >= critical_value)
+                        result=STATE_CRITICAL;
+                else if(check_warning_value==TRUE && cache_buffers >= warning_value)
+                        result=STATE_WARNING;
+                output_message = ssprintf(output_message,"Dirty cache buffers = %lu",cache_buffers);
+
+        /* check LRU sitting time in minutes */
+        } else if (vars_to_check==CHECK_LRUM) {
+
+                send_buffer = strscpy(send_buffer,"S5\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                lru_time=strtoul(recv_buffer,NULL,10);
+
+                if(check_critical_value==TRUE && lru_time <= critical_value)
+                        result=STATE_CRITICAL;
+                else if(check_warning_value==TRUE && lru_time <= warning_value)
+                        result=STATE_WARNING;
+                output_message = ssprintf(output_message,"LRU sitting time = %lu minutes",lru_time);
+
+
+        /* check KB free space on volume */
+        } else if (vars_to_check==CHECK_VKF) {
+
+                send_buffer = ssprintf(send_buffer,"VKF%s\r\n",volume_name);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+
+                if (!strcmp(recv_buffer,"-1\n")) {
+                        output_message = ssprintf(output_message,"Error: Volume '%s' does not exist!",volume_name);
+                        result=STATE_CRITICAL;
+                }       else {
+                        free_disk_space=strtoul(recv_buffer,NULL,10);
+                        if(check_critical_value==TRUE && free_disk_space <= critical_value)
+                                result=STATE_CRITICAL;
+                        else if(check_warning_value==TRUE && free_disk_space <= warning_value)
+                                result=STATE_WARNING;
+                        output_message = ssprintf(output_message,"%s%lu KB free on volume %s",(result==STATE_OK)?"":"Only ",free_disk_space,volume_name);
+                }
+
+        /* check % free space on volume */
+        } else if (vars_to_check==CHECK_VPF) {
+
+                send_buffer = ssprintf(send_buffer,"VKF%s\r\n",volume_name);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+
+                if(!strcmp(recv_buffer,"-1\n")){
+
+                        output_message = ssprintf(output_message,"Error: Volume '%s' does not exist!",volume_name);
+                        result=STATE_CRITICAL;
+
+                } else {
+
+                        free_disk_space=strtoul(recv_buffer,NULL,10);
+
+                        send_buffer = ssprintf(send_buffer,"VKS%s\r\n",volume_name);
+                        result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                        if(result!=STATE_OK)
+                                return result;
+                        total_disk_space=strtoul(recv_buffer,NULL,10);
+
+                        percent_free_space=(int)(((double)free_disk_space/(double)total_disk_space)*100.0);
+
+                        if(check_critical_value==TRUE && percent_free_space <= critical_value)
+                                result=STATE_CRITICAL;
+                        else if(check_warning_value==TRUE && percent_free_space <= warning_value)
+                                result=STATE_WARNING;
+                        free_disk_space/=1024;
+                        output_message = ssprintf(output_message,"%lu MB (%d%%) free on volume %s",free_disk_space,percent_free_space,volume_name);
+                }
+
+        /* check to see if DS Database is open or closed */
+        } else if(vars_to_check==CHECK_DSDB) {
+
+                send_buffer = strscpy(send_buffer,"S11\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                if(atoi(recv_buffer)==1)
+                        result=STATE_OK;
+                else
+                        result=STATE_WARNING;
+ 
+                send_buffer = strscpy(send_buffer,"S13\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                temp_buffer=strtok(recv_buffer,"\r\n");
+ 
+                output_message = ssprintf(output_message,"Directory Services Database is %s (DS version %s)",(result==STATE_OK)?"open":"closed",temp_buffer);
+
+        /* check to see if logins are enabled */
+        } else if (vars_to_check==CHECK_LOGINS) {
+
+                send_buffer = strscpy(send_buffer,"S12\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+                if(atoi(recv_buffer)==1)
+                        result=STATE_OK;
+                else
+                        result=STATE_WARNING;
+ 
+                output_message = ssprintf(output_message,"Logins are %s",(result==STATE_OK)?"enabled":"disabled");
+
+        /* check packet receive buffers */
+        } else if (vars_to_check==CHECK_UPRB || vars_to_check==CHECK_PUPRB) {
+ 
+                send_buffer = ssprintf(send_buffer,"S15\r\n",volume_name);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+
+                used_packet_receive_buffers=atoi(recv_buffer);
+
+                send_buffer = ssprintf(send_buffer,"S16\r\n",volume_name);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+
+                max_packet_receive_buffers=atoi(recv_buffer);
+ 
+                percent_used_packet_receive_buffers=(unsigned long)(((double)used_packet_receive_buffers/(double)max_packet_receive_buffers)*100.0);
+
+                if(vars_to_check==CHECK_UPRB){
+                        if(check_critical_value==TRUE && used_packet_receive_buffers >= critical_value)
+                                result=STATE_CRITICAL;
+                        else if(check_warning_value==TRUE && used_packet_receive_buffers >= warning_value)
+                                result=STATE_WARNING;
+                } else {
+                        if(check_critical_value==TRUE && percent_used_packet_receive_buffers >= critical_value)
+                                result=STATE_CRITICAL;
+                        else if(check_warning_value==TRUE && percent_used_packet_receive_buffers >= warning_value)
+                                result=STATE_WARNING;
+                }
+ 
+                output_message = ssprintf(output_message,"%d of %d (%lu%%) packet receive buffers used",used_packet_receive_buffers,max_packet_receive_buffers,percent_used_packet_receive_buffers);
+
+        /* check SAP table entries */
+        } else if (vars_to_check==CHECK_SAPENTRIES) {
+
+                if(sap_number==-1)
+                        send_buffer = ssprintf(send_buffer,"S9\r\n");
+                else
+                        send_buffer = ssprintf(send_buffer,"S9.%d\r\n",sap_number);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+ 
+                sap_entries=atoi(recv_buffer);
+ 
+                if(check_critical_value==TRUE && sap_entries >= critical_value)
+                        result=STATE_CRITICAL;
+                else if(check_warning_value==TRUE && sap_entries >= warning_value)
+                        result=STATE_WARNING;
+
+                if(sap_number==-1)
+                        output_message = ssprintf(output_message,"%d entries in SAP table",sap_entries);
+                else
+                        output_message = ssprintf(output_message,"%d entries in SAP table for SAP type %d",sap_entries,sap_number);
+
+        /* check KB purgeable space on volume */
+        } else if (vars_to_check==CHECK_VKP) {
+
+                send_buffer = ssprintf(send_buffer,"VKP%s\r\n",volume_name);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+
+                if (!strcmp(recv_buffer,"-1\n")) {
+                        output_message = ssprintf(output_message,"Error: Volume '%s' does not exist!",volume_name);
+                        result=STATE_CRITICAL;
+                } else {
+                        purgeable_disk_space=strtoul(recv_buffer,NULL,10);
+                        if(check_critical_value==TRUE && purgeable_disk_space >= critical_value)
+                                result=STATE_CRITICAL;
+                        else if(check_warning_value==TRUE && purgeable_disk_space >= warning_value)
+                                result=STATE_WARNING;
+                        output_message = ssprintf(output_message,"%s%lu KB purgeable on volume %s",(result==STATE_OK)?"":"Only ",purgeable_disk_space,volume_name);
+                }
+
+        /* check % purgeable space on volume */
+        } else if (vars_to_check==CHECK_VPP) {
+
+                send_buffer = ssprintf(send_buffer,"VKP%s\r\n",volume_name);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+
+                if(!strcmp(recv_buffer,"-1\n")){
+
+                        output_message = ssprintf(output_message,"Error: Volume '%s' does not exist!",volume_name);
+                        result=STATE_CRITICAL;
+
+                } else {
+
+                        purgeable_disk_space=strtoul(recv_buffer,NULL,10);
+
+                        send_buffer = ssprintf(send_buffer,"VKS%s\r\n",volume_name);
+                        result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                        if(result!=STATE_OK)
+                                return result;
+                        total_disk_space=strtoul(recv_buffer,NULL,10);
+
+                        percent_purgeable_space=(int)(((double)purgeable_disk_space/(double)total_disk_space)*100.0);
+
+                        if(check_critical_value==TRUE && percent_purgeable_space >= critical_value)
+                                result=STATE_CRITICAL;
+                        else if(check_warning_value==TRUE && percent_purgeable_space >= warning_value)
+                                result=STATE_WARNING;
+                        purgeable_disk_space/=1024;
+                        output_message = ssprintf(output_message,"%lu MB (%d%%) purgeable on volume %s",purgeable_disk_space,percent_purgeable_space,volume_name);
+                }
+
+        /* check KB not yet purgeable space on volume */
+        } else if (vars_to_check==CHECK_VKNP) {
+
+                send_buffer = ssprintf(send_buffer,"VKNP%s\r\n",volume_name);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+
+                if (!strcmp(recv_buffer,"-1\n")) {
+                        output_message = ssprintf(output_message,"Error: Volume '%s' does not exist!",volume_name);
+                        result=STATE_CRITICAL;
+                } else {
+                        non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
+                        if(check_critical_value==TRUE && non_purgeable_disk_space >= critical_value)
+                                result=STATE_CRITICAL;
+                        else if(check_warning_value==TRUE && non_purgeable_disk_space >= warning_value)
+                                result=STATE_WARNING;
+                        output_message = ssprintf(output_message,"%s%lu KB not yet purgeable on volume %s",(result==STATE_OK)?"":"Only ",non_purgeable_disk_space,volume_name);
+                }
+
+        /* check % not yet purgeable space on volume */
+        } else if (vars_to_check==CHECK_VPNP) {
+
+                send_buffer = ssprintf(send_buffer,"VKNP%s\r\n",volume_name);
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+
+                if(!strcmp(recv_buffer,"-1\n")){
+
+                        output_message = ssprintf(output_message,"Error: Volume '%s' does not exist!",volume_name);
+                        result=STATE_CRITICAL;
+
+                } else {
+
+                        non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);
+
+                        send_buffer = ssprintf(send_buffer,"VKS%s\r\n",volume_name);
+                        result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                        if(result!=STATE_OK)
+                                return result;
+                        total_disk_space=strtoul(recv_buffer,NULL,10);
+
+                        percent_non_purgeable_space=(int)(((double)non_purgeable_disk_space/(double)total_disk_space)*100.0);
+
+                        if(check_critical_value==TRUE && percent_non_purgeable_space >= critical_value)
+                                result=STATE_CRITICAL;
+                        else if(check_warning_value==TRUE && percent_non_purgeable_space >= warning_value)
+                                result=STATE_WARNING;
+                        purgeable_disk_space/=1024;
+                        output_message = ssprintf(output_message,"%lu MB (%d%%) not yet purgeable on volume %s",non_purgeable_disk_space,percent_non_purgeable_space,volume_name);
+                }
+
+        /* check # of open files */
+        } else if (vars_to_check==CHECK_OFILES) {
+
+                send_buffer = ssprintf(send_buffer,"S18\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+ 
+                open_files=atoi(recv_buffer);
+ 
+                if(check_critical_value==TRUE && open_files >= critical_value)
+                        result=STATE_CRITICAL;
+                else if(check_warning_value==TRUE && open_files >= warning_value)
+                        result=STATE_WARNING;
+
+                output_message = ssprintf(output_message,"%d open files",open_files);
+
+        /* check # of abended threads (Netware 5.x only) */
+        } else if (vars_to_check==CHECK_ABENDS) {
+
+                send_buffer = ssprintf(send_buffer,"S17\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+ 
+                abended_threads=atoi(recv_buffer);
+ 
+                if(check_critical_value==TRUE && abended_threads >= critical_value)
+                        result=STATE_CRITICAL;
+                else if(check_warning_value==TRUE && abended_threads >= warning_value)
+                        result=STATE_WARNING;
+
+                output_message = ssprintf(output_message,"%d abended threads",abended_threads);
+
+        /* check # of current service processes (Netware 5.x only) */
+        } else if (vars_to_check==CHECK_CSPROCS) {
+
+                send_buffer = ssprintf(send_buffer,"S20\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+ 
+                max_service_processes=atoi(recv_buffer);
+ 
+                send_buffer = ssprintf(send_buffer,"S21\r\n");
+                result=process_tcp_request(server_address,server_port,send_buffer,recv_buffer,sizeof(recv_buffer));
+                if(result!=STATE_OK)
+                        return result;
+ 
+                current_service_processes=atoi(recv_buffer);
+ 
+                if(check_critical_value==TRUE && current_service_processes >= critical_value)
+                        result=STATE_CRITICAL;
+                else if(check_warning_value==TRUE && current_service_processes >= warning_value)
+                        result=STATE_WARNING;
+
+                output_message = ssprintf(output_message,"%d current service processes (%d max)",current_service_processes,max_service_processes);
+
+        } else {
+
+                output_message = strscpy(output_message,"Nothing to check!\n");
+                result=STATE_UNKNOWN;
+
+        }
+
+        /* reset timeout */
+        alarm(0);
+
+        printf("%s%s\n",netware_version,output_message);
+
+        return result;
+}
+
+
+/* process command-line arguments */
+int process_arguments(int argc, char **argv){
+        int c;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] =
+        { 
+                {"port",     required_argument,0,'p'},
+                {"timeout",  required_argument,0,'t'},
+                {"critical", required_argument,0,'c'},
+                {"warning",  required_argument,0,'w'},
+                {"variable", required_argument,0,'v'},
+                {"hostname", required_argument,0,'H'},
+                {"osversion",no_argument,      0,'o'},
+                {"version",  no_argument,      0,'V'},
+                {"help",     no_argument,      0,'h'},
+                {0,0,0,0}
+        };
+#endif
+
+        /* no options were supplied */
+        if(argc<2) return ERROR;
+
+        /* backwards compatibility */
+        if (! is_option(argv[1])) {
+                server_address=argv[1];
+                argv[1]=argv[0];
+                argv=&argv[1];
+                argc--;
+        }
+
+  for (c=1;c<argc;c++) {
+    if(strcmp("-to",argv[c])==0)
+      strcpy(argv[c],"-t");
+    else if (strcmp("-wv",argv[c])==0)
+      strcpy(argv[c],"-w");
+    else if (strcmp("-cv",argv[c])==0)
+      strcpy(argv[c],"-c");
+        }
+
+        while (1){
+#ifdef HAVE_GETOPT_H
+                c = getopt_long(argc,argv,"+hoVH:t:c:w:p:v:",long_options,&option_index);
+#else
+                c = getopt(argc,argv,"+hoVH:t:c:w:p:v:");
+#endif
+
+                if (c==-1||c==EOF||c==1)
+                        break;
+
+                switch (c)
+                        {
+                        case '?': /* print short usage statement if args not parsable */
+                                printf("%s: Unknown argument: %s\n\n",my_basename(argv[0]),optarg);
+                                print_usage();
+                                exit(STATE_UNKNOWN);
+                        case 'h': /* help */
+                                print_help();
+                                exit(STATE_OK);
+                        case 'V': /* version */
+                                print_revision(my_basename(argv[0]),"$Revision$");
+                                exit(STATE_OK);
+                        case 'H': /* hostname */
+                                server_address=optarg;
+                                break;
+                        case 'o': /* display nos version */
+                                check_netware_version=TRUE;
+                                break;
+                        case 'p': /* port */
+                                if (is_intnonneg(optarg))
+                                        server_port=atoi(optarg);
+                                else
+                                        terminate(STATE_UNKNOWN,"Server port an integer (seconds)\nType '%s -h' for additional help\n",PROGNAME);
+                                break;
+                        case 'v':
+                                if(strlen(optarg)<3)
+                                        return ERROR;
+                                if(!strcmp(optarg,"LOAD1"))
+                                        vars_to_check=CHECK_LOAD1;
+                                else if(!strcmp(optarg,"LOAD5"))
+                                        vars_to_check=CHECK_LOAD5;
+                                else if(!strcmp(optarg,"LOAD15"))
+                                        vars_to_check=CHECK_LOAD15;
+                                else if(!strcmp(optarg,"CONNS"))
+                                        vars_to_check=CHECK_CONNS;
+                                else if(!strcmp(optarg,"LTCH"))
+                                        vars_to_check=CHECK_LTCH;
+                                else if(!strcmp(optarg,"CBUFF"))
+                                        vars_to_check=CHECK_CBUFF;
+                                else if(!strcmp(optarg,"CDBUFF"))
+                                        vars_to_check=CHECK_CDBUFF;
+                                else if(!strcmp(optarg,"LRUM"))
+                                        vars_to_check=CHECK_LRUM;
+                                else if(strncmp(optarg,"VPF",3)==0){
+                                        vars_to_check=CHECK_VPF;
+                                        volume_name = strscpy(volume_name,optarg+3);
+                                        if(!strcmp(volume_name,""))
+                                                volume_name = strscpy(volume_name,"SYS");
+                                }
+                                else if(strncmp(optarg,"VKF",3)==0){
+                                        vars_to_check=CHECK_VKF;
+                                        volume_name = strscpy(volume_name,optarg+3);
+                                        if(!strcmp(volume_name,""))
+                                                volume_name = strscpy(volume_name,"SYS");
+                                }
+                                else if(!strcmp(optarg,"DSDB"))
+                                        vars_to_check=CHECK_DSDB;
+                                else if(!strcmp(optarg,"LOGINS"))
+                                        vars_to_check=CHECK_LOGINS;
+                                else if(!strcmp(optarg,"UPRB"))
+                                        vars_to_check=CHECK_UPRB;
+                                else if(!strcmp(optarg,"PUPRB"))
+                                        vars_to_check=CHECK_PUPRB;
+                                else if(!strncmp(optarg,"SAPENTRIES",10)){
+                                        vars_to_check=CHECK_SAPENTRIES;
+                                        if(strlen(optarg)>10)
+                                                sap_number=atoi(optarg+10);
+                                        else
+                                                sap_number=-1;
+                                }
+                                else if(!strcmp(optarg,"OFILES"))
+                                        vars_to_check=CHECK_OFILES;
+                                else if(strncmp(optarg,"VKP",3)==0){
+                                        vars_to_check=CHECK_VKP;
+                                        volume_name = strscpy(volume_name,optarg+3);
+                                        if(!strcmp(volume_name,""))
+                                                volume_name = strscpy(volume_name,"SYS");
+                                }
+                                else if(strncmp(optarg,"VPP",3)==0){
+                                        vars_to_check=CHECK_VPP;
+                                        volume_name = strscpy(volume_name,optarg+3);
+                                        if(!strcmp(volume_name,""))
+                                                volume_name = strscpy(volume_name,"SYS");
+                                }
+                                else if(strncmp(optarg,"VKNP",4)==0){
+                                        vars_to_check=CHECK_VKNP;
+                                        volume_name = strscpy(volume_name,optarg+4);
+                                        if(!strcmp(volume_name,""))
+                                                volume_name = strscpy(volume_name,"SYS");
+                                }
+                                else if(strncmp(optarg,"VPNP",4)==0){
+                                        vars_to_check=CHECK_VPNP;
+                                        volume_name = strscpy(volume_name,optarg+4);
+                                        if(!strcmp(volume_name,""))
+                                                volume_name = strscpy(volume_name,"SYS");
+                                }
+                                else if(!strcmp(optarg,"ABENDS"))
+                                        vars_to_check=CHECK_ABENDS;
+                                else if(!strcmp(optarg,"CSPROCS"))
+                                        vars_to_check=CHECK_CSPROCS;
+                                else
+                                        return ERROR;
+                                break;
+                        case 'w': /* warning threshold */
+                                warning_value=strtoul(optarg,NULL,10);
+                                check_warning_value=TRUE;
+                                break;
+                        case 'c': /* critical threshold */
+                                critical_value=strtoul(optarg,NULL,10);
+                                check_critical_value=TRUE;
+                                break;
+                        case 't': /* timeout */
+                                socket_timeout=atoi(optarg);
+                                if(socket_timeout<=0)
+                                        return ERROR;
+                        }
+
+        }
+
+        return OK;
+}
+
+
+void print_usage(void)
+{
+        printf
+                ("Usage:\n"
+                 " %s %s\n"
+#ifdef HAVE_GETOPT_H
+                 " %s (-h | --help) for detailed help\n"
+                 " %s (-V | --version) for version information\n",
+#else
+                 " %s -h for detailed help\n"
+                 " %s -V for version information\n",
+#endif
+                 PROGNAME, OPTIONS, PROGNAME, PROGNAME);
+}
+
+void print_help(void)
+{
+        print_revision (PROGNAME, REVISION);
+        printf ("%s\n\n%s\n", COPYRIGHT, SUMMARY);
+        print_usage();
+        printf
+                ("\nOptions:\n" LONGOPTIONS "\n" DESCRIPTION "\n",
+                 PORT, DEFAULT_SOCKET_TIMEOUT);
+        support ();
+}
diff --git a/plugins/check_overcr.c b/plugins/check_overcr.c
new file mode 100644
index 00000000..305a8242
--- /dev/null
+++ b/plugins/check_overcr.c
@@ -0,0 +1,489 @@
+/******************************************************************************
+*
+* CHECK_OVERCR.C
+*
+* Program: Over-CR collector plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+*
+* $Id$
+*
+* Description:
+*
+* Notes:
+* - This plugin requires that Eric Molitors' Over-CR collector daemon
+*        be running on any UNIX boxes you want to monitor.  Over-CR
+*        is available from * http://www.molitor.org/overcr/
+*
+* Modifications:
+*
+* 08-11-999 Jacob Lundqvist <jaclu@grm.se>
+* Load was presented as a one digit percentage - changed to two digit
+*       value * before load of 11.2 was presented as "1.2%" (not very
+*       high). Warning and Critical params were int's, not very good
+*       for load, changed to doubles, so we can trap loadlimits like
+*       1.5.  Also added more informative LOAD error messages.
+* 
+* 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 "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define CHECK_NONE      0
+#define CHECK_LOAD1     1
+#define CHECK_LOAD5     2
+#define CHECK_LOAD15    4
+#define CHECK_DPU       8
+#define CHECK_PROCS     16
+#define CHECK_NETSTAT   32
+#define CHECK_UPTIME    64
+
+#define PORT    2000
+
+#define PROGNAME "check_overcr"
+
+char *server_address = NULL;
+int server_port = PORT;
+double warning_value = 0L;
+double critical_value = 0L;
+int check_warning_value = FALSE;
+int check_critical_value = FALSE;
+int vars_to_check = CHECK_NONE;
+int cmd_timeout = 1;
+
+int netstat_port = 0;
+char *disk_name = NULL;
+char *process_name = NULL;
+
+int process_arguments (int, char **);
+void print_usage (void);
+void print_help (void);
+
+int
+main (int argc, char **argv)
+{
+        int result;
+        char send_buffer[MAX_INPUT_BUFFER];
+        char recv_buffer[MAX_INPUT_BUFFER];
+        char output_message[MAX_INPUT_BUFFER];
+        char temp_buffer[MAX_INPUT_BUFFER];
+        char *temp_ptr = NULL;
+        int found_disk = FALSE;
+        unsigned long percent_used_disk_space = 100;
+        double load;
+        double load_1min;
+        double load_5min;
+        double load_15min;
+        int port_connections = 0;
+        int processes = 0;
+        double uptime_raw_hours;
+        int uptime_raw_minutes = 0;
+        int uptime_days = 0;
+        int uptime_hours = 0;
+        int uptime_minutes = 0;
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+
+        result = STATE_OK;
+
+        if (vars_to_check == CHECK_LOAD1 || vars_to_check == CHECK_LOAD5
+                        || vars_to_check == CHECK_LOAD15) {
+
+                strcpy (send_buffer, "LOAD\r\nQUIT\r\n");
+                result =
+                        process_tcp_request2 (server_address, server_port, send_buffer,
+                                                                                                                recv_buffer, sizeof (recv_buffer));
+                if (result != STATE_OK)
+                        return result;
+
+                temp_ptr = (char *) strtok (recv_buffer, "\r\n");
+                if (temp_ptr == NULL) {
+                        printf ("Invalid response from server - no load information\n");
+                        return STATE_CRITICAL;
+                }
+                load_1min = strtod (temp_ptr, NULL);
+                temp_ptr = (char *) strtok (NULL, "\r\n");
+                if (temp_ptr == NULL) {
+                        printf ("Invalid response from server after load 1\n");
+                        return STATE_CRITICAL;
+                }
+                load_5min = strtod (temp_ptr, NULL);
+                temp_ptr = (char *) strtok (NULL, "\r\n");
+                if (temp_ptr == NULL) {
+                        printf ("Invalid response from server after load 5\n");
+                        return STATE_CRITICAL;
+                }
+                load_15min = strtod (temp_ptr, NULL);
+
+
+                switch (vars_to_check) {
+                case CHECK_LOAD1:
+                        strcpy (temp_buffer, "1");
+                        load = load_1min;
+                        break;
+                case CHECK_LOAD5:
+                        strcpy (temp_buffer, "5");
+                        load = load_5min;
+                        break;
+                default:
+                        strcpy (temp_buffer, "15");
+                        load = load_15min;
+                        break;
+                }
+
+                if (check_critical_value == TRUE && (load >= critical_value))
+                        result = STATE_CRITICAL;
+                else if (check_warning_value == TRUE && (load >= warning_value))
+                        result = STATE_WARNING;
+                sprintf (output_message, "Load %s - %s-min load average = %0.2f",
+                                                 (result == STATE_OK) ? "ok" : "problem", temp_buffer, load);
+        }
+
+
+        else if (vars_to_check == CHECK_DPU) {
+
+                sprintf (send_buffer, "DISKSPACE\r\n");
+                result =
+                        process_tcp_request2 (server_address, server_port, send_buffer,
+                                                                                                                recv_buffer, sizeof (recv_buffer));
+                if (result != STATE_OK)
+                        return result;
+
+                for (temp_ptr = (char *) strtok (recv_buffer, " "); temp_ptr != NULL;
+                                 temp_ptr = (char *) strtok (NULL, " ")) {
+
+                        if (!strcmp (temp_ptr, disk_name)) {
+                                found_disk = TRUE;
+                                temp_ptr = (char *) strtok (NULL, "%");
+                                if (temp_ptr == NULL) {
+                                        printf ("Invalid response from server\n");
+                                        return STATE_CRITICAL;
+                                }
+                                percent_used_disk_space = strtoul (temp_ptr, NULL, 10);
+                                break;
+                        }
+
+                        temp_ptr = (char *) strtok (NULL, "\r\n");
+                }
+
+                /* error if we couldn't find the info for the disk */
+                if (found_disk == FALSE) {
+                        sprintf (output_message, "Error: Disk '%s' non-existent or not mounted",
+                                                         disk_name);
+                        result = STATE_CRITICAL;
+                }
+
+                /* else check the disk space used */
+                else {
+
+                        if (check_critical_value == TRUE
+                                        && (percent_used_disk_space >= critical_value)) result =
+                                        STATE_CRITICAL;
+                        else if (check_warning_value == TRUE
+                                                         && (percent_used_disk_space >= warning_value)) result =
+                                        STATE_WARNING;
+
+                        sprintf (output_message, "Disk %s - %lu%% used on %s",
+                                                         (result == STATE_OK) ? "ok" : "problem",
+                                                         percent_used_disk_space, disk_name);
+                }
+        }
+
+        else if (vars_to_check == CHECK_NETSTAT) {
+
+                sprintf (send_buffer, "NETSTAT %d\r\n", netstat_port);
+                result =
+                        process_tcp_request2 (server_address, server_port, send_buffer,
+                                                                                                                recv_buffer, sizeof (recv_buffer));
+                if (result != STATE_OK)
+                        return result;
+
+                port_connections = strtod (recv_buffer, NULL);
+
+                if (check_critical_value == TRUE && (port_connections >= critical_value))
+                        result = STATE_CRITICAL;
+                else if (check_warning_value == TRUE
+                                                 && (port_connections >= warning_value)) result = STATE_WARNING;
+
+                sprintf (output_message, "Net %s - %d connection%s on port %d",
+                                                 (result == STATE_OK) ? "ok" : "problem", port_connections,
+                                                 (port_connections == 1) ? "" : "s", netstat_port);
+        }
+
+        else if (vars_to_check == CHECK_PROCS) {
+
+                sprintf (send_buffer, "PROCESS %s\r\n", process_name);
+                result =
+                        process_tcp_request2 (server_address, server_port, send_buffer,
+                                                                                                                recv_buffer, sizeof (recv_buffer));
+                if (result != STATE_OK)
+                        return result;
+
+                temp_ptr = (char *) strtok (recv_buffer, "(");
+                if (temp_ptr == NULL) {
+                        printf ("Invalid response from server\n");
+                        return STATE_CRITICAL;
+                }
+                temp_ptr = (char *) strtok (NULL, ")");
+                if (temp_ptr == NULL) {
+                        printf ("Invalid response from server\n");
+                        return STATE_CRITICAL;
+                }
+                processes = strtod (temp_ptr, NULL);
+
+                if (check_critical_value == TRUE && (processes >= critical_value))
+                        result = STATE_CRITICAL;
+                else if (check_warning_value == TRUE && (processes >= warning_value))
+                        result = STATE_WARNING;
+
+                sprintf (output_message, "Process %s - %d instance%s of %s running",
+                                                 (result == STATE_OK) ? "ok" : "problem", processes,
+                                                 (processes == 1) ? "" : "s", process_name);
+        }
+
+        else if (vars_to_check == CHECK_UPTIME) {
+
+                sprintf (send_buffer, "UPTIME\r\n");
+                result =
+                        process_tcp_request2 (server_address, server_port, send_buffer,
+                                                                                                                recv_buffer, sizeof (recv_buffer));
+                if (result != STATE_OK)
+                        return result;
+
+                uptime_raw_hours = strtod (recv_buffer, NULL);
+                uptime_raw_minutes = (unsigned long) (uptime_raw_hours * 60.0);
+
+                if (check_critical_value == TRUE
+                                && (uptime_raw_minutes <= critical_value)) result = STATE_CRITICAL;
+                else if (check_warning_value == TRUE
+                                                 && (uptime_raw_minutes <= warning_value)) result = STATE_WARNING;
+
+                uptime_days = uptime_raw_minutes / 1440;
+                uptime_raw_minutes %= 1440;
+                uptime_hours = uptime_raw_minutes / 60;
+                uptime_raw_minutes %= 60;
+                uptime_minutes = uptime_raw_minutes;
+
+                sprintf (output_message, "Uptime %s - Up %d days %d hours %d minutes",
+                                                 (result == STATE_OK) ? "ok" : "problem", uptime_days,
+                                                 uptime_hours, uptime_minutes);
+        }
+
+        else {
+                strcpy (output_message, "Nothing to check!\n");
+                result = STATE_UNKNOWN;
+        }
+
+        /* reset timeout */
+        alarm (0);
+
+        printf ("%s\n", output_message);
+
+        return result;
+}
+
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"port", required_argument, 0, 'p'},
+                {"timeout", required_argument, 0, 't'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"variable", required_argument, 0, 'v'},
+                {"hostname", required_argument, 0, 'H'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        /* no options were supplied */
+        if (argc < 2)
+                return ERROR;
+
+        /* backwards compatibility */
+        if (!is_option (argv[1])) {
+                server_address = argv[1];
+                argv[1] = argv[0];
+                argv = &argv[1];
+                argc--;
+        }
+
+        for (c = 1; c < argc; c++) {
+                if (strcmp ("-to", argv[c]) == 0)
+                        strcpy (argv[c], "-t");
+                else if (strcmp ("-wv", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-cv", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVH:t:c:w:p:v:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+hVH:t:c:w:p:v:");
+#endif
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case '?':                                                                       /* print short usage statement if args not parsable */
+                        printf ("%s: Unknown argument: %s\n\n", my_basename (argv[0]), optarg);
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'H':                                                                       /* hostname */
+                        server_address = optarg;
+                        break;
+                case 'p':                                                                       /* port */
+                        if (is_intnonneg (optarg))
+                                server_port = atoi (optarg);
+                        else
+                                terminate (STATE_UNKNOWN,
+                                                                         "Server port an integer (seconds)\nType '%s -h' for additional help\n",
+                                                                         PROGNAME);
+                        break;
+                case 'v':                                                                       /* variable */
+                        if (strcmp (optarg, "LOAD1") == 0)
+                                vars_to_check = CHECK_LOAD1;
+                        else if (strcmp (optarg, "LOAD5") == 0)
+                                vars_to_check = CHECK_LOAD5;
+                        else if (strcmp (optarg, "LOAD15") == 0)
+                                vars_to_check = CHECK_LOAD15;
+                        else if (strcmp (optarg, "UPTIME") == 0)
+                                vars_to_check = CHECK_UPTIME;
+                        else if (strstr (optarg, "PROC") == optarg) {
+                                vars_to_check = CHECK_PROCS;
+                                process_name = strscpy (process_name, optarg + 4);
+                        }
+                        else if (strstr (optarg, "NET") == optarg) {
+                                vars_to_check = CHECK_NETSTAT;
+                                netstat_port = atoi (optarg + 3);
+                        }
+                        else if (strstr (optarg, "DPU") == optarg) {
+                                vars_to_check = CHECK_DPU;
+                                disk_name = strscpy (disk_name, optarg + 3);
+                        }
+                        else
+                                return ERROR;
+                        break;
+                case 'w':                                                                       /* warning threshold */
+                        warning_value = strtoul (optarg, NULL, 10);
+                        check_warning_value = TRUE;
+                        break;
+                case 'c':                                                                       /* critical threshold */
+                        critical_value = strtoul (optarg, NULL, 10);
+                        check_critical_value = TRUE;
+                        break;
+                case 't':                                                                       /* timeout */
+                        socket_timeout = atoi (optarg);
+                        if (socket_timeout <= 0)
+                                return ERROR;
+                }
+
+        }
+        return OK;
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H host [-p port] [-v variable] [-w warning] [-c critical] [-t timeout]\n",
+                 PROGNAME);
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Ethan Galstad/Karl DeBisschop\n\n"
+                 "This plugin attempts to contact the Over-CR collector daemon running on the\n"
+                 "remote UNIX server in order to gather the requested system information. This\n"
+                 "plugin requres that Eric Molitors' Over-CR collector daemon be running on the\n"
+                 "remote server. Over-CR can be downloaded from http://www.molitor.org/overcr\n"
+                 "(This plugin was tested with version 0.99.53 of the Over-CR collector)\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 "-H, --hostname=HOST\n"
+                 "   Name of the host to check\n"
+                 "-p, --port=INTEGER\n"
+                 "   Optional port number (default: %d)\n"
+                 "-v, --variable=STRING\n"
+                 "   Variable to check.  Valid variables include:\n"
+                 "     LOAD1         = 1 minute average CPU load\n"
+                 "     LOAD5         = 5 minute average CPU load\n"
+                 "     LOAD15        = 15 minute average CPU load\n"
+                 "     DPU<filesys>  = percent used disk space on filesystem <filesys>\n"
+                 "     PROC<process> = number of running processes with name <process>\n"
+                 "     NET<port>     = number of active connections on TCP port <port>\n"
+                 "     UPTIME        = system uptime in seconds\n"
+                 " -w, --warning=INTEGER\n"
+                 "   Threshold which will result in a warning status\n"
+                 " -c, --critical=INTEGER\n"
+                 "   Threshold which will result in a critical status\n"
+                 " -t, --timeout=INTEGER\n"
+                 "   Seconds before connection attempt times out (default: %d)\n"
+                 "-h, --help\n"
+                 "   Print this help screen\n"
+                 "-V, --version\n"
+                 "   Print version information\n\n"
+                 "Notes:\n"
+                 " - For the available options, the critical threshold value should always be\n"
+                 "   higher than the warning threshold value, EXCEPT with the uptime variable\n"
+                 "   (i.e. lower uptimes are worse).\n", PORT, DEFAULT_SOCKET_TIMEOUT);
+}
diff --git a/plugins/check_pgsql.c b/plugins/check_pgsql.c
new file mode 100644
index 00000000..03614ab1
--- /dev/null
+++ b/plugins/check_pgsql.c
@@ -0,0 +1,440 @@
+/******************************************************************************
+ *
+ * Program: PostgreSQL plugin for Nagios
+ * License: GPL
+ *
+ * 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.
+ *
+ * $Id$
+ *
+ *****************************************************************************/
+
+#define PROGNAME "check_pgsql"
+#define REVISION "$Revision$"
+#define COPYRIGHT "1999-2001"
+#define AUTHOR "Karl DeBisschop"
+#define EMAIL "kdebisschop@users.sourceforge.net"
+#define SUMMARY "Tests to see if a PostgreSQL DBMS is accepting connections.\n"
+
+#define OPTIONS "\
+\[-c critical_time] [-w warning_time] [-t timeout] [-H host]\n\
+             [-P port] [-d database] [-l logname] [-p password]"
+
+#define LONGOPTIONS "\
+  -c, --critical=INTEGER\n\
+    Exit STATE_CRITICAL if connection time exceeds threshold (default: %d)\n\
+  -w, --warning=INTEGER\n\
+    Exit STATE_WARNING if connection time exceeds threshold (default: %d)\n\
+  -t, --timeout=INTEGER\n\
+    Terminate test if timeout limit is exceeded (default: %d)\n\
+  -H, --hostname=STRING\n\
+    Name or numeric IP address of machine running backend\n\
+  -P, --port=INTEGER\n\
+    Port running backend (default: %s)\n\
+  -d, --database=STRING\n\
+    Database to check (default: %s)\n\
+  -l, --logname = STRING\n\
+    Login name of user\n\
+  -p, --password = STRING\n\
+    Password (BIG SECURITY ISSUE)\n"
+
+#define DESCRIPTION "All parameters are optional.\n\
+\n\
+This plugin tests a PostgreSQL DBMS to determine whether it is active and\n\
+accepting queries. In its current operation, it simply connects to the\n\
+specified database, and then disconnects. If no database is specified, it\n\
+connects to the template1 database, which is present in every functioning \n\
+PostgreSQL DBMS.\n\
+\n\
+The plugin will connect to a local postmaster if no host is specified. To\n\
+connect to a remote host, be sure that the remote postmaster accepts TCP/IP\n\
+connections (start the postmaster with the -i option).\n\
+\n\
+Typically, the nagios user (unless the --logname option is used) should be\n\
+able to connect to the database without a password. The plugin can also send\n\
+a password, but no effort is made to obsure or encrypt the password.\n"
+
+#define DEFAULT_DB "template1"
+#define DEFAULT_HOST "127.0.0.1"
+#define DEFAULT_PORT "5432"
+#define DEFAULT_WARN 2
+#define DEFAULT_CRIT 8
+#define DEFAULT_TIMEOUT 30
+
+#include "config.h"
+#include "common.h"
+#include "utils.h"
+#include <netdb.h>
+#include <libpq-fe.h>
+
+int process_arguments (int, char **);
+int validate_arguments (void);
+void print_usage (void);
+void print_help (void);
+int is_pg_dbname (char *);
+int is_pg_logname (char *);
+
+char *pghost = NULL;                                            /* host name of the backend server */
+char *pgport = NULL;                                            /* port of the backend server */
+char default_port[4] = DEFAULT_PORT;
+char *pgoptions = NULL;
+char *pgtty = NULL;
+char dbName[NAMEDATALEN] = DEFAULT_DB;
+char *pguser = NULL;
+char *pgpasswd = NULL;
+int twarn = DEFAULT_WARN;
+int tcrit = DEFAULT_CRIT;
+
+PGconn *conn;
+/*PGresult   *res;*/
+
+
+/******************************************************************************
+
+The (psuedo?)literate programming XML is contained within \@\@\- <XML> \-\@\@
+tags in the comments. With in the tags, the XML is assembled sequentially.
+You can define entities in tags. You also have all the #defines available as
+entities.
+
+Please note that all tags must be lowercase to use the DocBook XML DTD.
+
+@@-<article>
+
+<sect1>
+<title>Quick Reference</title>
+<!-- The refentry forms a manpage -->
+<refentry>
+<refmeta>
+<manvolnum>5<manvolnum>
+</refmeta>
+<refnamdiv>
+<refname>&PROGNAME;</refname>
+<refpurpose>&SUMMARY;</refpurpose>
+</refnamdiv>
+</refentry>
+</sect1>
+
+<sect1>
+<title>FAQ</title>
+</sect1>
+
+<sect1>
+<title>Theory, Installation, and Operation</title>
+
+<sect2>
+<title>General Description</title>
+<para>
+&DESCRIPTION;
+</para>
+</sect2>
+
+<sect2>
+<title>Future Enhancements</title>
+<para>ToDo List</para>
+<itemizedlist>
+<listitem>Add option to get password from a secured file rather than the command line</listitem>
+<listitem>Add option to specify the query to execute</listitem>
+</itemizedlist>
+</sect2>
+
+
+<sect2>
+<title>Functions</title>
+-@@
+******************************************************************************/
+
+int
+main (int argc, char **argv)
+{
+        int elapsed_time;
+
+        /* begin, by setting the parameters for a backend connection if the
+         * parameters are null, then the system will try to use reasonable
+         * defaults by looking up environment variables or, failing that,
+         * using hardwired constants */
+
+        pgoptions = NULL;  /* special options to start up the backend server */
+        pgtty = NULL;      /* debugging tty for the backend server */
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments");
+
+        /* Set signal handling and alarm */
+        if (signal (SIGALRM, timeout_alarm_handler) == SIG_ERR) {
+                printf ("Cannot catch SIGALRM");
+                return STATE_UNKNOWN;
+        }
+        alarm (timeout_interval);
+
+        /* make a connection to the database */
+        time (&start_time);
+        conn =
+                PQsetdbLogin (pghost, pgport, pgoptions, pgtty, dbName, pguser, pgpasswd);
+        time (&end_time);
+        elapsed_time = (int) (end_time - start_time);
+
+        /* check to see that the backend connection was successfully made */
+        if (PQstatus (conn) == CONNECTION_BAD) {
+                printf ("PGSQL: CRITICAL - no connection to '%s' (%s).\n", dbName,
+                                                PQerrorMessage (conn));
+                PQfinish (conn);
+                return STATE_CRITICAL;
+        }
+        else if (elapsed_time > tcrit) {
+                PQfinish (conn);
+                printf ("PGSQL: CRITICAL - database %s (%d sec.)\n", dbName,
+                                                elapsed_time);
+                return STATE_CRITICAL;
+        }
+        else if (elapsed_time > twarn) {
+                PQfinish (conn);
+                printf ("PGSQL: WARNING - database %s (%d sec.)\n", dbName, elapsed_time);
+                return STATE_WARNING;
+        }
+        else {
+                PQfinish (conn);
+                printf ("PGSQL: ok - database %s (%d sec.)\n", dbName, elapsed_time);
+                return STATE_OK;
+        }
+}
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, REVISION);
+        printf
+                ("Copyright (c) %s %s <%s>\n\n%s\n",
+                 COPYRIGHT, AUTHOR, EMAIL, SUMMARY);
+        print_usage ();
+        printf
+                ("\nOptions:\n" LONGOPTIONS "\n" DESCRIPTION "\n", 
+                 DEFAULT_WARN, DEFAULT_CRIT, DEFAULT_TIMEOUT, DEFAULT_PORT, DEFAULT_DB);
+        support ();
+}
+
+void
+print_usage (void)
+{
+        printf ("Usage:\n" " %s %s\n"
+#ifdef HAVE_GETOPT_H
+                                        " %s (-h | --help) for detailed help\n"
+                                        " %s (-V | --version) for version information\n",
+#else
+                                        " %s -h for detailed help\n"
+                                        " %s -V for version information\n",
+#endif
+                                        PROGNAME, OPTIONS, PROGNAME, PROGNAME);
+}
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"help", no_argument, 0, 'h'},
+                {"version", no_argument, 0, 'V'},
+                {"timeout", required_argument, 0, 't'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"hostname", required_argument, 0, 'H'},
+                {"logname", required_argument, 0, 'l'},
+                {"password", required_argument, 0, 'p'},
+                {"authorization", required_argument, 0, 'a'},
+                {"port", required_argument, 0, 'P'},
+                {"database", required_argument, 0, 'd'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c = getopt_long (argc, argv, "+?hVt:c:w:H:P:d:l:p:a:",
+                                 long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+?hVt:c:w:H:P:d:l:p:a:");
+#endif
+                if (c == EOF)
+                        break;
+
+                switch (c) {
+                case '?':     /* help */
+                        usage2 ("Unknown argument", optarg);
+                case 'h':     /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':     /* version */
+                        print_revision (PROGNAME, REVISION);
+                        exit (STATE_OK);
+                case 't':     /* timeout period */
+                        if (!is_integer (optarg))
+                                usage2 ("Timeout Interval must be an integer", optarg);
+                        timeout_interval = atoi (optarg);
+                        break;
+                case 'c':     /* critical time threshold */
+                        if (!is_integer (optarg))
+                                usage2 ("Invalid critical threshold", optarg);
+                        tcrit = atoi (optarg);
+                        break;
+                case 'w':     /* warning time threshold */
+                        if (!is_integer (optarg))
+                                usage2 ("Invalid critical threshold", optarg);
+                        twarn = atoi (optarg);
+                        break;
+                case 'H':     /* host */
+                        if (!is_host (optarg))
+                                usage2 ("You gave an invalid host name", optarg);
+                        pghost = optarg;
+                        break;
+                case 'P':     /* port */
+                        if (!is_integer (optarg))
+                                usage2 ("Port must be an integer", optarg);
+                        pgport = optarg;
+                        break;
+                case 'd':     /* database name */
+                        if (!is_pg_dbname (optarg))
+                                usage2 ("Database name is not valid", optarg);
+                        strncpy (dbName, optarg, NAMEDATALEN - 1);
+                        dbName[NAMEDATALEN - 1] = 0;
+                        break;
+                case 'l':     /* login name */
+                        if (!is_pg_logname (optarg))
+                                usage2 ("user name is not valid", optarg);
+                        pguser = optarg;
+                        break;
+                case 'p':     /* authentication password */
+                case 'a':
+                        pgpasswd = optarg;
+                        break;
+                }
+        }
+
+        return validate_arguments ();
+}
+
+
+/******************************************************************************
+
+@@-
+<sect3>
+<title>validate_arguments</title>
+
+<para>&PROTO_validate_arguments;</para>
+
+<para>Given a database name, this function returns TRUE if the string
+is a valid PostgreSQL database name, and returns false if it is
+not.</para>
+
+<para>Valid PostgreSQL database names are less than &NAMEDATALEN;
+characters long and consist of letters, numbers, and underscores. The
+first character cannot be a number, however.</para>
+
+</sect3>
+-@@
+******************************************************************************/
+
+int
+validate_arguments ()
+{
+        return OK;
+}
+
+
+
+/******************************************************************************
+
+@@-
+<sect3>
+<title>is_pg_dbname</title>
+
+<para>&PROTO_is_pg_dbname;</para>
+
+<para>Given a database name, this function returns TRUE if the string
+is a valid PostgreSQL database name, and returns false if it is
+not.</para>
+
+<para>Valid PostgreSQL database names are less than &NAMEDATALEN;
+characters long and consist of letters, numbers, and underscores. The
+first character cannot be a number, however.</para>
+
+</sect3>
+-@@
+******************************************************************************/
+
+int
+is_pg_dbname (char *dbname)
+{
+        char txt[NAMEDATALEN];
+        char tmp[NAMEDATALEN];
+        if (strlen (dbname) > NAMEDATALEN - 1)
+                return (FALSE);
+        strncpy (txt, dbname, NAMEDATALEN - 1);
+        txt[NAMEDATALEN - 1] = 0;
+        if (sscanf (txt, "%[_a-zA-Z]%[^_a-zA-Z0-9]", tmp, tmp) == 1)
+                return (TRUE);
+        if (sscanf (txt, "%[_a-zA-Z]%[_a-zA-Z0-9]%[^_a-zA-Z0-9]", tmp, tmp, tmp) ==
+                        2) return (TRUE);
+        return (FALSE);
+}
+
+/**
+
+the tango program should eventually create an entity here based on the 
+function prototype
+
+@@-
+<sect3>
+<title>is_pg_logname</title>
+
+<para>&PROTO_is_pg_logname;</para>
+
+<para>Given a username, this function returns TRUE if the string is a
+valid PostgreSQL username, and returns false if it is not. Valid PostgreSQL
+usernames are less than &NAMEDATALEN; characters long and consist of
+letters, numbers, dashes, and underscores, plus possibly some other
+characters.</para>
+
+<para>Currently this function only checks string length. Additional checks
+should be added.</para>
+
+</sect3>
+-@@
+******************************************************************************/
+
+int
+is_pg_logname (char *username)
+{
+        if (strlen (username) > NAMEDATALEN - 1)
+                return (FALSE);
+        return (TRUE);
+}
+
+/******************************************************************************
+@@-
+</sect2> 
+</sect1>
+</article>
+-@@
+******************************************************************************/
diff --git a/plugins/check_ping.c b/plugins/check_ping.c
new file mode 100644
index 00000000..b61b41b5
--- /dev/null
+++ b/plugins/check_ping.c
@@ -0,0 +1,492 @@
+/*****************************************************************************
+*
+* CHECK_PING.C
+*
+* Program: Ping plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+*
+* $Id$
+*
+*****************************************************************************/
+
+#define PROGNAME "check_pgsql"
+#define REVISION "$Revision$"
+#define COPYRIGHT "1999-2001"
+#define AUTHOR "Ethan Galstad/Karl DeBisschop"
+#define EMAIL "kdebisschop@users.sourceforge.net"
+#define SUMMARY "Use ping to check connection statistics for a remote host.\n"
+
+#define OPTIONS "\
+-H <host_address> -w <wrta>,<wpl>%% -c <crta>,<cpl>%%\n\
+       [-p packets] [-t timeout] [-L]\n"
+
+#define LONGOPTIONS "\
+-H, --hostname=HOST\n\
+   host to ping\n\
+-w, --warning=THRESHOLD\n\
+   warning threshold pair\n\
+-c, --critical=THRESHOLD\n\
+   critical threshold pair\n\
+-p, --packets=INTEGER\n\
+   number of ICMP ECHO packets to send (Default: %d)\n\
+-t, --timeout=INTEGER\n\
+   optional specified timeout in second (Default: %d)\n\
+-L, --link\n\
+   show HTML in the plugin output (obsoleted by urlize)\n\
+THRESHOLD is <rta>,<pl>%% where <rta> is the round trip average travel\n\
+time (ms) which triggers a WARNING or CRITICAL state, and <pl> is the\n\
+percentage of packet loss to trigger an alarm state.\n"
+
+#define DESCRIPTION "\
+This plugin uses the ping command to probe the specified host for packet loss\n\
+(percentage) and round trip average (milliseconds). It can produce HTML output\n\
+linking to a traceroute CGI contributed by Ian Cass. The CGI can be found in\n\
+the contrib area of the downloads section at http://www.nagios.org\n\n"
+
+#include "config.h"
+#include "common.h"
+#include "popen.h"
+#include "utils.h"
+
+#define UNKNOWN_PACKET_LOSS 200 /* 200% */
+#define UNKNOWN_TRIP_TIME -1.0  /* -1 seconds */
+#define DEFAULT_MAX_PACKETS 5           /* default no. of ICMP ECHO packets */
+
+#define WARN_DUPLICATES "DUPLICATES FOUND! "
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int get_threshold (char *, float *, int *);
+int validate_arguments (void);
+int run_ping (char *);
+void print_usage (void);
+void print_help (void);
+
+int display_html = FALSE;
+int wpl = UNKNOWN_PACKET_LOSS;
+int cpl = UNKNOWN_PACKET_LOSS;
+float wrta = UNKNOWN_TRIP_TIME;
+float crta = UNKNOWN_TRIP_TIME;
+char *server_address = NULL;
+int max_packets = -1;
+int verbose = FALSE;
+
+float rta = UNKNOWN_TRIP_TIME;
+int pl = UNKNOWN_PACKET_LOSS;
+
+char *warn_text = NULL;
+
+int
+main (int argc, char **argv)
+{
+        char *command_line = NULL;
+        int result = STATE_UNKNOWN;
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments");
+
+        /* does the host address of number of packets argument come first? */
+#ifdef PING_PACKETS_FIRST
+        command_line =
+                ssprintf (command_line, PING_COMMAND, max_packets, server_address);
+#else
+        command_line =
+                ssprintf (command_line, PING_COMMAND, server_address, max_packets);
+#endif
+
+        /* Set signal handling and alarm */
+        if (signal (SIGALRM, popen_timeout_alarm_handler) == SIG_ERR) {
+                printf ("Cannot catch SIGALRM");
+                return STATE_UNKNOWN;
+        }
+
+        /* handle timeouts gracefully */
+        alarm (timeout_interval);
+
+        if (verbose)
+                printf ("%s ==> ", command_line);
+
+        /* run the command */
+        run_ping (command_line);
+
+        if (pl == UNKNOWN_PACKET_LOSS || rta == UNKNOWN_TRIP_TIME) {
+                printf ("%s\n", command_line);
+                terminate (STATE_UNKNOWN,
+                                                         "Error: Could not interpret output from ping command\n");
+        }
+
+        if (pl >= cpl || rta >= crta || rta < 0)
+                result = STATE_CRITICAL;
+        else if (pl >= wpl || rta >= wrta)
+                result = STATE_WARNING;
+        else if (pl < wpl && rta < wrta && pl >= 0 && rta >= 0)
+                result = max (result, STATE_OK);
+
+        if (display_html == TRUE)
+                printf ("<A HREF='%s/traceroute.cgi?%s'>", CGIURL, server_address);
+        if (pl == 100)
+                printf ("PING %s - %sPacket loss = %d%%", state_text (result), warn_text,
+                                                pl);
+        else
+                printf ("PING %s - %sPacket loss = %d%%, RTA = %2.2f ms",
+                                                state_text (result), warn_text, pl, rta);
+        if (display_html == TRUE)
+                printf ("</A>");
+        printf ("\n");
+
+        if (verbose)
+                printf ("%f:%d%% %f:%d%%\n", wrta, wpl, crta, cpl);
+
+        return result;
+}
+
+
+/* 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");
+                if (strcmp ("-nohtml", argv[c]) == 0)
+                        strcpy (argv[c], "-n");
+        }
+
+        c = 0;
+        while ((c += call_getopt (argc - c, &argv[c])) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (server_address == NULL) {
+                        if (is_host (argv[c]) == FALSE) {
+                                printf ("Invalid host name/address: %s\n\n", argv[c]);
+                                return ERROR;
+                        }
+                        server_address = argv[c];
+                }
+                else if (wpl == UNKNOWN_PACKET_LOSS) {
+                        if (is_intpercent (argv[c]) == FALSE) {
+                                printf ("<wpl> (%s) must be an integer percentage\n", argv[c]);
+                                return ERROR;
+                        }
+                        wpl = atoi (argv[c]);
+                }
+                else if (cpl == UNKNOWN_PACKET_LOSS) {
+                        if (is_intpercent (argv[c]) == FALSE) {
+                                printf ("<cpl> (%s) must be an integer percentage\n", argv[c]);
+                                return ERROR;
+                        }
+                        cpl = atoi (argv[c]);
+                }
+                else if (wrta == UNKNOWN_TRIP_TIME) {
+                        if (is_negative (argv[c])) {
+                                printf ("<wrta> (%s) must be a non-negative number\n", argv[c]);
+                                return ERROR;
+                        }
+                        wrta = atof (argv[c]);
+                }
+                else if (crta == UNKNOWN_TRIP_TIME) {
+                        if (is_negative (argv[c])) {
+                                printf ("<crta> (%s) must be a non-negative number\n", argv[c]);
+                                return ERROR;
+                        }
+                        crta = atof (argv[c]);
+                }
+                else if (max_packets == -1) {
+                        if (is_intnonneg (argv[c])) {
+                                max_packets = atoi (argv[c]);
+                        }
+                        else {
+                                printf ("<max_packets> (%s) must be a non-negative number\n",
+                                                                argv[c]);
+                                return ERROR;
+                        }
+                }
+
+        }
+
+        return validate_arguments ();
+}
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"help", no_argument, 0, 'h'},
+                {"version", no_argument, 0, 'V'},
+                {"verbose", no_argument, 0, 'v'},
+                {"nohtml", no_argument, 0, 'n'},
+                {"link", no_argument, 0, 'L'},
+                {"timeout", required_argument, 0, 't'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"hostname", required_argument, 0, 'H'},
+                {"packets", required_argument, 0, 'p'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVvt:c:w:H:p:nL", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+hVvt:c:w:H:p:nL");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 't':
+                case 'c':
+                case 'w':
+                case 'H':
+                case 'p':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* print short usage statement if args not parsable */
+                        usage2 ("Unknown argument", optarg);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, REVISION);
+                        exit (STATE_OK);
+                case 't':                                                                       /* timeout period */
+                        timeout_interval = atoi (optarg);
+                        break;
+                case 'v':                                                                       /* verbose mode */
+                        verbose = TRUE;
+                        break;
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg) == FALSE)
+                                usage2 ("Invalid host name/address", optarg);
+                        server_address = optarg;
+                        break;
+                case 'p':                                                                       /* number of packets to send */
+                        if (is_intnonneg (optarg))
+                                max_packets = atoi (optarg);
+                        else
+                                usage2 ("<max_packets> (%s) must be a non-negative number\n", optarg);
+                        break;
+                case 'n':                                                                       /* no HTML */
+                        display_html = FALSE;
+                        break;
+                case 'L':                                                                       /* show HTML */
+                        display_html = TRUE;
+                        break;
+                case 'c':
+                        get_threshold (optarg, &crta, &cpl);
+                        break;
+                case 'w':
+                        get_threshold (optarg, &wrta, &wpl);
+                        break;
+                }
+        }
+
+        return i;
+}
+
+int
+get_threshold (char *arg, float *trta, int *tpl)
+{
+        if (is_intnonneg (arg) && sscanf (arg, "%f", trta) == 1)
+                return OK;
+        else if (strpbrk (arg, ",:") && strstr (arg, "%") && sscanf (arg, "%f%*[:,]%d%%", trta, tpl) == 2)
+                return OK;
+        else if (strstr (arg, "%") && sscanf (arg, "%d%%", tpl) == 1) 
+                return OK;
+        else
+                usage2 ("%s: Warning threshold must be integer or percentage!\n\n", arg);
+
+}
+
+int
+validate_arguments ()
+{
+        float max_seconds;
+
+        if (wrta == UNKNOWN_TRIP_TIME) {
+                printf ("<wrta> was not set\n");
+                return ERROR;
+        }
+        else if (crta == UNKNOWN_TRIP_TIME) {
+                printf ("<crta> was not set\n");
+                return ERROR;
+        }
+        else if (wpl == UNKNOWN_PACKET_LOSS) {
+                printf ("<wpl> was not set\n");
+                return ERROR;
+        }
+        else if (cpl == UNKNOWN_PACKET_LOSS) {
+                printf ("<cpl> was not set\n");
+                return ERROR;
+        }
+        else if (wrta > crta) {
+                printf ("<wrta> (%f) cannot be larger than <crta> (%f)\n", wrta, crta);
+                return ERROR;
+        }
+        else if (wpl > cpl) {
+                printf ("<wpl> (%d) cannot be larger than <cpl> (%d)\n", wpl, cpl);
+                return ERROR;
+        }
+
+        if (max_packets == -1)
+                max_packets = DEFAULT_MAX_PACKETS;
+
+        max_seconds = crta / 1000.0 * max_packets + max_packets;
+        if (max_seconds > timeout_interval)
+                timeout_interval = (int)max_seconds;
+
+        return OK;
+}
+
+
+int
+run_ping (char *command_line)
+{
+        char input_buffer[MAX_INPUT_BUFFER];
+        int result = STATE_UNKNOWN;
+
+        warn_text = malloc (1);
+        if (warn_text == NULL)
+                terminate (STATE_UNKNOWN, "unable to malloc warn_text");
+        warn_text[0] = 0;
+
+        if ((child_process = spopen (command_line)) == NULL) {
+                printf ("Cannot open pipe: ");
+                terminate (STATE_UNKNOWN, command_line);
+        }
+        child_stderr = fdopen (child_stderr_array[fileno (child_process)], "r");
+        if (child_stderr == NULL)
+                printf ("Cannot open stderr for %s\n", command_line);
+
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+
+                if (strstr (input_buffer, "(DUP!)")) {
+                        result = max (result, STATE_WARNING);
+                        warn_text = realloc (warn_text, strlen (WARN_DUPLICATES) + 1);
+                        if (warn_text == NULL)
+                                terminate (STATE_UNKNOWN, "unable to realloc warn_text");
+                        strcpy (warn_text, WARN_DUPLICATES);
+                }
+
+                /* get the percent loss statistics */
+                if (sscanf
+                                (input_buffer,
+                                 "%*d packets transmitted, %*d packets received, +%*d errors, %d%% packet loss",
+                                 &pl) == 1
+                                || sscanf (input_buffer,
+                                                                         "%*d packets transmitted, %*d packets received, %d%% packet loss",
+                                                                         &pl) == 1)
+                        continue;
+
+                /* get the round trip average */
+                else
+                        if (sscanf (input_buffer, "round-trip min/avg/max = %*f/%f/%*f", &rta)
+                                        == 1
+                                        || sscanf (input_buffer,
+                                                                                 "round-trip min/avg/max/mdev = %*f/%f/%*f/%*f",
+                                                                                 &rta) == 1
+                                        || sscanf (input_buffer,
+                                                                                 "round-trip min/avg/max/sdev = %*f/%f/%*f/%*f",
+                                                                                 &rta) == 1
+                                        || sscanf (input_buffer,
+                                                                                 "round-trip min/avg/max/stddev = %*f/%f/%*f/%*f",
+                                                                                 &rta) == 1
+                                        || sscanf (input_buffer,
+                                                                                 "round-trip min/avg/max/std-dev = %*f/%f/%*f/%*f",
+                                                                                 &rta) == 1
+                                        || sscanf (input_buffer, "round-trip (ms) min/avg/max = %*f/%f/%*f",
+                                                                                 &rta) == 1)
+                        continue;
+        }
+
+        /* this is needed because there is no rta if all packets are lost */
+        if (pl == 100)
+                rta = crta;
+
+
+        /* check stderr */
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) {
+                if (strstr
+                                (input_buffer,
+                                 "Warning: no SO_TIMESTAMP support, falling back to SIOCGSTAMP"))
+                                continue;
+
+                if (strstr (input_buffer, "Network is unreachable"))
+                        terminate (STATE_CRITICAL, "PING CRITICAL - Network unreachable (%s)",
+                                                                 server_address);
+                else if (strstr (input_buffer, "Destination Host Unreachable"))
+                        terminate (STATE_CRITICAL, "PING CRITICAL - Host Unreachable (%s)",
+                                                                 server_address);
+
+                warn_text =
+                        realloc (warn_text, strlen (warn_text) + strlen (input_buffer) + 2);
+                if (warn_text == NULL)
+                        terminate (STATE_UNKNOWN, "unable to realloc warn_text");
+                if (strlen (warn_text) == 0)
+                        strcpy (warn_text, input_buffer);
+                else
+                        sprintf (warn_text, "%s %s", warn_text, input_buffer);
+
+                if (strstr (input_buffer, "DUPLICATES FOUND"))
+                        result = max (result, STATE_WARNING);
+                else
+                        result = max (result, STATE_CRITICAL);
+        }
+        (void) fclose (child_stderr);
+
+
+        /* close the pipe - WARNING if status is set */
+        if (spclose (child_process))
+                result = max (result, STATE_WARNING);
+
+        return result;
+}
+
+
+void
+print_usage (void)
+{
+        printf ("Usage:\n" " %s %s\n"
+#ifdef HAVE_GETOPT_H
+                                        " %s (-h | --help) for detailed help\n"
+                                        " %s (-V | --version) for version information\n",
+#else
+                                        " %s -h for detailed help\n"
+                                        " %s -V for version information\n",
+#endif
+                                        PROGNAME, OPTIONS, PROGNAME, PROGNAME);
+}
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, REVISION);
+        printf
+                ("Copyright (c) %s %s <%s>\n\n%s\n",
+                 COPYRIGHT, AUTHOR, EMAIL, SUMMARY);
+        print_usage ();
+        printf
+                ("\nOptions:\n" LONGOPTIONS "\n" DESCRIPTION "\n", 
+                 DEFAULT_MAX_PACKETS, DEFAULT_SOCKET_TIMEOUT);
+        support ();
+}
diff --git a/plugins/check_pop.c b/plugins/check_pop.c
new file mode 100644
index 00000000..9fcfaec6
--- /dev/null
+++ b/plugins/check_pop.c
@@ -0,0 +1,364 @@
+/******************************************************************************
+ *
+ * CHECK_POP.C
+ *
+ * Program: POP3 plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ *
+ * $Id$
+ *
+ * Description:
+ *
+ * This plugin will attempt to open an POP connection with the host.
+ * Successul connects return STATE_OK, refusals and timeouts return
+ * STATE_CRITICAL, other errors return STATE_UNKNOWN.  Successful
+ * connects, but incorrect reponse messages from the host result in
+ * STATE_WARNING return values.
+ *
+ * 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 "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define PROGNAME "check_pop"
+
+#define POP_PORT        110
+#define POP_EXPECT     "+OK"
+#define POP_QUIT        "QUIT\n"
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+int check_disk (int usp, int free_disk);
+void print_help (void);
+void print_usage (void);
+
+int server_port = POP_PORT;
+char *server_address = NULL;
+char *server_expect = NULL;
+int warning_time = 0;
+int check_warning_time = FALSE;
+int critical_time = 0;
+int check_critical_time = FALSE;
+int verbose = FALSE;
+
+int
+main (int argc, char **argv)
+{
+        int sd;
+        int result;
+        char buffer[MAX_INPUT_BUFFER];
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+
+        /* try to connect to the host at the given port number */
+        time (&start_time);
+        result = my_tcp_connect (server_address, server_port, &sd);
+
+        /* we connected, so close connection before exiting */
+        if (result == STATE_OK) {
+
+                /* watch for the SMTP connection string */
+                result = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+
+                /* strip the buffer of carriage returns */
+                strip (buffer);
+
+                /* return a WARNING status if we couldn't read any data */
+                if (result == -1) {
+                        printf ("recv() failed\n");
+                        result = STATE_WARNING;
+                }
+
+                else {
+
+                        /* make sure we find the response we are looking for */
+                        if (!strstr (buffer, server_expect)) {
+                                if (server_port == POP_PORT)
+                                        printf ("Invalid POP response received from host\n");
+                                else
+                                        printf ("Invalid POP response received from host on port %d\n",
+                                                                        server_port);
+                                result = STATE_WARNING;
+                        }
+
+                        else {
+                                time (&end_time);
+
+                                result = STATE_OK;
+
+                                if (check_critical_time == TRUE
+                                                && (end_time - start_time) > critical_time) result =
+                                                STATE_CRITICAL;
+                                else if (check_warning_time == TRUE
+                                                                 && (end_time - start_time) > warning_time) result =
+                                                STATE_WARNING;
+
+                                if (verbose == TRUE)
+                                        printf ("POP %s - %d sec. response time, %s\n",
+                                                                        (result == STATE_OK) ? "ok" : "problem",
+                                                                        (int) (end_time - start_time), buffer);
+                                else
+                                        printf ("POP %s - %d second response time\n",
+                                                                        (result == STATE_OK) ? "ok" : "problem",
+                                                                        (int) (end_time - start_time));
+                        }
+                }
+
+                /* close the connection */
+                send (sd, POP_QUIT, strlen (POP_QUIT), 0);
+                close (sd);
+        }
+
+        /* reset the alarm */
+        alarm (0);
+
+        return result;
+}
+
+
+
+
+
+
+
+/* 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");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (server_address == NULL) {
+                        if (is_host (argv[c])) {
+                                server_address = argv[c];
+                        }
+                        else {
+                                usage ("Invalid host name");
+                        }
+                }
+        }
+
+        if (server_address == NULL)
+                server_address = strscpy (NULL, "127.0.0.1");
+
+        if (server_expect == NULL)
+                server_expect = strscpy (NULL, POP_EXPECT);
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"expect", required_argument, 0, 'e'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"port", required_argument, 0, 'P'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVvt:p:e:c:w:H:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+?hVvt:p:e:c:w:H:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 't':
+                case 'p':
+                case 'e':
+                case 'c':
+                case 'w':
+                case 'H':
+                        i++;
+                }
+
+                switch (c) {
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg)) {
+                                server_address = optarg;
+                        }
+                        else {
+                                usage ("Invalid host name\n");
+                        }
+                        break;
+                case 'p':                                                                       /* port */
+                        if (is_intpos (optarg)) {
+                                server_port = atoi (optarg);
+                        }
+                        else {
+                                usage ("Server port must be a positive integer\n");
+                        }
+                        break;
+                case 'e':                                                                       /* username */
+                        server_expect = optarg;
+                        break;
+                case 'c':                                                                       /* critical time threshold */
+                        if (is_intnonneg (optarg)) {
+                                critical_time = atoi (optarg);
+                                check_critical_time = TRUE;
+                        }
+                        else {
+                                usage ("Critical time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'w':                                                                       /* warning time threshold */
+                        if (is_intnonneg (optarg)) {
+                                warning_time = atoi (optarg);
+                                check_warning_time = TRUE;
+                        }
+                        else {
+                                usage ("Warning time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'v':                                                                       /* verbose */
+                        verbose = TRUE;
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (is_intnonneg (optarg)) {
+                                socket_timeout = atoi (optarg);
+                        }
+                        else {
+                                usage ("Time interval must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        return OK;
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Ethan Galstad/Karl DeBisschop\n\n"
+                 "This plugin tests the POP service on the specified host.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -H, --hostname=STRING or IPADDRESS\n"
+                 "   Check server on the indicated host\n"
+                 " -p, --port=INTEGER\n"
+                 "   Make connection on the indicated port (default: %d)\n"
+                 " -e, --expect=STRING\n"
+                 "   String to expect in first line of server response (default: %s)\n"
+                 " -w, --warning=INTEGER\n"
+                 "   Seconds necessary to result in a warning status\n"
+                 " -c, --critical=INTEGER\n"
+                 "   Seconds necessary to result in a critical status\n"
+                 " -t, --timeout=INTEGER\n"
+                 "   Seconds before connection attempt times out (default: %d)\n"
+                 " -v, --verbose\n"
+                 "   Print extra information (command-line use only)\n"
+                 " -h, --help\n"
+                 "   Print detailed help screen\n"
+                 " -V, --version\n"
+                 "   Print version information\n\n",
+                 POP_PORT, POP_EXPECT, DEFAULT_SOCKET_TIMEOUT);
+        support ();
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H host [-e expect] [-p port] [-w warn] [-c crit] [-t timeout] [-v]\n"
+                 "       %s --help\n"
+                 "       %s --version\n", PROGNAME, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_procs.c b/plugins/check_procs.c
new file mode 100644
index 00000000..c66d33de
--- /dev/null
+++ b/plugins/check_procs.c
@@ -0,0 +1,510 @@
+/******************************************************************************
+*
+* CHECK_PROCS.C
+*
+* Program: Process plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+*
+* $Id$
+*
+* Description:
+*
+* This plugin checks the number of currently running processes and
+* generates WARNING or CRITICAL states if the process count is outside
+* the specified threshold ranges. The process count can be filtered by
+* process owner, parent process PID, current state (e.g., 'Z'), or may
+* be the total number of running processes
+*
+* 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 "config.h"
+#include <pwd.h>
+#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 (void);
+void print_help (char *);
+
+int wmax = -1;
+int cmax = -1;
+int wmin = -1;
+int cmin = -1;
+
+int options = 0;
+#define ALL 1
+#define STAT 2
+#define PPID 4
+#define USER 8
+#define PROG 16
+#define ARGS 32
+
+int verbose = FALSE;
+int uid;
+int ppid;
+char *statopts = NULL;
+char *prog = NULL;
+char *args = NULL;
+char *format = NULL;
+char tmp[MAX_INPUT_BUFFER];
+
+int
+main (int argc, char **argv)
+{
+        char input_buffer[MAX_INPUT_BUFFER];
+
+        int procuid = 0;
+        int procppid = 0;
+        char procstat[8];
+        char procprog[MAX_INPUT_BUFFER];
+        char *procargs;
+
+        int resultsum = 0;
+        int found = 0;
+        int procs = 0;
+        int pos;
+
+        int result = STATE_UNKNOWN;
+
+        procargs = malloc (MAX_INPUT_BUFFER);
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Unable to parse command line\n");
+
+        /* run the command */
+        if (verbose)
+                printf ("%s\n", PS_COMMAND);
+        child_process = spopen (PS_COMMAND);
+        if (child_process == NULL) {
+                printf ("Could not open pipe: %s\n", PS_COMMAND);
+                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", PS_COMMAND);
+
+        fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process);
+
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+                if (
+#ifdef USE_PS_VARS
+                                 sscanf (input_buffer, PS_FORMAT, PS_VARLIST) >= 4
+#else
+                                 sscanf (input_buffer, PS_FORMAT, procstat, &procuid, &procppid, &pos,
+                                                                 procprog) >= 4
+#endif
+                        ) {
+                        found++;
+                        resultsum = 0;
+                        procargs = strcpy (procargs, &input_buffer[pos]);
+                        strip (procargs);
+                        if ((options & STAT) && (strstr (statopts, procstat)))
+                                resultsum |= STAT;
+                        if ((options & ARGS) && (strstr (procargs, args) == procargs))
+                                resultsum |= ARGS;
+                        if ((options & PROG) && (strcmp (prog, procprog) == 0))
+                                resultsum |= PROG;
+                        if ((options & PPID) && (procppid == ppid))
+                                resultsum |= PPID;
+                        if ((options & USER) && (procuid == uid))
+                                resultsum |= USER;
+#ifdef DEBUG1
+                        if (procargs == NULL)
+                                printf ("%d %d %d %s %s\n", procs, procuid, procppid, procstat,
+                                                                procprog);
+                        else
+                                printf ("%d %d %d %s %s %s\n", procs, procuid, procppid, procstat,
+                                                                procprog, procargs);
+#endif
+                        if (options == resultsum)
+                                procs++;
+                }
+        }
+
+        /* If we get anything on STDERR, at least set warning */
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) {
+                if (verbose)
+                        printf ("%s", input_buffer);
+                result = max (result, STATE_WARNING);
+        }
+        if (result > STATE_OK)
+                printf ("System call sent warnings to stderr\n");
+
+        (void) fclose (child_stderr);
+
+        /* close the pipe */
+        if (spclose (child_process)) {
+                printf ("System call returned nonzero status\n");
+                return max (result, STATE_WARNING);
+        }
+
+        if (options == ALL)
+                procs = found;
+
+        if (found == 0) {                                                       /* no process lines parsed so return STATE_UNKNOWN */
+                printf ("Unable to read output\n");
+                return max (result, STATE_UNKNOWN);
+        }
+
+        if (verbose && (options & STAT))
+                printf ("%s ", statopts);
+        if (verbose && (options & PROG))
+                printf ("%s ", prog);
+        if (verbose && (options & PPID))
+                printf ("%d ", ppid);
+        if (verbose && (options & USER))
+                printf ("%d ", uid);
+
+        if (cmax >= 0 && cmin >= 0 && cmax < cmin) {
+                if (procs > cmax && procs < cmin) {
+                        printf (format, "CRITICAL", procs);
+                        return STATE_CRITICAL;
+                }
+        }
+        else if (cmax >= 0 && procs > cmax) {
+                printf (format, "CRITICAL", procs);
+                return STATE_CRITICAL;
+        }
+        else if (cmin >= 0 && procs < cmin) {
+                printf (format, "CRITICAL", procs);
+                return STATE_CRITICAL;
+        }
+
+        if (wmax >= 0 && wmin >= 0 && wmax < wmin) {
+                if (procs > wmax && procs < wmin) {
+                        printf (format, "CRITICAL", procs);
+                        return STATE_CRITICAL;
+                }
+        }
+        else if (wmax >= 0 && procs > wmax) {
+                printf (format, "WARNING", procs);
+                return max (result, STATE_WARNING);
+        }
+        else if (wmin >= 0 && procs < wmin) {
+                printf (format, "WARNING", procs);
+                return max (result, STATE_WARNING);
+        }
+
+        printf (format, "OK", procs);
+        return max (result, STATE_OK);
+}
+
+/* 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 (wmax == -1)
+                        wmax = atoi (argv[c]);
+                else if (cmax == -1)
+                        cmax = atoi (argv[c]);
+                else if (statopts == NULL) {
+                        statopts = strscpy (statopts, argv[c]);
+                        format =
+                                strscat (format,
+                                                                 ssprintf (NULL, "%sSTATE = %s", (options ? ", " : ""),
+                                                                                                         statopts));
+                        options |= STAT;
+                }
+        }
+
+        return validate_arguments ();
+}
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 1;
+        char *user;
+        struct passwd *pw;
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"warning", required_argument, 0, 'w'},
+                {"critical", required_argument, 0, 'c'},
+                {"timeout", required_argument, 0, 't'},
+                {"status", required_argument, 0, 's'},
+                {"ppid", required_argument, 0, 'p'},
+                {"command", required_argument, 0, 'C'},
+                {"argument-array", required_argument, 0, 'a'},
+                {"help", no_argument, 0, 'h'},
+                {"version", no_argument, 0, 'V'},
+                {"verbose", no_argument, 0, 'v'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+Vvht:c:w:p:s:u:C:a:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+Vvht:c:w:p:s:u:C:a:");
+#endif
+
+                if (c == EOF)
+                        break;
+
+                i++;
+                switch (c) {
+                case 't':
+                case 'c':
+                case 'w':
+                case 'p':
+                case 's':
+                case 'a':
+                case 'u':
+                case 'C':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* help */
+                        print_usage ();
+                        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$");
+                        exit (STATE_OK);
+                case 't':                                                                       /* timeout period */
+                        if (!is_integer (optarg)) {
+                                printf ("%s: Timeout Interval must be an integer!\n\n",
+                                                                my_basename (argv[0]));
+                                print_usage ();
+                                exit (STATE_UNKNOWN);
+                        }
+                        timeout_interval = atoi (optarg);
+                        break;
+                case 'c':                                                                       /* critical threshold */
+                        if (is_integer (optarg)) {
+                                cmax = atoi (optarg);
+                                break;
+                        }
+                        else if (sscanf (optarg, ":%d", &cmax) == 1) {
+                                break;
+                        }
+                        else if (sscanf (optarg, "%d:%d", &cmin, &cmax) == 2) {
+                                break;
+                        }
+                        else if (sscanf (optarg, "%d:", &cmin) == 1) {
+                                break;
+                        }
+                        else {
+                                printf ("%s: Critical Process Count must be an integer!\n\n",
+                                                                my_basename (argv[0]));
+                                print_usage ();
+                                exit (STATE_UNKNOWN);
+                        }
+                case 'w':                                                                       /* warning time threshold */
+                        if (is_integer (optarg)) {
+                                wmax = atoi (optarg);
+                                break;
+                        }
+                        else if (sscanf (optarg, ":%d", &wmax) == 1) {
+                                break;
+                        }
+                        else if (sscanf (optarg, "%d:%d", &wmin, &wmax) == 2) {
+                                break;
+                        }
+                        else if (sscanf (optarg, "%d:", &wmin) == 1) {
+                                break;
+                        }
+                        else {
+                                printf ("%s: Warning Process Count must be an integer!\n\n",
+                                                                my_basename (argv[0]));
+                                print_usage ();
+                                exit (STATE_UNKNOWN);
+                        }
+                case 'p':                                                                       /* process id */
+                        if (sscanf (optarg, "%d%[^0-9]", &ppid, tmp) == 1) {
+                                format =
+                                        strscat (format,
+                                                                         ssprintf (NULL, "%sPPID = %d", (options ? ", " : ""),
+                                                                                                                 ppid));
+                                options |= PPID;
+                                break;
+                        }
+                        printf ("%s: Parent Process ID must be an integer!\n\n",
+                                                        my_basename (argv[0]));
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 's':                                                                       /* status */
+                        statopts = strscpy (statopts, optarg);
+                        format =
+                                strscat (format,
+                                                                 ssprintf (NULL, "%sSTATE = %s", (options ? ", " : ""),
+                                                                                                         statopts));
+                        options |= STAT;
+                        break;
+                case 'u':                                                                       /* user or user id */
+                        if (is_integer (optarg)) {
+                                uid = atoi (optarg);
+                                pw = getpwuid ((uid_t) uid);
+                                /*  check to be sure user exists */
+                                if (pw == NULL) {
+                                        printf ("UID %d was not found\n", uid);
+                                        print_usage ();
+                                        exit (STATE_UNKNOWN);
+                                }
+                        }
+                        else {
+                                pw = getpwnam (optarg);
+                                /*  check to be sure user exists */
+                                if (pw == NULL) {
+                                        printf ("User name %s was not found\n", optarg);
+                                        print_usage ();
+                                        exit (STATE_UNKNOWN);
+                                }
+                                /*  then get uid */
+                                uid = pw->pw_uid;
+                        }
+                        user = pw->pw_name;
+                        format =
+                                strscat (format,
+                                                                 ssprintf (NULL, "%sUID = %d (%s)", (options ? ", " : ""),
+                                                                                                         uid, user));
+                        options |= USER;
+                        break;
+                case 'C':                                                                       /* command */
+                        prog = strscpy (prog, optarg);
+                        format =
+                                strscat (format,
+                                                                 ssprintf (NULL, "%scommand name %s", (options ? ", " : ""),
+                                                                                                         prog));
+                        options |= PROG;
+                        break;
+                case 'a':                                                                       /* args (full path name with args) */
+                        args = strscpy (args, optarg);
+                        format =
+                                strscat (format,
+                                                                 ssprintf (NULL, "%sargs %s", (options ? ", " : ""), args));
+                        options |= ARGS;
+                        break;
+                case 'v':                                                                       /* command */
+                        verbose = TRUE;
+                        break;
+                }
+        }
+        return i;
+}
+
+
+int
+validate_arguments ()
+{
+
+        if (wmax >= 0 && wmin == -1)
+                wmin = 0;
+        if (cmax >= 0 && cmin == -1)
+                cmin = 0;
+        if (wmax >= wmin && cmax >= cmin) {     /* standard ranges */
+                if (wmax > cmax && cmax != -1) {
+                        printf ("wmax (%d) cannot be greater than cmax (%d)\n", wmax, cmax);
+                        return ERROR;
+                }
+                if (cmin > wmin && wmin != -1) {
+                        printf ("wmin (%d) cannot be less than cmin (%d)\n", wmin, cmin);
+                        return ERROR;
+                }
+        }
+
+        if (wmax == -1 && cmax == -1 && wmin == -1 && cmin == -1) {
+                printf ("At least one threshold must be set\n");
+                return ERROR;
+        }
+
+        if (options == 0) {
+                options = 1;
+                format = ssprintf (format, "%%s - %%d processes running\n");
+        }
+        else {
+                format =
+                        ssprintf (format, "%%s - %%d processes running with %s\n", format);
+        }
+
+        return options;
+}
+
+
+void
+print_help (char *cmd)
+{
+        print_revision (cmd, "$Revision$");
+        printf
+                ("Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)\n\n"
+                 "This plugin checks the number of currently running processes and\n"
+                 "generates WARNING or CRITICAL states if the process count is outside\n"
+                 "the specified threshold ranges. The process count can be filtered by\n"
+                 "process owner, parent process PID, current state (e.g., 'Z'), or may\n"
+                 "be the total number of running processes\n\n");
+        print_usage ();
+        printf
+                ("\nRequired Arguments:\n"
+                 " -w, --warning=RANGE\n"
+                 "    generate warning state if process count is outside this range\n"
+                 " -c, --critical=RANGE\n"
+                 "    generate critical state if process count is outside this range\n\n"
+                 "Optional Filters:\n"
+                 " -s, --state=STATUSFLAGS\n"
+                 "    Only scan for processes that have, in the output of `ps`, one or\n"
+                 "    more of the status flags you specify (for example R, Z, S, RS,\n"
+                 "    RSZDT, plus others based on the output of your 'ps' command).\n"
+                 " -p, --ppid=PPID\n"
+                 "    Only scan for children of the parent process ID indicated.\n"
+                 " -u, --user=USER\n"
+                 "    Only scan for proceses with user name or ID indicated.\n"
+                 " -a, --argument-array=STRING\n"
+                 "    Only scan for ARGS that match up to the length of the given STRING\n"
+                 " -C, --command=COMMAND\n"
+                 "    Only scan for exact matches to the named COMMAND.\n\n"
+                 "RANGEs are specified 'min:max' or 'min:' or ':max' (or 'max'). If\n"
+                 "specified 'max:min', a warning status will be generated if the\n"
+
+                 "count is inside the specified range\n");}
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage:\n"
+                 " check_procs -w <range> -c <range> [-s state] [-p ppid] [-u user]\n"
+                 "             [-a argument-array] [-C command]\n"
+                 " check_procs --version\n" " check_procs --help\n");
+}
diff --git a/plugins/check_radius.c b/plugins/check_radius.c
new file mode 100644
index 00000000..614d467b
--- /dev/null
+++ b/plugins/check_radius.c
@@ -0,0 +1,345 @@
+/******************************************************************************
+ *
+ * Program: radius server check plugin for Nagios
+ * License: GPL
+ *
+ * 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.
+ *
+ * $Id$
+ *
+ *****************************************************************************/
+
+#define PROGNAME "check_radius"
+#define REVISION "$Revision$"
+#define COPYRIGHT "1999-2001"
+#define AUTHORS "Robert August Vincent II/Karl DeBisschop"
+#define EMAIL "kdebisschop@users.sourceforge.net"
+#define SUMMARY "Tests to see if a radius server is accepting connections.\n"
+
+#define OPTIONS "\
+-H host -F config_file -u username -p password\'\
+              [-P port] [-t timeout] [-r retries] [-e expect]"
+
+#define LONGOPTIONS "\
+ -H, --hostname=HOST\n\
+    Host name argument for servers using host headers (use numeric\n\
+    address if possible to bypass DNS lookup).\n\
+ -P, --port=INTEGER\n\
+    Port number (default: %d)\n\
+ -u, --username=STRING\n\
+    The user to authenticate\n\
+ -p, --password=STRING\n\
+    Password for autentication (SECURITY RISK)\n\
+ -F, --filename=STRING\n\
+    Configuration file\n\
+ -e, --expect=STRING\n\
+    Response string to expect from the server\n\
+ -r, --retries=INTEGER\n\
+    Number of times to retry a failed connection\n\
+ -t, --timeout=INTEGER\n\
+    Seconds before connection times out (default: %d)\n\
+ -v\n\
+    Show details for command-line debugging (do not use with nagios server)\n\
+ -h, --help\n\
+    Print detailed help screen\n\
+ -V, --version\n\
+    Print version information\n"
+
+#define DESCRIPTION "\
+The password option presents a substantial security issue because the 
+password can be determined by careful watching of the command line in
+a process listing.  This risk is exacerbated because nagios will
+run the plugin at regular prdictable intervals.  Please be sure that
+the password used does not allow access to sensitive system resources,
+otherwise compormise could occur.\n"
+
+#include "config.h"
+#include "common.h"
+#include "utils.h"
+#include <radiusclient.h>
+
+int process_arguments (int, char **);
+void print_usage (void);
+void print_help (void);
+
+char *server = NULL;
+int port = PW_AUTH_UDP_PORT;
+char *username = NULL;
+char *password = NULL;
+char *expect = NULL;
+char *config_file = NULL;
+int retries = 1;
+int verbose = FALSE;
+
+ENV *env = NULL;
+
+/******************************************************************************
+
+The (psuedo?)literate programming XML is contained within \@\@\- <XML> \-\@\@
+tags in the comments. With in the tags, the XML is assembled sequentially.
+You can define entities in tags. You also have all the #defines available as
+entities.
+
+Please note that all tags must be lowercase to use the DocBook XML DTD.
+
+@@-<article>
+
+<sect1>
+<title>Quick Reference</title>
+<!-- The refentry forms a manpage -->
+<refentry>
+<refmeta>
+<manvolnum>5<manvolnum>
+</refmeta>
+<refnamdiv>
+<refname>&PROGNAME;</refname>
+<refpurpose>&SUMMARY;</refpurpose>
+</refnamdiv>
+</refentry>
+</sect1>
+
+<sect1>
+<title>FAQ</title>
+</sect1>
+
+<sect1>
+<title>Theory, Installation, and Operation</title>
+
+<sect2>
+<title>General Description</title>
+<para>
+&DESCRIPTION;
+</para>
+</sect2>
+
+<sect2>
+<title>Future Enhancements</title>
+<para>ToDo List</para>
+<itemizedlist>
+<listitem>Add option to get password from a secured file rather than the command line</listitem>
+</itemizedlist>
+</sect2>
+
+
+<sect2>
+<title>Functions</title>
+-@@
+******************************************************************************/
+
+int
+main (int argc, char **argv)
+{
+        UINT4 service;
+        char msg[BUFFER_LEN];
+        SEND_DATA data = { 0 };
+        int result;
+        UINT4 client_id;
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments\n");
+
+        if ((config_file && rc_read_config (config_file)) ||
+                        rc_read_dictionary (rc_conf_str ("dictionary")))
+                terminate (STATE_UNKNOWN, "Config file error");
+
+        service = PW_AUTHENTICATE_ONLY;
+
+        if (!(rc_avpair_add (&data.send_pairs, PW_SERVICE_TYPE, &service, 0) &&
+                                rc_avpair_add (&data.send_pairs, PW_USER_NAME, username, 0) &&
+                                rc_avpair_add (&data.send_pairs, PW_USER_PASSWORD, password, 0)))
+                terminate (STATE_UNKNOWN, "Out of Memory?");
+
+        /* 
+         * Fill in NAS-IP-Address 
+         */
+
+        if ((client_id = rc_own_ipaddress ()) == 0)
+                return (ERROR_RC);
+
+        if (rc_avpair_add (&(data.send_pairs), PW_NAS_IP_ADDRESS, &client_id, 0) ==
+                        NULL) return (ERROR_RC);
+
+        rc_buildreq (&data, PW_ACCESS_REQUEST, server, port, timeout_interval,
+                                                         retries);
+
+        result = rc_send_server (&data, msg);
+        rc_avpair_free (data.send_pairs);
+        if (data.receive_pairs)
+                rc_avpair_free (data.receive_pairs);
+
+        if (result == TIMEOUT_RC)
+                terminate (STATE_CRITICAL, "Timeout");
+        if (result == ERROR_RC)
+                terminate (STATE_CRITICAL, "Auth Error");
+        if (result == BADRESP_RC)
+                terminate (STATE_WARNING, "Auth Failed");
+        if (expect && !strstr (msg, expect))
+                terminate (STATE_WARNING, msg);
+        if (result == OK_RC)
+                terminate (STATE_OK, "Auth OK");
+        return (0);
+}
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"port", required_argument, 0, 'P'},
+                {"username", required_argument, 0, 'u'},
+                {"password", required_argument, 0, 'p'},
+                {"filename", required_argument, 0, 'F'},
+                {"expect", required_argument, 0, 'e'},
+                {"retries", required_argument, 0, 'r'},
+                {"timeout", required_argument, 0, 't'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        if (argc < 2)
+                return ERROR;
+
+        if (argc == 9) {
+                config_file = argv[1];
+                username = argv[2];
+                password = argv[3];
+                if (is_intpos (argv[4]))
+                        timeout_interval = atoi (argv[4]);
+                else
+                        usage ("Timeout interval must be a positive integer");
+                if (is_intpos (argv[5]))
+                        retries = atoi (argv[5]);
+                else
+                        usage ("Number of retries must be a positive integer");
+                server = argv[6];
+                if (is_intpos (argv[7]))
+                        port = atoi (argv[7]);
+                else
+                        usage ("Server port must be a positive integer");
+                expect = argv[8];
+                return OK;
+        }
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVvH:P:F:u:p:t:r:e:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+hVvH:P:F:u:p:t:r:e:");
+#endif
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case '?':                                                                       /* print short usage statement if args not parsable */
+                        printf ("%s: Unknown argument: %s\n\n", my_basename (argv[0]), optarg);
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (OK);
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (OK);
+                case 'v':                                                                       /* verbose mode */
+                        verbose = TRUE;
+                        break;
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg) == FALSE) {
+                                printf ("Invalid host name/address\n\n");
+                                print_usage ();
+                                exit (STATE_UNKNOWN);
+                        }
+                        server = optarg;
+                        break;
+                case 'P':                                                                       /* port */
+                        if (is_intnonneg (optarg))
+                                port = atoi (optarg);
+                        else
+                                usage ("Server port must be a positive integer");
+                        break;
+                case 'u':                                                                       /* username */
+                        username = optarg;
+                        break;
+                case 'p':                                                                       /* password */
+                        password = optarg;
+                        break;
+                case 'F':                                                                       /* configuration file */
+                        config_file = optarg;
+                        break;
+                case 'e':                                                                       /* expect */
+                        expect = optarg;
+                        break;
+                case 'r':                                                                       /* retries */
+                        if (is_intpos (optarg))
+                                retries = atoi (optarg);
+                        else
+                                usage ("Number of retries must be a positive integer");
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (is_intpos (optarg))
+                                timeout_interval = atoi (optarg);
+                        else
+                                usage ("Timeout interval must be a positive integer");
+                        break;
+                }
+        }
+        return OK;
+}
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, REVISION);
+        printf
+                ("Copyright (c) %s %s <%s>\n\n%s\n",
+                 COPYRIGHT, AUTHORS, EMAIL, SUMMARY);
+        print_usage ();
+        printf
+                ("\nOptions:\n" LONGOPTIONS "\n" DESCRIPTION "\n", 
+                 port, timeout_interval);
+        support ();
+}
+
+
+void
+print_usage (void)
+{
+        printf ("Usage:\n" " %s %s\n"
+#ifdef HAVE_GETOPT_H
+                                        " %s (-h | --help) for detailed help\n"
+                                        " %s (-V | --version) for version information\n",
+#else
+                                        " %s -h for detailed help\n"
+                                        " %s -V for version information\n",
+#endif
+                                        PROGNAME, OPTIONS, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_real.c b/plugins/check_real.c
new file mode 100644
index 00000000..ba746b81
--- /dev/null
+++ b/plugins/check_real.c
@@ -0,0 +1,661 @@
+/*****************************************************************************
+*
+* CHECK_REAL.C
+*
+* Program: RealMedia plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Pedro Leite (leite@cic.ua.pt)
+*
+* Based on CHECK_HTTP.C
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+*
+* Last Modified: $Date$
+*
+* Command line: CHECK_REAL <host_address> [-e expect] [-u url] [-p port]
+*                          [-hn host_name] [-wt warn_time] [-ct crit_time]
+*                          [-to to_sec]
+*
+* Description:
+*
+* This plugin will attempt to open an RTSP connection with the host.
+* Successul connects return STATE_OK, refusals and timeouts return
+* STATE_CRITICAL, other errors return STATE_UNKNOWN.  Successful connects,
+* but incorrect reponse messages from the host result in STATE_WARNING return
+* values.  If you are checking a virtual server that uses "host headers"you
+* must supply the FQDN (fully qualified domain name) as the [host_name]
+* argument.
+*
+* 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 "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define PROGNAME "check_real"
+
+#define PORT    554
+#define EXPECT  "RTSP/1."
+#define URL     ""
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+int check_disk (int usp, int free_disk);
+void print_help (void);
+void print_usage (void);
+
+int server_port = PORT;
+char *server_address = NULL;
+char *host_name = NULL;
+char *server_url = NULL;
+char *server_expect = NULL;
+int warning_time = 0;
+int check_warning_time = FALSE;
+int critical_time = 0;
+int check_critical_time = FALSE;
+int verbose = FALSE;
+
+int
+main (int argc, char **argv)
+{
+        int sd;
+        int result;
+        char buffer[MAX_INPUT_BUFFER];
+        char *status_line = NULL;
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+        time (&start_time);
+
+        /* try to connect to the host at the given port number */
+        if (my_tcp_connect (server_address, server_port, &sd) != STATE_OK)
+                terminate (STATE_CRITICAL, "Unable to connect to %s on port %d\n",
+                                                         server_address, server_port);
+
+        /* Part I - Server Check */
+
+        /* send the OPTIONS request */
+        sprintf (buffer, "OPTIONS rtsp://%s:%d RTSP/1.0\n", host_name, server_port);
+        result = send (sd, buffer, strlen (buffer), 0);
+
+        /* send the header sync */
+        sprintf (buffer, "CSeq: 1\n");
+        result = send (sd, buffer, strlen (buffer), 0);
+
+        /* send a newline so the server knows we're done with the request */
+        sprintf (buffer, "\n");
+        result = send (sd, buffer, strlen (buffer), 0);
+
+        /* watch for the REAL connection string */
+        result = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+
+        /* return a CRITICAL status if we couldn't read any data */
+        if (result == -1)
+                terminate (STATE_CRITICAL, "No data received from %s\n", host_name);
+
+        /* make sure we find the response we are looking for */
+        if (!strstr (buffer, EXPECT)) {
+                if (server_port == PORT)
+                        printf ("Invalid REAL response received from host\n");
+                else
+                        printf ("Invalid REAL response received from host on port %d\n",
+                                                        server_port);
+        }
+        else {
+                /* else we got the REAL string, so check the return code */
+
+                time (&end_time);
+
+                result = STATE_OK;
+
+                status_line = (char *) strtok (buffer, "\n");
+
+                if (strstr (status_line, "200"))
+                        result = STATE_OK;
+
+                /* client errors result in a warning state */
+                else if (strstr (status_line, "400"))
+                        result = STATE_WARNING;
+                else if (strstr (status_line, "401"))
+                        result = STATE_WARNING;
+                else if (strstr (status_line, "402"))
+                        result = STATE_WARNING;
+                else if (strstr (status_line, "403"))
+                        result = STATE_WARNING;
+                else if (strstr (status_line, "404"))
+                        result = STATE_WARNING;
+
+                /* server errors result in a critical state */
+                else if (strstr (status_line, "500"))
+                        result = STATE_CRITICAL;
+                else if (strstr (status_line, "501"))
+                        result = STATE_CRITICAL;
+                else if (strstr (status_line, "502"))
+                        result = STATE_CRITICAL;
+                else if (strstr (status_line, "503"))
+                        result = STATE_CRITICAL;
+
+                else
+                        result = STATE_UNKNOWN;
+        }
+
+        /* Part II - Check stream exists and is ok */
+        if ((result == STATE_OK) && (server_url != NULL)) {
+
+                /* Part I - Server Check */
+
+                /* send the OPTIONS request */
+                sprintf (buffer, "DESCRIBE rtsp://%s:%d%s RTSP/1.0\n", host_name,
+                                                 server_port, server_url);
+                result = send (sd, buffer, strlen (buffer), 0);
+
+                /* send the header sync */
+                sprintf (buffer, "CSeq: 2\n");
+                result = send (sd, buffer, strlen (buffer), 0);
+
+                /* send a newline so the server knows we're done with the request */
+                sprintf (buffer, "\n");
+                result = send (sd, buffer, strlen (buffer), 0);
+
+                /* watch for the REAL connection string */
+                result = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+
+                /* return a CRITICAL status if we couldn't read any data */
+                if (result == -1) {
+                        printf ("No data received from host\n");
+                        result = STATE_CRITICAL;
+                }
+                else {
+                        /* make sure we find the response we are looking for */
+                        if (!strstr (buffer, EXPECT)) {
+                                if (server_port == PORT)
+                                        printf ("Invalid REAL response received from host\n");
+                                else
+                                        printf ("Invalid REAL response received from host on port %d\n",
+                                                                        server_port);
+                        }
+                        else {
+
+                                /* else we got the REAL string, so check the return code */
+
+                                time (&end_time);
+
+                                result = STATE_OK;
+
+                                status_line = (char *) strtok (buffer, "\n");
+
+                                if (strstr (status_line, "200"))
+                                        result = STATE_OK;
+
+                                /* client errors result in a warning state */
+                                else if (strstr (status_line, "400"))
+                                        result = STATE_WARNING;
+                                else if (strstr (status_line, "401"))
+                                        result = STATE_WARNING;
+                                else if (strstr (status_line, "402"))
+                                        result = STATE_WARNING;
+                                else if (strstr (status_line, "403"))
+                                        result = STATE_WARNING;
+                                else if (strstr (status_line, "404"))
+                                        result = STATE_WARNING;
+
+                                /* server errors result in a critical state */
+                                else if (strstr (status_line, "500"))
+                                        result = STATE_CRITICAL;
+                                else if (strstr (status_line, "501"))
+                                        result = STATE_CRITICAL;
+                                else if (strstr (status_line, "502"))
+                                        result = STATE_CRITICAL;
+                                else if (strstr (status_line, "503"))
+                                        result = STATE_CRITICAL;
+
+                                else
+                                        result = STATE_UNKNOWN;
+                        }
+                }
+        }
+
+        /* Return results */
+        if (result == STATE_OK) {
+
+                if (check_critical_time == TRUE
+                                && (end_time - start_time) > critical_time) result = STATE_CRITICAL;
+                else if (check_warning_time == TRUE
+                                                 && (end_time - start_time) > warning_time) result =
+                                STATE_WARNING;
+
+                /* Put some HTML in here to create a dynamic link */
+                printf ("REAL %s - %d second response time\n",
+                                                (result == STATE_OK) ? "ok" : "problem",
+                                                (int) (end_time - start_time));
+        }
+        else
+                printf ("%s\n", status_line);
+
+        /* close the connection */
+        close (sd);
+
+        /* reset the alarm */
+        alarm (0);
+
+        return result;
+}
+
+
+
+
+
+
+/* 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");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (server_address == NULL) {
+                        if (is_host (argv[c])) {
+                                server_address = argv[c];
+                        }
+                        else {
+                                usage ("Invalid host name");
+                        }
+                }
+        }
+
+        if (server_expect == NULL)
+                server_expect = strscpy (NULL, EXPECT);
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"IPaddress", required_argument, 0, 'I'},
+                {"expect", required_argument, 0, 'e'},
+                {"url", required_argument, 0, 'u'},
+                {"port", required_argument, 0, 'p'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"timeout", required_argument, 0, 't'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVI:H:e:u:p:w:c:t:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+?hVI:H:e:u:p:w:c:t");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 'I':
+                case 'H':
+                case 'e':
+                case 'u':
+                case 'p':
+                case 'w':
+                case 'c':
+                case 't':
+                        i++;
+                }
+
+                switch (c) {
+                case 'I':                                                                       /* hostname */
+                        if (is_host (optarg)) {
+                                server_address = optarg;
+                        }
+                        else {
+                                usage ("Invalid host name\n");
+                        }
+                        break;
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg)) {
+                                server_address = optarg;
+                        }
+                        else {
+                                usage ("Invalid host name\n");
+                        }
+                        break;
+                case 'e':                                                                       /* string to expect in response header */
+                        server_expect = optarg;
+                        break;
+                case 'u':                                                                       /* string to expect in response header */
+                        server_url = optarg;
+                        break;
+                case 'p':                                                                       /* port */
+                        if (is_intpos (optarg)) {
+                                server_port = atoi (optarg);
+                        }
+                        else {
+                                usage ("Server port must be a positive integer\n");
+                        }
+                        break;
+                case 'w':                                                                       /* warning time threshold */
+                        if (is_intnonneg (optarg)) {
+                                warning_time = atoi (optarg);
+                                check_warning_time = TRUE;
+                        }
+                        else {
+                                usage ("Warning time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'c':                                                                       /* critical time threshold */
+                        if (is_intnonneg (optarg)) {
+                                critical_time = atoi (optarg);
+                                check_critical_time = TRUE;
+                        }
+                        else {
+                                usage ("Critical time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'v':                                                                       /* verbose */
+                        verbose = TRUE;
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (is_intnonneg (optarg)) {
+                                socket_timeout = atoi (optarg);
+                        }
+                        else {
+                                usage ("Time interval must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        return OK;
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Pedro Leite (leite@cic.ua.pt)/Karl DeBisschop\n\n"
+                 "This plugin tests the REAL service on the specified host.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -H, --hostname=STRING or IPADDRESS\n"
+                 "   Check this server on the indicated host\n"
+                 " -I, --IPaddress=STRING or IPADDRESS\n"
+                 "   Check server at this host address\n"
+                 " -p, --port=INTEGER\n"
+                 "   Make connection on the indicated port (default: %d)\n"
+                 " -u, --url=STRING\n"
+                 "   Connect to this url\n"
+                 " -e, --expect=STRING\n"
+                 "   String to expect in first line of server response (default: %s)\n"
+                 " -w, --warning=INTEGER\n"
+                 "   Seconds necessary to result in a warning status\n"
+                 " -c, --critical=INTEGER\n"
+                 "   Seconds necessary to result in a critical status\n"
+                 " -t, --timeout=INTEGER\n"
+                 "   Seconds before connection attempt times out (default: %d)\n"
+                 " -v, --verbose\n"
+                 "   Print extra information (command-line use only)\n"
+                 " -h, --help\n"
+                 "   Print detailed help screen\n"
+                 " -V, --version\n"
+                 "   Print version information\n\n",
+                 PORT, EXPECT, DEFAULT_SOCKET_TIMEOUT);
+        support ();
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H host [-e expect] [-p port] [-w warn] [-c crit]\n"
+                 "            [-t timeout] [-v]\n"
+                 "       %s --help\n"
+                 "       %s --version\n", PROGNAME, PROGNAME, PROGNAME);
+}
+
+
+
+
+/*
+// process command-line arguments 
+int
+process_arguments (int argc, char **argv)
+{
+  int x;
+
+  // no options were supplied 
+  if (argc < 2)
+    return ERROR;
+
+  // first option is always the server name/address 
+  strncpy (server_address, argv[1], sizeof (server_address) - 1);
+  server_address[sizeof (server_address) - 1] = 0;
+
+  // set the host name to the server address (until its overridden) 
+  strcpy (host_name, server_address);
+
+  // process all remaining arguments 
+  for (x = 3; x <= argc; x++)
+    {
+
+      // we got the string to expect from the server 
+      if (!strcmp (argv[x - 1], "-e"))
+        {
+          if (x < argc)
+            {
+              strncpy (server_expect, argv[x], sizeof (server_expect) - 1);
+              server_expect[sizeof (server_expect) - 1] = 0;
+              x++;
+            }
+          else
+            return ERROR;
+        }
+
+      // we got the URL to check 
+      else if (!strcmp (argv[x - 1], "-u"))
+        {
+          if (x < argc)
+            {
+              strncpy (server_url, argv[x], sizeof (server_url) - 1);
+              server_url[sizeof (server_url) - 1] = 0;
+              x++;
+            }
+          else
+            return ERROR;
+        }
+
+      // we go the host name to use in the host header 
+      else if (!strcmp (argv[x - 1], "-hn"))
+        {
+          if (x < argc)
+            {
+              strncpy (host_name, argv[x], sizeof (host_name) - 1);
+              host_name[sizeof (host_name) - 1] = 0;
+              x++;
+            }
+          else
+            return ERROR;
+        }
+
+      // we got the port number to use 
+      else if (!strcmp (argv[x - 1], "-p"))
+        {
+          if (x < argc)
+            {
+              server_port = atoi (argv[x]);
+              x++;
+            }
+          else
+            return ERROR;
+        }
+
+      // we got the socket timeout 
+      else if (!strcmp (argv[x - 1], "-to"))
+        {
+          if (x < argc)
+            {
+              socket_timeout = atoi (argv[x]);
+              if (socket_timeout <= 0)
+                return ERROR;
+              x++;
+            }
+          else
+            return ERROR;
+        }
+
+      // we got the warning threshold time 
+      else if (!strcmp (argv[x - 1], "-wt"))
+        {
+          if (x < argc)
+            {
+              warning_time = atoi (argv[x]);
+              check_warning_time = TRUE;
+              x++;
+            }
+          else
+            return ERROR;
+        }
+
+      // we got the critical threshold time 
+      else if (!strcmp (argv[x - 1], "-ct"))
+        {
+          if (x < argc)
+            {
+              critical_time = atoi (argv[x]);
+              check_critical_time = TRUE;
+              x++;
+            }
+          else
+            return ERROR;
+        }
+
+      // else we got something else... 
+      else
+        return ERROR;
+    }
+
+  return OK;
+}
+
+  result = process_arguments (argc, argv);
+
+  if (result != OK)
+    {
+
+      printf ("Incorrect number of arguments supplied\n");
+      printf ("\n");
+      print_revision(argv[0],"$Revision$");
+      printf ("Copyright (c) 1999 Pedro Leite (leite@cic.ua.pt)\n");
+      printf ("Last Modified: 30-10-1999\n");
+      printf ("License: GPL\n");
+      printf ("\n");
+      printf ("Usage: %s <host_address> [-e expect] [-u url] [-p port] [-hn host_name] [-wt warn_time]\n",argv[0]);
+      printf("        [-ct crit_time] [-to to_sec] [-a auth]\n");
+      printf ("\n");
+      printf ("Options:\n");
+      printf (" [expect]    = String to expect in first line of server response - default is \"%s\"\n", EXPECT);
+      printf (" [url]       = Optional URL to GET - default is root document\n");
+      printf (" [port]      = Optional port number to use - default is %d\n", PORT);
+      printf (" [host_name] = Optional host name argument to GET command - used for servers using host headers\n");
+      printf (" [warn_time] = Response time in seconds necessary to result in a warning status\n");
+      printf (" [crit_time] = Response time in seconds necessary to result in a critical status\n");
+      printf (" [to_sec]    = Number of seconds before connection attempt times out - default is %d seconds\n", DEFAULT_SOCKET_TIMEOUT);
+      printf (" [auth]      = Optional username:password for sites requiring basic authentication\n");
+      printf ("\n");
+      printf ("This plugin attempts to contact the REAL service on the specified host.\n");
+      printf ("If possible, supply an IP address for the host address, as this will bypass the DNS lookup.\n");
+      printf ("\n");
+
+      return STATE_UNKNOWN;
+    }
+
+*/
diff --git a/plugins/check_smtp.c b/plugins/check_smtp.c
new file mode 100644
index 00000000..d57b7841
--- /dev/null
+++ b/plugins/check_smtp.c
@@ -0,0 +1,362 @@
+/******************************************************************************
+*
+* CHECK_SMTP.C
+*
+* Program: SMTP plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+*
+* $Id$
+*
+* Description:
+*
+* This plugin will attempt to open an SMTP connection with the host.
+* Successul connects return STATE_OK, refusals and timeouts return
+* STATE_CRITICAL, other errors return STATE_UNKNOWN.  Successful
+* connects, but incorrect reponse messages from the host result in
+* STATE_WARNING return values.
+*
+* 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 "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define PROGNAME "check_smtp"
+
+#define SMTP_PORT       25
+#define SMTP_EXPECT     "220"
+#define SMTP_QUIT       "QUIT\n"
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+int check_disk (int usp, int free_disk);
+void print_help (void);
+void print_usage (void);
+
+int server_port = SMTP_PORT;
+char *server_address = NULL;
+char *server_expect = NULL;
+int warning_time = 0;
+int check_warning_time = FALSE;
+int critical_time = 0;
+int check_critical_time = FALSE;
+int verbose = FALSE;
+
+int
+main (int argc, char **argv)
+{
+        int sd;
+        int result;
+        char buffer[MAX_INPUT_BUFFER] = "";
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+
+        /* try to connect to the host at the given port number */
+        time (&start_time);
+        result = my_tcp_connect (server_address, server_port, &sd);
+
+        /* we connected, so close connection before exiting */
+        if (result == STATE_OK) {
+
+                /* watch for the SMTP connection string */
+                result = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
+
+                /* strip the buffer of carriage returns */
+                strip (buffer);
+
+                /* return a WARNING status if we couldn't read any data */
+                if (result == -1) {
+                        printf ("recv() failed\n");
+                        result = STATE_WARNING;
+                }
+
+                else {
+
+                        /* make sure we find the response we are looking for */
+                        if (!strstr (buffer, server_expect)) {
+                                if (server_port == SMTP_PORT)
+                                        printf ("Invalid SMTP response received from host\n");
+                                else
+                                        printf ("Invalid SMTP response received from host on port %d\n",
+                                                                        server_port);
+                                result = STATE_WARNING;
+                        }
+
+                        else {
+
+                                time (&end_time);
+
+                                result = STATE_OK;
+
+                                if (check_critical_time == TRUE
+                                                && (end_time - start_time) > critical_time) result =
+                                                STATE_CRITICAL;
+                                else if (check_warning_time == TRUE
+                                                                 && (end_time - start_time) > warning_time) result =
+                                                STATE_WARNING;
+
+                                if (verbose == TRUE)
+                                        printf ("SMTP %s - %d sec. response time, %s\n",
+                                                                        state_text (result), (int) (end_time - start_time), buffer);
+                                else
+                                        printf ("SMTP %s - %d second response time\n", state_text (result),
+                                                                        (int) (end_time - start_time));
+                        }
+                }
+
+                /* close the connection */
+                send (sd, SMTP_QUIT, strlen (SMTP_QUIT), 0);
+                close (sd);
+        }
+
+        /* reset the alarm */
+        alarm (0);
+
+        return result;
+}
+
+
+
+
+
+
+/* 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");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (server_address == NULL) {
+                        if (is_host (argv[c])) {
+                                server_address = argv[c];
+                        }
+                        else {
+                                usage ("Invalid host name");
+                        }
+                }
+        }
+
+        if (server_address == NULL)
+                server_address = strscpy (NULL, "127.0.0.1");
+
+        if (server_expect == NULL)
+                server_expect = strscpy (NULL, SMTP_EXPECT);
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"expect", required_argument, 0, 'e'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"port", required_argument, 0, 'P'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVvt:p:e:c:w:H:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+?hVvt:p:e:c:w:H:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 't':
+                case 'p':
+                case 'e':
+                case 'c':
+                case 'w':
+                case 'H':
+                        i++;
+                }
+
+                switch (c) {
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg)) {
+                                server_address = optarg;
+                        }
+                        else {
+                                usage ("Invalid host name\n");
+                        }
+                        break;
+                case 'p':                                                                       /* port */
+                        if (is_intpos (optarg)) {
+                                server_port = atoi (optarg);
+                        }
+                        else {
+                                usage ("Server port must be a positive integer\n");
+                        }
+                        break;
+                case 'e':                                                                       /* username */
+                        server_expect = optarg;
+                        break;
+                case 'c':                                                                       /* critical time threshold */
+                        if (is_intnonneg (optarg)) {
+                                critical_time = atoi (optarg);
+                                check_critical_time = TRUE;
+                        }
+                        else {
+                                usage ("Critical time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'w':                                                                       /* warning time threshold */
+                        if (is_intnonneg (optarg)) {
+                                warning_time = atoi (optarg);
+                                check_warning_time = TRUE;
+                        }
+                        else {
+                                usage ("Warning time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'v':                                                                       /* verbose */
+                        verbose = TRUE;
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (is_intnonneg (optarg)) {
+                                socket_timeout = atoi (optarg);
+                        }
+                        else {
+                                usage ("Time interval must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        return OK;
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Ethan Galstad/Karl DeBisschop\n\n"
+                 "This plugin test the SMTP service on the specified host.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -H, --hostname=STRING or IPADDRESS\n"
+                 "   Check server on the indicated host\n"
+                 " -p, --port=INTEGER\n"
+                 "   Make connection on the indicated port (default: %d)\n"
+                 " -e, --expect=STRING\n"
+                 "   String to expect in first line of server response (default: %s)\n"
+                 " -w, --warning=INTEGER\n"
+                 "   Seconds necessary to result in a warning status\n"
+                 " -c, --critical=INTEGER\n"
+                 "   Seconds necessary to result in a critical status\n"
+                 " -t, --timeout=INTEGER\n"
+                 "   Seconds before connection attempt times out (default: %d)\n"
+                 " -v, --verbose\n"
+                 "   Print extra information (command-line use only)\n"
+                 " -h, --help\n"
+                 "   Print detailed help screen\n"
+                 " -V, --version\n"
+                 "   Print version information\n\n",
+                 SMTP_PORT, SMTP_EXPECT, DEFAULT_SOCKET_TIMEOUT);
+        support ();
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H host [-e expect] [-p port] [-w warn] [-c crit] [-t timeout] [-v]\n"
+                 "       %s --help\n"
+                 "       %s --version\n", PROGNAME, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_snmp.c b/plugins/check_snmp.c
new file mode 100644
index 00000000..2f970b3d
--- /dev/null
+++ b/plugins/check_snmp.c
@@ -0,0 +1,805 @@
+/******************************************************************************
+ *
+ * CHECK_SNMP.C
+ *
+ * Program: SNMP plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ *
+ * Last Modified: $Date$
+ *
+ * Description:
+ *
+ * This plugin uses the 'snmpget' command included with the UCD-SNMP
+ * package.  If you don't have the package installed you will need to
+ * download it from http://ucd-snmp.ucdavis.edu before you can use
+ * this plugin.
+ *
+ * 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.
+ *./plugins/check_snmp 127.0.0.1 -c public -o .1.3.6.1.4.1.2021.9.1.2.1
+ *****************************************************************************/
+
+#include "common.h"
+#include "utils.h"
+#include "popen.h"
+
+#define PROGNAME check_snmp
+
+#define mark(a) ((a)!=0?"*":"")
+
+#define CHECK_UNDEF 0
+#define CRIT_PRESENT 1
+#define CRIT_STRING 2
+#define CRIT_REGEX 4
+#define CRIT_GT 8
+#define CRIT_LT 16
+#define CRIT_GE 32
+#define CRIT_LE 64
+#define CRIT_EQ 128
+#define CRIT_NE 256
+#define CRIT_RANGE 512
+#define WARN_PRESENT 1024
+#define WARN_STRING 2048
+#define WARN_REGEX 4096
+#define WARN_GT 8192
+#define WARN_LT 16384
+#define WARN_GE 32768
+#define WARN_LE 65536
+#define WARN_EQ 131072
+#define WARN_NE 262144
+#define WARN_RANGE 524288
+
+#define MAX_OIDS 8
+#define MAX_DELIM_LENGTH 8
+#define DEFAULT_DELIMITER "="
+#define DEFAULT_OUTPUT_DELIMITER " "
+
+void print_usage (void);
+void print_help (char *);
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int check_num (int);
+char *clarify_message (char *);
+int lu_getll (unsigned long *, char *);
+int lu_getul (unsigned long *, char *);
+char *thisarg (char *str);
+char *nextarg (char *str);
+
+#ifdef HAVE_REGEX_H
+#include <regex.h>
+char regex_expect[MAX_INPUT_BUFFER] = "";
+regex_t preg;
+regmatch_t pmatch[10];
+char timestamp[10] = "";
+char regex[MAX_INPUT_BUFFER];
+char errbuf[MAX_INPUT_BUFFER];
+int cflags = REG_EXTENDED | REG_NOSUB | REG_NEWLINE;
+int eflags = 0;
+int errcode, excode;
+#endif
+
+char *server_address = NULL;
+char *community = NULL;
+char oid[MAX_INPUT_BUFFER] = "";
+char *label = NULL;
+char *units = NULL;
+char string_value[MAX_INPUT_BUFFER] = "";
+char **labels = NULL;
+char **unitv = NULL;
+int nlabels = 0;
+int labels_size = 8;
+int nunits = 0;
+int unitv_size = 8;
+unsigned long lower_warn_lim[MAX_OIDS];
+unsigned long upper_warn_lim[MAX_OIDS];
+unsigned long lower_crit_lim[MAX_OIDS];
+unsigned long upper_crit_lim[MAX_OIDS];
+unsigned long response_value[MAX_OIDS];
+int check_warning_value = FALSE;
+int check_critical_value = FALSE;
+int eval_method[MAX_OIDS];
+char *delimiter = NULL;
+char *output_delim = NULL;
+
+
+int
+main (int argc, char **argv)
+{
+        int i = 0;
+        int iresult = STATE_UNKNOWN;
+        int found = 0;
+        int result = STATE_DEPENDENT;
+        char input_buffer[MAX_INPUT_BUFFER];
+        char *command_line = NULL;
+        char *response = NULL;
+        char *outbuff = NULL;
+        char *output = NULL;
+        char *ptr = NULL;
+        char *p2 = NULL;
+        char *show = NULL;
+
+        labels = malloc (labels_size);
+        unitv = malloc (unitv_size);
+        outbuff = strscpy (outbuff, "");
+        for (i = 0; i < MAX_OIDS; i++)
+                eval_method[i] = CHECK_UNDEF;
+        i = 0;
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Incorrect arguments supplied\n");
+
+        /* create the command line to execute */
+        command_line = ssprintf
+                (command_line,
+                 "%s -m ALL -v 1 %s %s %s",
+                 PATH_TO_SNMPGET, server_address, community, oid);
+
+        /* run the command */
+        child_process = spopen (command_line);
+        if (child_process == NULL) {
+                printf ("Could not open pipe: %s\n", command_line);
+                exit (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);
+        }
+
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process))
+                output = strscat (output, input_buffer);
+
+        ptr = output;
+
+        while (ptr) {
+
+                ptr = strstr (ptr, delimiter);
+                if (ptr == NULL)
+                        break;
+
+                ptr += strlen (delimiter);
+                ptr += strspn (ptr, " ");
+
+                found++;
+
+                if (ptr[0] == '"') {
+                        ptr++;
+                        response = strpcpy (response, ptr, "\"");
+                        ptr = strpbrk (ptr, "\"");
+                        ptr += strspn (ptr, "\"\n");
+                }
+                else {
+                        response = strpcpy (response, ptr, "\n");
+                        ptr = strpbrk (ptr, "\n");
+                        ptr += strspn (ptr, "\n");
+                        while
+                                (strstr (ptr, delimiter) &&
+                                 strstr (ptr, "\n") && strstr (ptr, "\n") < strstr (ptr, delimiter)) {
+                                response = strpcat (response, ptr, "\n");
+                                ptr = strpbrk (ptr, "\n");
+                        }
+                        if (ptr && strstr (ptr, delimiter) == NULL) {
+                                response = strscat (response, ptr);
+                                ptr = NULL;
+                        }
+                }
+
+                if (strstr (response, "Gauge: "))
+                        show = strstr (response, "Gauge: ") + 7;
+                else if (strstr (response, "Gauge32: "))
+                        show = strstr (response, "Gauge32: ") + 9;
+                else
+                        show = response;
+                p2 = show;
+
+                if (eval_method[i] & CRIT_GT ||
+                                eval_method[i] & CRIT_LT ||
+                                eval_method[i] & CRIT_GE ||
+                                eval_method[i] & CRIT_LE ||
+                                eval_method[i] & CRIT_EQ ||
+                                eval_method[i] & CRIT_NE ||
+                                eval_method[i] & WARN_GT ||
+                                eval_method[i] & WARN_LT ||
+                                eval_method[i] & WARN_GE ||
+                                eval_method[i] & WARN_LE ||
+                                eval_method[i] & WARN_EQ || eval_method[i] & WARN_NE) {
+                        p2 = strpbrk (p2, "0123456789");
+                        response_value[i] = strtoul (p2, NULL, 10);
+                        iresult = check_num (i);
+                        show = ssprintf (show, "%d", response_value[i]);
+                }
+
+                else if (eval_method[i] & CRIT_STRING) {
+                        if (strcmp (response, string_value))
+                                iresult = STATE_CRITICAL;
+                        else
+                                iresult = STATE_OK;
+                }
+
+                else if (eval_method[i] & CRIT_REGEX) {
+#ifdef HAVE_REGEX_H
+                        excode = regexec (&preg, response, 10, pmatch, eflags);
+                        if (excode == 0) {
+                                iresult = STATE_OK;
+                        }
+                        else if (excode != REG_NOMATCH) {
+                                regerror (excode, &preg, errbuf, MAX_INPUT_BUFFER);
+                                printf ("Execute Error: %s\n", errbuf);
+                                exit (STATE_CRITICAL);
+                        }
+                        else {
+                                iresult = STATE_CRITICAL;
+                        }
+#else
+                        printf ("SNMP UNKNOWN: call for regex which was not a compiled option");
+                        exit (STATE_UNKNOWN);
+#endif
+                }
+
+                else {
+                        if (response)
+                                iresult = STATE_OK;
+                        else if (eval_method[i] & CRIT_PRESENT)
+                                iresult = STATE_CRITICAL;
+                        else
+                                iresult = STATE_WARNING;
+                }
+
+                result = max (result, iresult);
+
+                if (nlabels > 1 && i < nlabels && labels[i] != NULL)
+                        outbuff = ssprintf
+                                (outbuff,
+                                 "%s%s%s %s%s%s",
+                                 outbuff,
+                                 (i == 0) ? " " : output_delim,
+                                 labels[i], mark (iresult), show, mark (iresult));
+                else
+                        outbuff = ssprintf
+                                (outbuff,
+                                 "%s%s%s%s%s",
+                                 outbuff,
+                                 (i == 0) ? " " : output_delim, mark (iresult), show, mark (iresult));
+
+                if (nunits > 0 && i < nunits)
+                        outbuff = ssprintf (outbuff, "%s %s", outbuff, unitv[i]);
+
+                i++;
+
+        }                                                                                                                       /* end while */
+
+        if (found == 0)
+                terminate
+                        (STATE_UNKNOWN,
+                         "%s problem - No data recieved from host\nCMD: %s\n",
+                         label, command_line);
+
+        /* WARNING if output found on stderr */
+        if (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
+                result = max (result, STATE_WARNING);
+
+        /* close stderr */
+        (void) fclose (child_stderr);
+
+        /* close the pipe */
+        if (spclose (child_process))
+                result = max (result, STATE_WARNING);
+
+        if (nunits > 0)
+                printf ("%s %s -%s\n", label, state_text (result), outbuff);
+        else
+                printf ("%s %s -%s %s\n", label, state_text (result), outbuff, units);
+
+        return result;
+}
+
+/* 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");
+                if (strcmp ("-wv", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                if (strcmp ("-cv", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+        c = 0;
+        while (c += (call_getopt (argc - c, &argv[c]))) {
+                if (argc <= c)
+                        break;
+                if (server_address == NULL)
+                        server_address = strscpy (NULL, argv[c]);
+        }
+
+        if (community == NULL)
+                community = strscpy (NULL, "public");
+
+        if (delimiter == NULL)
+                delimiter = strscpy (NULL, DEFAULT_DELIMITER);
+
+        if (output_delim == NULL)
+                output_delim = strscpy (NULL, DEFAULT_OUTPUT_DELIMITER);
+
+        if (label == NULL)
+                label = strscpy (NULL, "SNMP");
+
+        if (units == NULL)
+                units = strscpy (NULL, "");
+
+        return c;
+}
+
+int
+call_getopt (int argc, char **argv)
+{
+        char *ptr;
+        int c, i = 1;
+        int j = 0, jj = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"help", no_argument, 0, 'h'},
+                {"version", no_argument, 0, 'V'},
+                {"timeout", required_argument, 0, 't'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"hostname", required_argument, 0, 'H'},
+                {"community", required_argument, 0, 'C'},
+                {"oid", required_argument, 0, 'o'},
+                {"object", required_argument, 0, 'o'},
+                {"delimiter", required_argument, 0, 'd'},
+                {"output-delimiter", required_argument, 0, 'D'},
+                {"string", required_argument, 0, 's'},
+                {"regex", required_argument, 0, 'r'},
+                {"ereg", required_argument, 0, 'r'},
+                {"eregi", required_argument, 0, 'R'},
+                {"label", required_argument, 0, 'l'},
+                {"units", required_argument, 0, 'u'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+?hVt:c:w:H:C:o:d:D:s:R:r:l:u:",
+                                                                         long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+?hVt:c:w:H:C:o:d:D:s:R:r:l:u:");
+#endif
+
+                if (c == -1 || c == EOF)
+                        break;
+
+                i++;
+                switch (c) {
+                case 't':
+                case 'c':
+                case 'w':
+                case 'H':
+                case 'C':
+                case 'o':
+                case 'd':
+                case 'D':
+                case 's':
+                case 'R':
+                case 'r':
+                case 'l':
+                case 'u':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* help */
+                        printf ("%s: Unknown argument: %s\n\n", my_basename (argv[0]), optarg);
+                        print_usage ();
+                        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$");
+                        exit (STATE_OK);
+                case 't':                                                                       /* timeout period */
+                        if (!is_integer (optarg)) {
+                                printf ("%s: Timeout Interval must be an integer!\n\n",
+                                                                my_basename (argv[0]));
+                                print_usage ();
+                                exit (STATE_UNKNOWN);
+                        }
+                        timeout_interval = atoi (optarg);
+                        break;
+                case 'c':                                                                       /* critical time threshold */
+                        if (strspn (optarg, "0123456789:,") < strlen (optarg)) {
+                                printf ("Invalid critical threshold: %s\n", optarg);
+                                print_usage ();
+                                exit (STATE_UNKNOWN);
+                        }
+                        for (ptr = optarg, jj = 0; ptr && jj < MAX_OIDS; jj++) {
+                                if (lu_getll (&lower_crit_lim[jj], ptr) == 1)
+                                        eval_method[jj] |= CRIT_LT;
+                                if (lu_getul (&upper_crit_lim[jj], ptr) == 1)
+                                        eval_method[jj] |= CRIT_GT;
+                                (ptr = index (ptr, ',')) ? ptr++ : ptr;
+                        }
+                        break;
+                case 'w':                                                                       /* warning time threshold */
+                        if (strspn (optarg, "0123456789:,") < strlen (optarg)) {
+                                printf ("Invalid warning threshold: %s\n", optarg);
+                                print_usage ();
+                                exit (STATE_UNKNOWN);
+                        }
+                        for (ptr = optarg, jj = 0; ptr && jj < MAX_OIDS; jj++) {
+                                if (lu_getll (&lower_warn_lim[jj], ptr) == 1)
+                                        eval_method[jj] |= WARN_LT;
+                                if (lu_getul (&upper_warn_lim[jj], ptr) == 1)
+                                        eval_method[jj] |= WARN_GT;
+                                (ptr = index (ptr, ',')) ? ptr++ : ptr;
+                        }
+                        break;
+                case 'H':                                                                       /* Host or server */
+                        server_address = strscpy (server_address, optarg);
+                        break;
+                case 'C':                                                                       /* group or community */
+                        community = strscpy (community, optarg);
+                        break;
+                case 'o':                                                                       /* object identifier */
+                        for (ptr = optarg; (ptr = index (ptr, ',')); ptr++)
+                                ptr[0] = ' ';
+                        strncpy (oid, optarg, sizeof (oid) - 1);
+                        oid[sizeof (oid) - 1] = 0;
+                        for (ptr = optarg, j = 1; (ptr = index (ptr, ' ')); ptr++)
+                                j++;
+                        break;
+                case 'd':                                                                       /* delimiter */
+                        delimiter = strscpy (delimiter, optarg);
+                        break;
+                case 'D':                                                                       /* output-delimiter */
+                        output_delim = strscpy (output_delim, optarg);
+                        break;
+                case 's':                                                                       /* string or substring */
+                        strncpy (string_value, optarg, sizeof (string_value) - 1);
+                        string_value[sizeof (string_value) - 1] = 0;
+                        eval_method[jj++] = CRIT_STRING;
+                        break;
+                case 'R':                                                                       /* regex */
+#ifdef HAVE_REGEX_H
+                        cflags = REG_ICASE;
+#endif
+                case 'r':                                                                       /* regex */
+#ifdef HAVE_REGEX_H
+                        cflags |= REG_EXTENDED | REG_NOSUB | REG_NEWLINE;
+                        strncpy (regex_expect, optarg, sizeof (regex_expect) - 1);
+                        regex_expect[sizeof (regex_expect) - 1] = 0;
+                        errcode = regcomp (&preg, regex_expect, cflags);
+                        if (errcode != 0) {
+                                regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
+                                printf ("Could Not Compile Regular Expression");
+                                return ERROR;
+                        }
+                        eval_method[jj++] = CRIT_REGEX;
+#else
+                        printf ("SNMP UNKNOWN: call for regex which was not a compiled option");
+                        exit (STATE_UNKNOWN);
+#endif
+                        break;
+                case 'l':                                                                       /* label */
+                        label = optarg;
+                        nlabels++;
+                        if (nlabels >= labels_size) {
+                                labels_size += 8;
+                                labels = realloc (labels, labels_size);
+                                if (labels == NULL)
+                                        terminate (STATE_UNKNOWN,
+                                                                                 "Could not realloc() labels[%d]", nlabels);
+                        }
+                        labels[nlabels - 1] = optarg;
+                        ptr = thisarg (optarg);
+                        if (strstr (ptr, "'") == ptr)
+                                labels[nlabels - 1] = ptr + 1;
+                        else
+                                labels[nlabels - 1] = ptr;
+                        while (ptr && (ptr = nextarg (ptr))) {
+                                if (nlabels >= labels_size) {
+                                        labels_size += 8;
+                                        labels = realloc (labels, labels_size);
+                                        if (labels == NULL)
+                                                terminate (STATE_UNKNOWN, "Could not realloc() labels\n");
+                                }
+                                labels++;
+                                ptr = thisarg (ptr);
+                                if (strstr (ptr, "'") == ptr)
+                                        labels[nlabels - 1] = ptr + 1;
+                                else
+                                        labels[nlabels - 1] = ptr;
+                        }
+                        break;
+                case 'u':                                                                       /* units */
+                        units = optarg;
+                        nunits++;
+                        if (nunits >= unitv_size) {
+                                unitv_size += 8;
+                                unitv = realloc (unitv, unitv_size);
+                                if (unitv == NULL)
+                                        terminate (STATE_UNKNOWN,
+                                                                                 "Could not realloc() units [%d]\n", nunits);
+                        }
+                        unitv[nunits - 1] = optarg;
+                        ptr = thisarg (optarg);
+                        if (strstr (ptr, "'") == ptr)
+                                unitv[nunits - 1] = ptr + 1;
+                        else
+                                unitv[nunits - 1] = ptr;
+                        while (ptr && (ptr = nextarg (ptr))) {
+                                if (nunits >= unitv_size) {
+                                        unitv_size += 8;
+                                        unitv = realloc (unitv, unitv_size);
+                                        if (units == NULL)
+                                                terminate (STATE_UNKNOWN, "Could not realloc() units\n");
+                                }
+                                nunits++;
+                                ptr = thisarg (ptr);
+                                if (strstr (ptr, "'") == ptr)
+                                        unitv[nunits - 1] = ptr + 1;
+                                else
+                                        unitv[nunits - 1] = ptr;
+                        }
+                        break;
+                }
+        }
+        return i;
+}
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: check_snmp -H <ip_address> -o <OID> [-w warn_range] [-c crit_range] \n"
+                 "                  [-C community] [-s string] [-r regex] [-R regexi] [-t timeout]\n"
+                 "                  [-l label] [-u units] [-d delimiter] [-D output-delimiter]\n"
+                 "       check_snmp --help\n" "       check_snmp --version\n");
+}
+
+void
+print_help (char *cmd)
+{
+        printf ("Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)\n"
+                                        "License: GPL\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -h, --help\n"
+                 "    Print detailed help screen\n"
+                 " -V, --version\n"
+                 "    Print version information\n"
+                 " -H, --hostname=HOST\n"
+                 "    Name or IP address of the device you wish to query\n"
+                 " -o, --oid=OID(s)\n"
+                 "    Object identifier(s) whose value you wish to query\n"
+                 " -w, --warning=INTEGER_RANGE(s)\n"
+                 "    Range(s) which will not result in a WARNING status\n"
+                 " -c, --critical=INTEGER_RANGE(s)\n"
+                 "    Range(s) which will not result in a CRITICAL status\n"
+                 " -C, --community=STRING\n"
+                 "    Optional community string for SNMP communication\n"
+                 "    (default is \"public\")\n"
+                 " -u, --units=STRING\n"
+                 "    Units label(s) for output data (e.g., 'sec.').\n"
+                 " -d, --delimiter=STRING\n"
+                 "    Delimiter to use when parsing returned data. Default is \"%s\"\n"
+                 "    Any data on the right hand side of the delimiter is considered\n"
+                 "    to be the data that should be used in the evaluation.\n"
+                 " -t, --timeout=INTEGER\n"
+                 "    Seconds to wait before plugin times out (see also nagios server timeout)\n"
+                 " -D, --output-delimiter=STRING\n"
+                 "    Separates output on multiple OID requests\n"
+                 " -s, --string=STRING\n"
+                 "    Return OK state (for that OID) if STRING is an exact match\n"
+                 " -r, --ereg=REGEX\n"
+                 "    Return OK state (for that OID) if extended regular expression REGEX matches\n"
+                 " -R, --eregi=REGEX\n"
+                 "    Return OK state (for that OID) if case-insensitive extended REGEX matches\n"
+                 " -l, --label=STRING\n"
+                 "    Prefix label for output from plugin (default -s 'SNMP')\n\n"
+                 "- This plugin uses the 'snmpget' command included with the UCD-SNMP package.\n"
+                 "  If you don't have the package installed, you will need to download it from\n"
+                 "  http://ucd-snmp.ucdavis.edu before you can use this plugin.\n"
+                 "- Multiple OIDs may be indicated by a comma- or space-delimited list (lists with\n"
+                 "  internal spaces must be quoted)\n"
+                 "- Ranges are inclusive and are indicated with colons. When specified as\n"
+                 "  'min:max' a STATE_OK will be returned if the result is within the indicated\n"
+                 "  range or is equal to the upper or lower bound. A non-OK state will be\n"
+                 "  returned if the result is outside the specified range.\n"
+                 "- If spcified in the order 'max:min' a non-OK state will be returned if the\n"
+                 "  result is within the (inclusive) range.\n"
+                 "- Upper or lower bounds may be omitted to skip checking the respective limit.\n"
+                 "- Bare integers are interpreted as upper limits.\n"
+                 "- When checking multiple OIDs, separate ranges by commas like '-w 1:10,1:,:20'\n"
+                 "- Note that only one string and one regex may be checked at present\n"
+                 "- All evaluation methods other than PR, STR, and SUBSTR expect that the value\n"
+                 "  returned from the SNMP query is an unsigned integer.\n\n",
+                 DEFAULT_DELIMITER);
+}
+
+char *
+clarify_message (char *msg)
+{
+        int i = 0;
+        int foo;
+        char tmpmsg_c[MAX_INPUT_BUFFER];
+        char *tmpmsg = (char *) &tmpmsg_c;
+        tmpmsg = strcpy (tmpmsg, msg);
+        if (!strncmp (tmpmsg, " Hex:", 5)) {
+                tmpmsg = strtok (tmpmsg, ":");
+                while ((tmpmsg = strtok (NULL, " "))) {
+                        foo = strtol (tmpmsg, NULL, 16);
+                        /* Translate chars that are not the same value in the printers
+                         * character set.
+                         */
+                        switch (foo) {
+                        case 208:
+                                {
+                                        foo = 197;
+                                        break;
+                                }
+                        case 216:
+                                {
+                                        foo = 196;
+                                        break;
+                                }
+                        }
+                        msg[i] = foo;
+                        i++;
+                }
+                msg[i] = 0;
+        }
+        return (msg);
+}
+
+
+int
+check_num (int i)
+{
+        int result;
+        result = STATE_OK;
+        if (eval_method[i] & WARN_GT && eval_method[i] & WARN_LT &&
+                        lower_warn_lim[i] > upper_warn_lim[i]) {
+                if (response_value[i] <= lower_warn_lim[i] &&
+                                response_value[i] >= upper_warn_lim[i]) {
+                        result = STATE_WARNING;
+                }
+        }
+        else if
+                ((eval_method[i] & WARN_GT && response_value[i] > upper_warn_lim[i]) ||
+                 (eval_method[i] & WARN_GE && response_value[i] >= upper_warn_lim[i]) ||
+                 (eval_method[i] & WARN_LT && response_value[i] < lower_warn_lim[i]) ||
+                 (eval_method[i] & WARN_LE && response_value[i] <= lower_warn_lim[i]) ||
+                 (eval_method[i] & WARN_EQ && response_value[i] == upper_warn_lim[i]) ||
+                 (eval_method[i] & WARN_NE && response_value[i] != upper_warn_lim[i])) {
+                result = STATE_WARNING;
+        }
+
+        if (eval_method[i] & CRIT_GT && eval_method[i] & CRIT_LT &&
+                        lower_warn_lim[i] > upper_warn_lim[i]) {
+                if (response_value[i] <= lower_crit_lim[i] &&
+                                response_value[i] >= upper_crit_lim[i]) {
+                        result = STATE_CRITICAL;
+                }
+        }
+        else if
+                ((eval_method[i] & CRIT_GT && response_value[i] > upper_crit_lim[i]) ||
+                 (eval_method[i] & CRIT_GE && response_value[i] >= upper_crit_lim[i]) ||
+                 (eval_method[i] & CRIT_LT && response_value[i] < lower_crit_lim[i]) ||
+                 (eval_method[i] & CRIT_LE && response_value[i] <= lower_crit_lim[i]) ||
+                 (eval_method[i] & CRIT_EQ && response_value[i] == upper_crit_lim[i]) ||
+                 (eval_method[i] & CRIT_NE && response_value[i] != upper_crit_lim[i])) {
+                result = STATE_CRITICAL;
+        }
+
+        return result;
+}
+
+
+int
+lu_getll (unsigned long *ll, char *str)
+{
+        char tmp[100];
+        if (strchr (str, ':') == NULL)
+                return 0;
+        if (strchr (str, ',') != NULL && (strchr (str, ',') < strchr (str, ':')))
+                return 0;
+        if (sscanf (str, "%lu%[:]", ll, tmp) == 2)
+                return 1;
+        return 0;
+}
+
+int
+lu_getul (unsigned long *ul, char *str)
+{
+        char tmp[100];
+        if (sscanf (str, "%lu%[^,]", ul, tmp) == 1)
+                return 1;
+        if (sscanf (str, ":%lu%[^,]", ul, tmp) == 1)
+                return 1;
+        if (sscanf (str, "%*u:%lu%[^,]", ul, tmp) == 1)
+                return 1;
+        return 0;
+}
+
+
+
+
+
+
+/* trim leading whitespace
+         if there is a leading quote, make sure it balances */
+
+char *
+thisarg (char *str)
+{
+        str += strspn (str, " \t\r\n"); /* trim any leading whitespace */
+        if (strstr (str, "'") == str) { /* handle SIMPLE quoted strings */
+                if (strlen (str) == 1 || !strstr (str + 1, "'"))
+                        terminate (STATE_UNKNOWN, "Unbalanced quotes\n");
+        }
+        return str;
+}
+
+
+/* if there's a leading quote, advance to the trailing quote
+         set the trailing quote to '\x0'
+         if the string continues, advance beyond the comma */
+
+char *
+nextarg (char *str)
+{
+        if (strstr (str, "'") == str) {
+                if (strlen (str) > 1) {
+                        str = strstr (str + 1, "'");
+                        str[0] = 0;
+                        return (++str);
+                }
+                else {
+                        str[0] = 0;
+                        return NULL;
+                }
+        }
+        if (strstr (str, ",") == str) {
+                if (strlen (str) > 1) {
+                        str[0] = 0;
+                        return (++str);
+                }
+                else {
+                        str[0] = 0;
+                        return NULL;
+                }
+        }
+        if ((str = strstr (str, ",")) && strlen (str) > 1) {
+                str[0] = 0;
+                return (++str);
+        }
+        return NULL;
+}
diff --git a/plugins/check_ssh.c b/plugins/check_ssh.c
new file mode 100644
index 00000000..d78189fc
--- /dev/null
+++ b/plugins/check_ssh.c
@@ -0,0 +1,285 @@
+/*
+* check_ssh.c
+* 
+* Made by (Remi PAULMIER)
+* Login   <remi@sinfomic.fr>
+* 
+* Started on  Fri Jul  9 09:18:23 1999 Remi PAULMIER
+* Update Thu Jul 22 12:50:04 1999 remi paulmier
+* $Id$
+*
+*/
+
+#include "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define PROGNAME "check_ssh"
+
+#ifndef MSG_DONTWAIT
+#define MSG_DONTWAIT 0
+#endif
+
+#define SSH_DFL_PORT    22
+#define BUFF_SZ         256
+
+short port = -1;
+char *server_name = NULL;
+int verbose = FALSE;
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+void print_help (void);
+void print_usage (void);
+
+char *ssh_resolve (char *hostname);
+int ssh_connect (char *haddr, short hport);
+
+int
+main (int argc, char **argv)
+{
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+        alarm (socket_timeout);
+
+        /* ssh_connect exits if error is found */
+        ssh_connect (ssh_resolve (server_name), port);
+
+        alarm (0);
+
+        return (STATE_OK);
+}
+
+
+/* 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 (server_name == NULL) {
+                        server_name = argv[c];
+                }
+                else if (port == -1) {
+                        if (is_intpos (argv[c])) {
+                                port = atoi (argv[c]);
+                        }
+                        else {
+                                print_usage ();
+                                exit (STATE_UNKNOWN);
+                        }
+                }
+        }
+
+        return validate_arguments ();
+}
+
+
+/************************************************************************
+*
+* Run the getopt until we encounter a non-option entry in the arglist
+*
+*-----------------------------------------------------------------------*/
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 1;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {"verbose", no_argument, 0, 'v'},
+                {"timeout", required_argument, 0, 't'},
+                {"host", required_argument, 0, 'H'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c = getopt_long (argc, argv, "+Vhvt:H:p:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+Vhvt:H:p:");
+#endif
+
+                if (c == -1 || c == EOF)
+                        break;
+
+                i++;
+                switch (c) {
+                case 't':
+                case 'H':
+                case 'p':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* help */
+                        usage ("");
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'v':                                                                       /* verose */
+                        verbose = TRUE;
+                        break;
+                case 't':                                                                       /* timeout period */
+                        if (!is_integer (optarg))
+                                usage ("Timeout Interval must be an integer!\n\n");
+                        socket_timeout = atoi (optarg);
+                        break;
+                case 'H':                                                                       /* host */
+                        server_name = optarg;
+                        break;
+                case 'p':                                                                       /* port */
+                        if (is_intpos (optarg)) {
+                                port = atoi (optarg);
+                        }
+                        else {
+                                printf ("Port number nust be a positive integer: %s\n", optarg);
+                                usage ("");
+                        }
+                }
+
+        }
+        return i;
+}
+
+int
+validate_arguments (void)
+{
+        if (server_name == NULL)
+                return ERROR;
+        if (port == -1)                                                         /* funky, but allows -p to override stray integer in args */
+                port = SSH_DFL_PORT;
+        return OK;
+}
+
+
+/************************************************************************
+*
+* Resolve hostname into IP address
+*
+*-----------------------------------------------------------------------*/
+
+char *
+ssh_resolve (char *hostname)
+{
+        struct hostent *host;
+
+        host = gethostbyname (hostname);
+        if (!host) {
+                herror (hostname);
+                exit (STATE_CRITICAL);
+        }
+        return (host->h_addr);
+}
+
+
+/************************************************************************
+*
+* Try to connect to SSH server at specified server and port
+*
+*-----------------------------------------------------------------------*/
+
+int
+ssh_connect (char *haddr, short hport)
+{
+        int s;
+        struct sockaddr_in addr;
+        int addrlen;
+        int len;
+        char *output = NULL;
+        char *buffer = NULL;
+        char *ssh_proto = NULL;
+        char *ssh_server = NULL;
+        char revision[20];
+
+        sscanf ("$Revision$", "$Revision: %[0123456789.]", revision);
+
+        addrlen = sizeof (addr);
+        memset (&addr, 0, addrlen);
+        addr.sin_port = htons (hport);
+        addr.sin_family = AF_INET;
+        bcopy (haddr, (void *) &addr.sin_addr.s_addr, 4);
+
+        s = socket (AF_INET, SOCK_STREAM, 0);
+        if (!s) {
+                printf ("socket(): %s for %s:%d\n", strerror (errno), server_name, hport);
+                exit (STATE_CRITICAL);
+        }
+
+        if (connect (s, (struct sockaddr *) &addr, addrlen)) {
+                printf ("connect(): %s for %s:%d\n", strerror (errno), server_name,
+                                                hport);
+                exit (STATE_CRITICAL);
+        }
+
+        output = (char *) malloc (BUFF_SZ + 1);
+        memset (output, 0, BUFF_SZ + 1);
+        recv (s, output, BUFF_SZ, 0);
+        if (strncmp (output, "SSH", 3)) {
+                printf ("Server answer: %s", output);
+                exit (STATE_CRITICAL);
+        }
+        else {
+                strip (output);
+                if (verbose)
+                        printf ("%s\n", output);
+                ssh_proto = output + 4;
+                ssh_server = ssh_proto + strspn (ssh_proto, "0123456789-. ");
+                ssh_proto[strspn (ssh_proto, "0123456789-. ")] = 0;
+                printf
+                        ("SSH ok - protocol version %s - server version %s\n",
+                         ssh_proto, ssh_server);
+                buffer =
+                        ssprintf (buffer, "SSH-%s-check_ssh_%s\r\n", ssh_proto, revision);
+                send (s, buffer, strlen (buffer), MSG_DONTWAIT);
+                if (verbose)
+                        printf ("%s\n", buffer);
+                exit (STATE_OK);
+        }
+}
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf ("Copyright (c) 1999 Remi Paulmier (remi@sinfomic.fr)\n\n");
+        print_usage ();
+        printf ("by default, port is %d\n", SSH_DFL_PORT);
+}
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage:\n"
+                 " %s -t [timeout] -p [port] <host>\n"
+                 " %s -V prints version info\n"
+                 " %s -h prints more detailed help\n", PROGNAME, PROGNAME, PROGNAME);
+}
+
+/* end of check_ssh.c */
diff --git a/plugins/check_swap.c b/plugins/check_swap.c
new file mode 100644
index 00000000..d225e1dc
--- /dev/null
+++ b/plugins/check_swap.c
@@ -0,0 +1,325 @@
+/******************************************************************************
+*
+* CHECK_SWAP.C
+*
+* Program: Process plugin for Nagios
+* License: GPL
+* Copyright (c) 2000 Karl DeBisschop (kdebisschop@users.sourceforge.net)
+*
+* $Id$
+*
+******************************************************************************/
+
+#include "common.h"
+#include "popen.h"
+#include "utils.h"
+
+#define PROGNAME "check_swap"
+
+int process_arguments (int argc, char **argv);
+int call_getopt (int argc, char **argv);
+int validate_arguments (void);
+void print_usage (void);
+void print_help (void);
+
+int warn_percent = 200, crit_percent = 200, warn_size = -1, crit_size = -1;
+
+int
+main (int argc, char **argv)
+{
+        int total_swap, used_swap, free_swap, percent_used;
+        int result = STATE_OK;
+        char input_buffer[MAX_INPUT_BUFFER];
+#ifdef HAVE_SWAP
+        char *temp_buffer;
+#endif
+#ifdef HAVE_PROC_MEMINFO
+        FILE *fp;
+#endif
+        char str[32];
+        char *status = NULL;
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+#ifdef HAVE_PROC_MEMINFO
+        fp = fopen (PROC_MEMINFO, "r");
+        status = ssprintf (status, "%s", "Swap used:");
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
+                sscanf (input_buffer, " %s %d %d %d", str, &total_swap, &used_swap,
+                                                &free_swap);
+                if (strstr (str, "Swap")) {
+                        percent_used = 100 * (((float) used_swap) / ((float) total_swap));
+                        status = ssprintf
+                                (status,
+                                 "%s %2d%% (%d bytes out of %d)",
+                                 status, percent_used, used_swap, total_swap);
+                        if (percent_used >= crit_percent || free_swap <= crit_size)
+                                result = STATE_CRITICAL;
+                        else if (percent_used >= warn_percent || free_swap <= warn_size)
+                                result = STATE_WARNING;
+                        break;
+                }
+        }
+        fclose (fp);
+#else
+#ifdef HAVE_SWAP
+        child_process = spopen (SWAP_COMMAND);
+        if (child_process == NULL) {
+                printf ("Could not open pipe: %s\n", SWAP_COMMAND);
+                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", SWAP_COMMAND);
+
+        sprintf (str, "%s", "");
+        /* read 1st line */
+        fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process);
+        if (strcmp (SWAP_FORMAT, "") == 0) {
+                temp_buffer = strtok (input_buffer, " \n");
+                while (temp_buffer) {
+                        if (strstr (temp_buffer, "blocks"))
+                                sprintf (str, "%s %s", str, "%f");
+                        else if (strstr (temp_buffer, "free"))
+                                sprintf (str, "%s %s", str, "%f");
+                        else
+                                sprintf (str, "%s %s", str, "%*s");
+                        temp_buffer = strtok (NULL, " \n");
+                }
+        }
+
+        status = ssprintf (status, "%s", "Swap used:");
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+                sscanf (input_buffer, SWAP_FORMAT, &total_swap, &free_swap);
+                used_swap = total_swap - free_swap;
+                percent_used = 100 * ((float) used_swap) / ((float) total_swap);
+                status = ssprintf
+                        (status,
+                         "%s %2d%% (%d bytes out of %d)",
+                         status, percent_used, used_swap, total_swap);
+                if (percent_used >= crit_percent || free_swap <= crit_size)
+                        result = STATE_CRITICAL;
+                else if (percent_used >= warn_percent || free_swap <= warn_size)
+                        result = STATE_WARNING;
+        }
+
+        /* If we get anything on STDERR, at least set warning */
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
+                result = max (result, STATE_WARNING);
+
+        /* close stderr */
+        (void) fclose (child_stderr);
+
+        /* close the pipe */
+        if (spclose (child_process))
+                result = max (result, STATE_WARNING);
+#endif
+#endif
+
+#ifndef SWAP_COMMAND
+#ifndef SWAP_FILE
+#ifndef HAVE_PROC_MEMINFO
+        return STATE_UNKNOWN;
+#endif
+#endif
+#endif
+
+        if (result == STATE_OK)
+                printf ("Swap ok - %s\n", status);
+        else if (result == STATE_CRITICAL)
+                printf ("CRITICAL - %s\n", status);
+        else if (result == STATE_WARNING)
+                printf ("WARNING - %s\n", status);
+        else if (result == STATE_UNKNOWN)
+                printf ("Unable to read output\n");
+        else {
+                result = STATE_UNKNOWN;
+                printf ("UNKNOWN - %s\n", status);
+        }
+
+        return result;
+}
+
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+        if (argc < 2)
+                return ERROR;
+
+        c = 0;
+        while (c += (call_getopt (argc - c, &argv[c]))) {
+                if (argc <= c)
+                        break;
+
+                if (warn_percent > 100 && is_intnonneg (argv[c]))
+                        warn_percent = atoi (argv[c]);
+                else if (crit_percent > 100 && is_intnonneg (argv[c]))
+                        crit_percent = atoi (argv[c]);
+                else if (warn_size < 0 && is_intnonneg (argv[c]))
+                        warn_size = atoi (argv[c]);
+                else if (crit_size < 0 && is_intnonneg (argv[c]))
+                        crit_size = atoi (argv[c]);
+        }
+
+        return validate_arguments ();
+}
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"warning", required_argument, 0, 'w'},
+                {"critical", required_argument, 0, 'c'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c = getopt_long (argc, argv, "+?Vhc:w:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+?Vhc:w:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF)
+                        break;
+
+                switch (c) {
+                case 'c':
+                case 'w':
+                        i++;
+                }
+
+                switch (c) {
+                case 'w':                                                                       /* warning time threshold */
+                        if (is_intnonneg (optarg)) {
+                                warn_size = atoi (optarg);
+                                break;
+                        }
+                        else if (strstr (optarg, ",") &&
+                                                         strstr (optarg, "%") &&
+                                                         sscanf (optarg, "%d,%d%%", &warn_size, &warn_percent) == 2) {
+                                break;
+                        }
+                        else if (strstr (optarg, "%") &&
+                                                         sscanf (optarg, "%d%%", &warn_percent) == 1) {
+                                break;
+                        }
+                        else {
+                                usage ("Warning threshold must be integer or percentage!\n");
+                        }
+                case 'c':                                                                       /* critical time threshold */
+                        if (is_intnonneg (optarg)) {
+                                crit_size = atoi (optarg);
+                                break;
+                        }
+                        else if (strstr (optarg, ",") &&
+                                                         strstr (optarg, "%") &&
+                                                         sscanf (optarg, "%d,%d%%", &crit_size, &crit_percent) == 2) {
+                                break;
+                        }
+                        else if (strstr (optarg, "%") &&
+                                                         sscanf (optarg, "%d%%", &crit_percent) == 1) {
+                                break;
+                        }
+                        else {
+                                usage ("Critical threshold must be integer or percentage!\n");
+                        }
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        if (warn_percent > 100 && crit_percent > 100 && warn_size < 0
+                        && crit_size < 0) {
+                return ERROR;
+        }
+        else if (warn_percent > crit_percent) {
+                usage
+                        ("Warning percentage should not be less than critical percentage\n");
+        }
+        else if (warn_size < crit_size) {
+                usage
+                        ("Warning free space should not be more than critical free space\n");
+        }
+        return OK;
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: check_swap -w <used_percentage>%% -c <used_percentage>%%\n"
+                 "       check_swap -w <bytes_free> -c <bytes_free>\n"
+                 "       check_swap (-V|--version)\n" "       check_swap (-h|--help)\n");
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Karl DeBisschop\n\n"
+                 "This plugin will check all of the swap partitions and return an\n"
+                 "error if the the avalable swap space is less than specified.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -w, --warning=INTEGER\n"
+                 "   Exit with WARNING status if less than INTEGER bytes of swap space are free\n"
+                 " -w, --warning=PERCENT%%\n"
+                 "   Exit with WARNING status if more than PERCENT of swap space has been used\n"
+                 " -c, --critical=INTEGER\n"
+                 "   Exit with CRITICAL status if less than INTEGER bytes of swap space are free\n"
+                 " -c, --critical=PERCENT%%\n"
+                 "   Exit with CRITCAL status if more than PERCENT of swap space has been used\n"
+                 " -h, --help\n"
+                 "    Print detailed help screen\n"
+                 " -V, --version\n" "    Print version information\n\n");
+        support ();
+}
diff --git a/plugins/check_tcp.c b/plugins/check_tcp.c
new file mode 100644
index 00000000..bef0e752
--- /dev/null
+++ b/plugins/check_tcp.c
@@ -0,0 +1,563 @@
+/******************************************************************************
+ *
+ * This file is part of the Nagios Plugins.
+ *
+ * Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>
+ *
+ * The Nagios Plugins are free software; you can redistribute them
+ * and/or modify them 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.
+ *
+ * $Id$
+ *
+ *****************************************************************************/
+
+#define PROGRAM check_tcp
+#define DESCRIPTION "Check a TCP port"
+#define AUTHOR "Ethan Galstad"
+#define EMAIL "nagios@nagios.org"
+#define COPYRIGHTDATE "1999"
+
+#include "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#ifdef HAVE_SSL_H
+#include <rsa.h>
+#include <crypto.h>
+#include <x509.h>
+#include <pem.h>
+#include <ssl.h>
+#include <err.h>
+#endif
+
+#ifdef HAVE_OPENSSL_SSL_H
+#include <openssl/rsa.h>
+#include <openssl/crypto.h>
+#include <openssl/x509.h>
+#include <openssl/pem.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#endif
+
+#ifdef HAVE_SSL
+SSL_CTX *ctx;
+SSL *ssl;
+int connect_SSL (void);
+#endif
+
+#define TCP_PROTOCOL 1
+#define UDP_PROTOCOL 2
+
+int process_arguments (int, char **);
+void print_usage (void);
+void print_help (void);
+
+char *PROGNAME = NULL;
+char *SERVICE = NULL;
+char *SEND = NULL;
+char *EXPECT = NULL;
+char *QUIT = NULL;
+int PROTOCOL = 0;
+int PORT = 0;
+
+int server_port = 0;
+char *server_address = NULL;
+char *server_send = NULL;
+char *server_quit = NULL;
+char **server_expect = NULL;
+int server_expect_count = 0;
+char **warn_codes = NULL;
+int warn_codes_count = 0;
+char **crit_codes = NULL;
+int crit_codes_count = 0;
+int delay = 0;
+int warning_time = 0;
+int check_warning_time = FALSE;
+int critical_time = 0;
+int check_critical_time = FALSE;
+int verbose = FALSE;
+int use_ssl = FALSE;
+int sd;
+
+int
+main (int argc, char **argv)
+{
+        int result;
+        int i;
+        char buffer[MAX_INPUT_BUFFER] = "";
+        char *status = NULL;
+        char *output = NULL;
+        char *ptr = NULL;
+
+        if (strstr (argv[0], "check_udp")) {
+                PROGNAME = strscpy (PROGNAME, "check_udp");
+                SERVICE = strscpy (SERVICE, "UDP");
+                SEND = NULL;
+                EXPECT = NULL;
+                QUIT = NULL;
+                PROTOCOL = UDP_PROTOCOL;
+                PORT = 0;
+        }
+        else if (strstr (argv[0], "check_tcp")) {
+                PROGNAME = strscpy (PROGNAME, "check_tcp");
+                SERVICE = strscpy (SERVICE, "TCP");
+                SEND = NULL;
+                EXPECT = NULL;
+                QUIT = NULL;
+                PROTOCOL = TCP_PROTOCOL;
+                PORT = 0;
+        }
+        else if (strstr (argv[0], "check_ftp")) {
+                PROGNAME = strscpy (PROGNAME, "check_ftp");
+                SERVICE = strscpy (SERVICE, "FTP");
+                SEND = NULL;
+                EXPECT = strscpy (EXPECT, "220");
+                QUIT = strscpy (QUIT, "QUIT\r\n");
+                PROTOCOL = TCP_PROTOCOL;
+                PORT = 21;
+        }
+        else if (strstr (argv[0], "check_smtp")) {
+                PROGNAME = strscpy (PROGNAME, "check_smtp");
+                SERVICE = strscpy (SERVICE, "SMTP");
+                SEND = NULL;
+                EXPECT = strscpy (EXPECT, "220");
+                QUIT = strscpy (QUIT, "QUIT\r\n");
+                PROTOCOL = TCP_PROTOCOL;
+                PORT = 25;
+        }
+        else if (strstr (argv[0], "check_pop")) {
+                PROGNAME = strscpy (PROGNAME, "check_pop");
+                SERVICE = strscpy (SERVICE, "POP");
+                SEND = NULL;
+                EXPECT = strscpy (EXPECT, "110");
+                QUIT = strscpy (QUIT, "QUIT\r\n");
+                PROTOCOL = TCP_PROTOCOL;
+                PORT = 110;
+        }
+        else if (strstr (argv[0], "check_imap")) {
+                PROGNAME = strscpy (PROGNAME, "check_imap");
+                SERVICE = strscpy (SERVICE, "IMAP");
+                SEND = NULL;
+                EXPECT = strscpy (EXPECT, "* OK");
+                QUIT = strscpy (QUIT, "a1 LOGOUT\r\n");
+                PROTOCOL = TCP_PROTOCOL;
+                PORT = 143;
+        }
+#ifdef HAVE_SSL
+        else if (strstr(argv[0],"check_simap")) {
+                PROGNAME=strscpy(PROGNAME,"check_simap");
+                SERVICE=strscpy(SERVICE,"SIMAP");
+                SEND=NULL;
+                EXPECT=strscpy(EXPECT,"* OK");
+                QUIT=strscpy(QUIT,"a1 LOGOUT\n");
+                PROTOCOL=TCP_PROTOCOL;
+                use_ssl=TRUE;
+                PORT=993;
+        }
+#endif
+        else if (strstr (argv[0], "check_nntp")) {
+                PROGNAME = strscpy (PROGNAME, "check_nntp");
+                SERVICE = strscpy (SERVICE, "NNTP");
+                SEND = NULL;
+                EXPECT = NULL;
+                server_expect = realloc (server_expect, ++server_expect_count);
+                server_expect[server_expect_count - 1] = strscpy (EXPECT, "200");
+                server_expect = realloc (server_expect, ++server_expect_count);
+                server_expect[server_expect_count - 1] = strscpy (NULL, "201");
+                QUIT = strscpy (QUIT, "QUIT\r\n");
+                PROTOCOL = TCP_PROTOCOL;
+                PORT = 119;
+        }
+        else {
+                usage ("ERROR: Generic check_tcp called with unknown service\n");
+        }
+
+        server_address = strscpy (NULL, "127.0.0.1");
+        server_port = PORT;
+        server_send = SEND;
+        server_quit = QUIT;
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments\n");
+
+        /* use default expect if none listed in process_arguments() */
+        if (EXPECT && server_expect_count == 0) {
+                server_expect = malloc (1);
+                server_expect[server_expect_count - 1] = EXPECT;
+        }
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+
+        /* try to connect to the host at the given port number */
+        time (&start_time);
+#ifdef HAVE_SSL
+        if (use_ssl)
+                result = connect_SSL ();
+        else
+#endif
+                {
+                        if (PROTOCOL == UDP_PROTOCOL)
+                                result = my_udp_connect (server_address, server_port, &sd);
+                        else                                                                                                    /* default is TCP */
+                                result = my_tcp_connect (server_address, server_port, &sd);
+                }
+
+        if (result == STATE_CRITICAL)
+                return STATE_CRITICAL;
+
+        if (server_send != NULL) {              /* Something to send? */
+                snprintf (buffer, MAX_INPUT_BUFFER - 1, "%s\r\n", server_send);
+                buffer[MAX_INPUT_BUFFER - 1] = 0;
+#ifdef HAVE_SSL
+                if (use_ssl)
+                        SSL_write(ssl,buffer,strlen(buffer));
+                else
+#endif
+                        send (sd, buffer, strlen (buffer), 0);
+        }
+
+        if (delay > 0) {
+                start_time = start_time + delay;
+                sleep (delay);
+        }
+
+        if (server_send || server_expect_count > 0) {
+
+                /* watch for the expect string */
+#ifdef HAVE_SSL
+                if (use_ssl && SSL_read (ssl, buffer, MAX_INPUT_BUFFER - 1)>=0)
+                        status = strscat(status,buffer);
+                else
+#endif
+                        {
+                                if (recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0) >= 0)
+                                        status = strscat (status, buffer);
+                        }
+                strip (status);
+
+                /* return a CRITICAL status if we couldn't read any data */
+                if (status == NULL)
+                        terminate (STATE_CRITICAL, "No data received from host\n");
+
+                if (status && verbose)
+                        printf ("%s\n", status);
+
+                if (server_expect_count > 0) {
+                        for (i = 0;; i++) {
+                                printf ("%d %d\n", i, server_expect_count);
+                                if (i >= server_expect_count)
+                                        terminate (STATE_WARNING, "Invalid response from host\n");
+                                if (strstr (status, server_expect[i]))
+                                        break;
+                        }
+                }
+        }
+
+        if (server_quit)
+#ifdef HAVE_SSL
+                if (use_ssl) {
+                        SSL_write (ssl, QUIT, strlen (QUIT));
+                        SSL_shutdown (ssl);
+                        SSL_free (ssl);
+                        SSL_CTX_free (ctx);
+                }
+                else
+#endif
+                send (sd, server_quit, strlen (server_quit), 0);
+
+        /* close the connection */
+        close (sd);
+
+        time (&end_time);
+
+        if (check_critical_time == TRUE && (end_time - start_time) > critical_time)
+                result = STATE_CRITICAL;
+        else if (check_warning_time == TRUE
+                                         && (end_time - start_time) > warning_time) result = STATE_WARNING;
+
+        /* reset the alarm */
+        alarm (0);
+
+        printf
+                ("%s %s - %d second response time on port %d",
+                 SERVICE,
+                 state_text (result), (int) (end_time - start_time), server_port);
+
+        if (status)
+                printf (" [%s]\n", status);
+        else
+                printf ("\n");
+
+        return result;
+}
+
+
+
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"critical-time", required_argument, 0, 'c'},
+                {"warning-time", required_argument, 0, 'w'},
+                {"critical-codes", required_argument, 0, 'C'},
+                {"warning-codes", required_argument, 0, 'W'},
+                {"timeout", required_argument, 0, 't'},
+                {"protocol", required_argument, 0, 'P'},
+                {"port", required_argument, 0, 'p'},
+                {"send", required_argument, 0, 's'},
+                {"expect", required_argument, 0, 'e'},
+                {"quit", required_argument, 0, 'q'},
+                {"delay", required_argument, 0, 'd'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        if (argc < 2)
+                usage ("No arguments found\n");
+
+        /* backwards compatibility */
+        for (c = 1; c < argc; c++) {
+                if (strcmp ("-to", argv[c]) == 0)
+                        strcpy (argv[c], "-t");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+        if (!is_option (argv[1])) {
+                server_address = argv[1];
+                argv[1] = argv[0];
+                argv = &argv[1];
+                argc--;
+        }
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVvH:s:e:q:c:w:t:p:C:W:d:S", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+hVvH:s:e:q:c:w:t:p:C:W:d:S");
+#endif
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case '?':                 /* print short usage statement if args not parsable */
+                        printf ("%s: Unknown argument: %s\n\n", my_basename (argv[0]), optarg);
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 'h':                 /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':                 /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'v':                 /* verbose mode */
+                        verbose = TRUE;
+                        break;
+                case 'H':                 /* hostname */
+                        if (is_host (optarg) == FALSE)
+                                usage ("Invalid host name/address\n");
+                        server_address = optarg;
+                        break;
+                case 'c':                 /* critical */
+                        if (!is_intnonneg (optarg))
+                                usage ("Critical threshold must be a nonnegative integer\n");
+                        critical_time = atoi (optarg);
+                        check_critical_time = TRUE;
+                        break;
+                case 'w':                 /* warning */
+                        if (!is_intnonneg (optarg))
+                                usage ("Warning threshold must be a nonnegative integer\n");
+                        warning_time = atoi (optarg);
+                        check_warning_time = TRUE;
+                        break;
+                case 'C':
+                        crit_codes = realloc (crit_codes, ++crit_codes_count);
+                        crit_codes[crit_codes_count - 1] = optarg;
+                        break;
+                case 'W':
+                        warn_codes = realloc (warn_codes, ++warn_codes_count);
+                        warn_codes[warn_codes_count - 1] = optarg;
+                        break;
+                case 't':                 /* timeout */
+                        if (!is_intpos (optarg))
+                                usage ("Timeout interval must be a positive integer\n");
+                        socket_timeout = atoi (optarg);
+                        break;
+                case 'p':                 /* port */
+                        if (!is_intpos (optarg))
+                                usage ("Server port must be a positive integer\n");
+                        server_port = atoi (optarg);
+                        break;
+                case 's':
+                        server_send = optarg;
+                        break;
+                case 'e':
+                        EXPECT = NULL;
+                        if (server_expect_count == 0)
+                                server_expect = malloc (++server_expect_count);
+                        else
+                                server_expect = realloc (server_expect, ++server_expect_count);
+                        server_expect[server_expect_count - 1] = optarg;
+                        break;
+                case 'q':
+                        server_quit = optarg;
+                        break;
+                case 'd':
+                        if (is_intpos (optarg))
+                                delay = atoi (optarg);
+                        else
+                                usage ("Delay must be a positive integer\n");
+                        break;
+                case 'S':
+#ifndef HAVE_SSL
+                        terminate (STATE_UNKNOWN,
+                                "SSL support not available. Install OpenSSL and recompile.");
+#endif
+                        use_ssl = TRUE;
+                        break;
+                }
+        }
+
+        if (server_address == NULL)
+                usage ("You must provide a server address\n");
+
+        return OK;
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H host -p port [-w warn_time] [-c crit_time] [-s send]\n"
+                 "         [-e expect] [-W wait] [-t to_sec] [-v]\n", PROGNAME);
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)\n\n"
+                 "This plugin tests %s connections with the specified host.\n\n",
+                 SERVICE);
+        print_usage ();
+        printf
+                ("Options:\n"
+                 " -H, --hostname=ADDRESS\n"
+                 "    Host name argument for servers using host headers (use numeric\n"
+                 "    address if possible to bypass DNS lookup).\n"
+                 " -p, --port=INTEGER\n"
+                 "    Port number\n"
+                 " -s, --send=STRING\n"
+                 "    String to send to the server\n"
+                 " -e, --expect=STRING\n"
+                 "    String to expect in server response"
+                 " -W, --wait=INTEGER\n"
+                 "    Seconds to wait between sending string and polling for response\n"
+                 " -w, --warning=INTEGER\n"
+                 "    Response time to result in warning status (seconds)\n"
+                 " -c, --critical=INTEGER\n"
+                 "    Response time to result in critical status (seconds)\n"
+                 " -t, --timeout=INTEGER\n"
+                 "    Seconds before connection times out (default: %d)\n"
+                 " -v"
+                 "    Show details for command-line debugging (do not use with nagios server)\n"
+                 " -h, --help\n"
+                 "    Print detailed help screen\n"
+                 " -V, --version\n"
+                 "    Print version information\n", DEFAULT_SOCKET_TIMEOUT);
+}
+
+
+#ifdef HAVE_SSL
+int
+connect_SSL (void)
+{
+  SSL_METHOD *meth;
+
+  /* Initialize SSL context */
+  SSLeay_add_ssl_algorithms ();
+  meth = SSLv2_client_method ();
+  SSL_load_error_strings ();
+  if ((ctx = SSL_CTX_new (meth)) == NULL)
+    {
+      printf ("ERROR: Cannot create SSL context.\n");
+      return STATE_CRITICAL;
+    }
+
+  /* Initialize alarm signal handling */
+  signal (SIGALRM, socket_timeout_alarm_handler);
+
+  /* Set socket timeout */
+  alarm (socket_timeout);
+
+  /* Save start time */
+  time (&start_time);
+
+  /* Make TCP connection */
+  if (my_tcp_connect (server_address, server_port, &sd) == STATE_OK)
+    {
+    /* Do the SSL handshake */
+      if ((ssl = SSL_new (ctx)) != NULL)
+      {
+        SSL_set_fd (ssl, sd);
+        if (SSL_connect (ssl) != -1)
+          return OK;
+        ERR_print_errors_fp (stderr);
+      }
+      else
+      {
+        printf ("ERROR: Cannot initiate SSL handshake.\n");
+      }
+      SSL_free (ssl);
+    }
+
+  SSL_CTX_free (ctx);
+  close (sd);
+
+  return STATE_CRITICAL;
+}
+#endif
+
diff --git a/plugins/check_time.c b/plugins/check_time.c
new file mode 100644
index 00000000..86c414e2
--- /dev/null
+++ b/plugins/check_time.c
@@ -0,0 +1,370 @@
+/******************************************************************************
+*
+* CHECK_TIME.C
+*
+* Program: Network time server plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+* Copyright (c) 2000 Karl DeBisschop (kdebisschop@users.sourceforge.net)
+*
+* $Id$
+*
+* Description:
+*
+* This plugin will attempt to connect to the specified port
+* on the host.  Successul connects return STATE_OK, refusals
+* and timeouts return STATE_CRITICAL, other errors return
+* STATE_UNKNOWN.
+*
+* 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 "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define PROGNAME "check_time"
+
+#define TIME_PORT       37
+#define UNIX_EPOCH      2208988800UL
+
+unsigned long server_time, raw_server_time;
+time_t diff_time;
+int warning_time = 0;
+int check_warning_time = FALSE;
+int critical_time = 0;
+int check_critical_time = FALSE;
+unsigned long warning_diff = 0;
+int check_warning_diff = FALSE;
+unsigned long critical_diff = 0;
+int check_critical_diff = FALSE;
+int server_port = TIME_PORT;
+char *server_address = NULL;
+
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+void print_usage (void);
+void print_help (void);
+
+
+int
+main (int argc, char **argv)
+{
+        int sd;
+        int result;
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+        time (&start_time);
+
+        /* try to connect to the host at the given port number */
+        if (my_tcp_connect (server_address, server_port, &sd) != STATE_OK) {
+                if (check_critical_time == TRUE)
+                        result = STATE_CRITICAL;
+                else if (check_warning_time == TRUE)
+                        result = STATE_WARNING;
+                else
+                        result = STATE_UNKNOWN;
+                terminate (result,
+                                                         "TIME UNKNOWN - could not connect to server %s, port %d\n",
+                                                         server_address, server_port);
+        }
+
+        /* watch for the FTP connection string */
+        result = recv (sd, &raw_server_time, sizeof (raw_server_time), 0);
+
+        /* close the connection */
+        close (sd);
+
+        /* reset the alarm */
+        time (&end_time);
+        alarm (0);
+
+        /* return a WARNING status if we couldn't read any data */
+        if (result <= 0) {
+                if (check_critical_time == TRUE)
+                        result = STATE_CRITICAL;
+                else if (check_warning_time == TRUE)
+                        result = STATE_WARNING;
+                else
+                        result = STATE_UNKNOWN;
+                terminate (result,
+                                                         "TIME UNKNOWN - no data on recv() from server %s, port %d\n",
+                                                         server_address, server_port);
+        }
+
+        result = STATE_OK;
+
+        if (check_critical_time == TRUE && (end_time - start_time) > critical_time)
+                result = STATE_CRITICAL;
+        else if (check_warning_time == TRUE
+                                         && (end_time - start_time) > warning_time) result = STATE_WARNING;
+
+        if (result != STATE_OK)
+                terminate (result, "TIME %s - %d second response time\n",
+                                                         state_text (result), (int) (end_time - start_time));
+
+        server_time = ntohl (raw_server_time) - UNIX_EPOCH;
+        if (server_time > end_time)
+                diff_time = server_time - end_time;
+        else
+                diff_time = end_time - server_time;
+
+        if (check_critical_diff == TRUE && diff_time > critical_diff)
+                result = STATE_CRITICAL;
+        else if (check_warning_diff == TRUE && diff_time > warning_diff)
+                result = STATE_WARNING;
+
+        printf ("TIME %s - %lu second time difference\n", state_text (result),
+                                        diff_time);
+        return result;
+}
+
+
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+        if (argc < 2)
+                usage ("\n");
+
+        for (c = 1; c < argc; c++) {
+                if (strcmp ("-to", argv[c]) == 0)
+                        strcpy (argv[c], "-t");
+                else if (strcmp ("-wd", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-cd", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-W");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-C");
+        }
+
+        c = 0;
+        while ((c += call_getopt (argc - c, &argv[c])) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (server_address == NULL) {
+                        if (argc > c) {
+                                if (is_host (argv[c]) == FALSE)
+                                        usage ("Invalid host name/address\n");
+                                server_address = argv[c];
+                        }
+                        else {
+                                usage ("Host name was not supplied\n");
+                        }
+                }
+        }
+
+        return OK;
+}
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"warning-variance", required_argument, 0, 'w'},
+                {"critical-variance", required_argument, 0, 'c'},
+                {"warning-connect", required_argument, 0, 'W'},
+                {"critical-connect", required_argument, 0, 'C'},
+                {"port", required_argument, 0, 'p'},
+                {"timeout", required_argument, 0, 't'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVH:w:c:W:C:p:t:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+hVH:w:c:W:C:p:t:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 'H':
+                case 'w':
+                case 'c':
+                case 'W':
+                case 'C':
+                case 'p':
+                case 't':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* print short usage statement if args not parsable */
+                        printf ("%s: Unknown argument: %s\n\n", my_basename (argv[0]), optarg);
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg) == FALSE)
+                                usage ("Invalid host name/address\n");
+                        server_address = optarg;
+                        break;
+                case 'w':                                                                       /* warning-variance */
+                        if (is_intnonneg (optarg)) {
+                                warning_diff = strtoul (optarg, NULL, 10);
+                                check_warning_diff = TRUE;
+                        }
+                        else if (strspn (optarg, "0123456789:,") > 0) {
+                                if (sscanf (optarg, "%lu%*[:,]%d", &warning_diff, &warning_time) == 2) {
+                                        check_warning_diff = TRUE;
+                                        check_warning_time = TRUE;
+                                }
+                                else {
+                                        usage ("Warning thresholds must be a nonnegative integer\n");
+                                }
+                        }
+                        else {
+                                usage ("Warning threshold must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'c':                                                                       /* critical-variance */
+                        if (is_intnonneg (optarg)) {
+                                critical_diff = strtoul (optarg, NULL, 10);
+                                check_critical_diff = TRUE;
+                        }
+                        else if (strspn (optarg, "0123456789:,") > 0) {
+                                if (sscanf (optarg, "%lu%*[:,]%d", &critical_diff, &critical_time) ==
+                                                2) {
+                                        check_critical_diff = TRUE;
+                                        check_critical_time = TRUE;
+                                }
+                                else {
+                                        usage ("Critical thresholds must be a nonnegative integer\n");
+                                }
+                        }
+                        else {
+                                usage ("Critical threshold must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'W':                                                                       /* warning-connect */
+                        if (!is_intnonneg (optarg))
+                                usage ("Warning threshold must be a nonnegative integer\n");
+                        warning_time = atoi (optarg);
+                        check_warning_time = TRUE;
+                        break;
+                case 'C':                                                                       /* critical-connect */
+                        if (!is_intnonneg (optarg))
+                                usage ("Critical threshold must be a nonnegative integer\n");
+                        critical_time = atoi (optarg);
+                        check_critical_time = TRUE;
+                        break;
+                case 'p':                                                                       /* port */
+                        if (!is_intnonneg (optarg))
+                                usage ("Serevr port must be a nonnegative integer\n");
+                        server_port = atoi (optarg);
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (!is_intnonneg (optarg))
+                                usage ("Timeout interval must be a nonnegative integer\n");
+                        socket_timeout = atoi (optarg);
+                        break;
+                }
+        }
+        return i;
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: check_time -H <host_address> [-p port] [-w variance] [-c variance]\n"
+                 "                 [-W connect_time] [-C connect_time] [-t timeout]\n");
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Ethan Galstad/Karl DeBisschop\n\n"
+                 "This plugin connects to a time port on the specified host.\n\n");
+        print_usage ();
+        printf
+                ("Options:\n"
+                 " -H, --hostname=ADDRESS\n"
+                 "    Host name argument for servers using host headers (use numeric\n"
+                 "    address if possible to bypass DNS lookup).\n"
+                 " -w, --warning-variance=INTEGER\n"
+                 "    Time difference (sec.) necessary to result in a warning status\n"
+                 " -c, --critical-variance=INTEGER\n"
+                 "    Time difference (sec.) necessary to result in a critical status\n"
+                 " -W, --warning-connect=INTEGER\n"
+                 "    Response time (sec.) necessary to result in warning status\n"
+                 " -C, --critical-connect=INTEGER\n"
+                 "    Response time (sec.) necessary to result in critical status\n"
+                 " -t, --timeout=INTEGER\n"
+                 "    Seconds before connection times out (default: %d)\n"
+                 " -p, --port=INTEGER\n"
+                 "    Port number (default: %d)\n"
+                 " -h, --help\n"
+                 "    Print detailed help screen\n"
+                 " -V, --version\n"
+                 "    Print version information\n\n", DEFAULT_SOCKET_TIMEOUT, TIME_PORT);
+        support ();
+}
diff --git a/plugins/check_udp.c b/plugins/check_udp.c
new file mode 100644
index 00000000..d00ce9c3
--- /dev/null
+++ b/plugins/check_udp.c
@@ -0,0 +1,315 @@
+/******************************************************************************
+*
+* CHECK_UDP.C
+*
+* Program: UDP port plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+*
+* Last Modified: $Date$
+*
+* Command line: CHECK_UDP <host_address> [-p port] [-s send] [-e expect] \
+*                          [-wt warn_time] [-ct crit_time] [-to to_sec]
+*
+* Description:
+*
+* This plugin will attempt to connect to the specified port
+* on the host.  Successul connects return STATE_OK, refusals
+* and timeouts return STATE_CRITICAL, other errors return
+* STATE_UNKNOWN.
+*
+* 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 "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define PROGNAME "check_udp"
+
+int warning_time = 0;
+int check_warning_time = FALSE;
+int critical_time = 0;
+int check_critical_time = FALSE;
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+void print_usage (void);
+void print_help (void);
+
+int verbose = FALSE;
+int server_port = 0;
+char *server_address = NULL;
+char *server_expect = NULL;
+char *server_send = NULL;
+
+int
+main (int argc, char **argv)
+{
+        int result;
+        char recv_buffer[MAX_INPUT_BUFFER];
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+
+        time (&start_time);
+        result =
+                process_udp_request (server_address, server_port, server_send,
+                                                                                                 recv_buffer, MAX_INPUT_BUFFER - 1);
+        time (&end_time);
+
+        if (result != STATE_OK) {
+                printf ("No response from host on port %d\n", server_port);
+                result = STATE_CRITICAL;
+        }
+
+        else {
+
+                /* check to see if we got the response we wanted */
+                if (server_expect) {
+                        if (!strstr (recv_buffer, server_expect)) {
+                                printf ("Invalid response received from host on port %d\n",
+                                                                server_port);
+                                result = STATE_CRITICAL;
+                        }
+                }
+        }
+
+        /* we connected, so close connection before exiting */
+        if (result == STATE_OK) {
+
+                if (check_critical_time == TRUE
+                                && (end_time - start_time) > critical_time) result = STATE_CRITICAL;
+                else if (check_warning_time == TRUE
+                                                 && (end_time - start_time) > warning_time) result =
+                                STATE_WARNING;
+
+                printf ("Connection %s on port %d - %d second response time\n",
+                                                (result == STATE_OK) ? "accepted" : "problem", server_port,
+                                                (int) (end_time - start_time));
+        }
+
+        /* reset the alarm */
+        alarm (0);
+
+        return result;
+}
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+        if (argc < 2)
+                usage ("\n");
+
+        for (c = 1; c < argc; c++) {
+                if (strcmp ("-to", argv[c]) == 0)
+                        strcpy (argv[c], "-t");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+        c = 0;
+        while ((c += call_getopt (argc - c, &argv[c])) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (server_address == NULL) {
+                        if (argc > c) {
+                                if (is_host (argv[c]) == FALSE)
+                                        usage ("Invalid host name/address\n");
+                                server_address = argv[c];
+                        }
+                        else {
+                                usage ("Host name was not supplied\n");
+                        }
+                }
+        }
+
+        if (server_send == NULL)
+                server_send = strscpy (server_send, "");
+
+        return OK;
+}
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"timeout", required_argument, 0, 't'},
+                {"port", required_argument, 0, 'p'},
+                {"expect", required_argument, 0, 'e'},
+                {"send", required_argument, 0, 's'},
+                {"verbose", no_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVvH:e:s:c:w:t:p:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+hVvH:e:s:c:w:t:p:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 'H':
+                case 'c':
+                case 'w':
+                case 't':
+                case 'p':
+                case 'e':
+                case 's':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* print short usage statement if args not parsable */
+                        printf ("%s: Unknown argument: %s\n\n", my_basename (argv[0]), optarg);
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'v':                                                                       /* verbose mode */
+                        verbose = TRUE;
+                        break;
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg) == FALSE)
+                                usage ("Invalid host name/address\n");
+                        server_address = optarg;
+                        break;
+                case 'c':                                                                       /* critical */
+                        if (!is_intnonneg (optarg))
+                                usage ("Critical threshold must be a nonnegative integer\n");
+                        critical_time = atoi (optarg);
+                        check_critical_time = TRUE;
+                        break;
+                case 'w':                                                                       /* warning */
+                        if (!is_intnonneg (optarg))
+                                usage ("Warning threshold must be a nonnegative integer\n");
+                        warning_time = atoi (optarg);
+                        check_warning_time = TRUE;
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (!is_intnonneg (optarg))
+                                usage ("Timeout interval must be a nonnegative integer\n");
+                        socket_timeout = atoi (optarg);
+                        break;
+                case 'p':                                                                       /* port */
+                        if (!is_intnonneg (optarg))
+                                usage ("Serevr port must be a nonnegative integer\n");
+                        server_port = atoi (optarg);
+                        break;
+                case 'e':                                                                       /* expect */
+                        server_expect = optarg;
+                        break;
+                case 's':                                                                       /* send */
+                        server_send = optarg;
+                        break;
+                }
+        }
+        return i;
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H <host_address> [-p port] [-w warn_time] [-c crit_time]\n"
+                 "         [-e expect] [-s send] [-t to_sec] [-v]\n", PROGNAME);
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)\n\n"
+                 "This plugin tests an UDP connection with the specified host.\n\n");
+        print_usage ();
+        printf
+                ("Options:\n"
+                 " -H, --hostname=ADDRESS\n"
+                 "    Host name argument for servers using host headers (use numeric\n"
+                 "    address if possible to bypass DNS lookup).\n"
+                 " -p, --port=INTEGER\n"
+                 "    Port number\n"
+                 " -e, --expect=STRING <optional>\n"
+                 "    String to expect in first line of server response\n"
+                 " -s, --send=STRING <optional>\n"
+                 "    String to send to the server when initiating the connection\n"
+                 " -w, --warning=INTEGER <optional>\n"
+                 "    Response time to result in warning status (seconds)\n"
+                 " -c, --critical=INTEGER <optional>\n"
+                 "    Response time to result in critical status (seconds)\n"
+                 " -t, --timeout=INTEGER <optional>\n"
+                 "    Seconds before connection times out (default: %d)\n"
+                 " -v, --verbose <optional>\n"
+                 "    Show details for command-line debugging (do not use with nagios server)\n"
+                 " -h, --help\n"
+                 "    Print detailed help screen and exit\n"
+                 " -V, --version\n"
+                 "    Print version information and exit\n", DEFAULT_SOCKET_TIMEOUT);
+}
diff --git a/plugins/check_ups.c b/plugins/check_ups.c
new file mode 100644
index 00000000..4632bdc0
--- /dev/null
+++ b/plugins/check_ups.c
@@ -0,0 +1,649 @@
+/******************************************************************************
+*
+* CHECK_UPS.C
+*
+* Program: UPS monitor plugin for Nagios
+* License: GPL
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+*
+* Last Modified: $Date$
+*
+* Command line: CHECK_UPS <host_address> [-u ups] [-p port] [-v variable] \
+*                          [-wv warn_value] [-cv crit_value] [-to to_sec]
+*
+* Description:
+*
+
+* This plugin attempts to determine the status of an UPS
+* (Uninterruptible Power Supply) on a remote host (or the local host)
+* that is being monitored with Russel Kroll's "Smarty UPS Tools"
+* package. If the UPS is online or calibrating, the plugin will
+* return an OK state. If the battery is on it will return a WARNING
+* state.  If the UPS is off or has a low battery the plugin will
+* return a CRITICAL state.  You may also specify a variable to check
+* (such as temperature, utility voltage, battery load, etc.)  as well
+* as warning and critical thresholds for the value of that variable.
+* If the remote host has multiple UPS that are being monitored you
+* will have to use the [ups] option to specify which UPS to check.
+*
+* Notes:
+*
+* This plugin requires that the UPSD daemon distributed with Russel
+* Kroll's "Smart UPS Tools" be installed on the remote host.  If you
+* don't have the package installed on your system, you can download
+* it from http://www.exploits.org/~rkroll/smartupstools
+*
+* 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 "config.h"
+#include "common.h"
+#include "netutils.h"
+#include "utils.h"
+
+#define PROGNAME "check_ups"
+
+#define CHECK_NONE      0
+
+#define PORT    3305
+
+#define UPS_NONE        0                                                       /* no supported options */
+#define UPS_UTILITY     1                                               /* supports utility line voltage */
+#define UPS_BATTPCT     2                                               /* supports percent battery remaining */
+#define UPS_STATUS      4                                               /* supports UPS status */
+#define UPS_TEMP        8                                                       /* supports UPS temperature */
+#define UPS_LOADPCT     16                                      /* supports load percent */
+
+#define UPSSTATUS_NONE          0
+#define UPSSTATUS_OFF           1
+#define UPSSTATUS_OL            2
+#define UPSSTATUS_OB            4
+#define UPSSTATUS_LB            8
+#define UPSSTATUS_CAL           16
+#define UPSSTATUS_UNKOWN        32
+
+int server_port = PORT;
+char *server_address = NULL;
+char *ups_name = NULL;
+double warning_value = 0.0L;
+double critical_value = 0.0L;
+int check_warning_value = FALSE;
+int check_critical_value = FALSE;
+int check_variable = UPS_NONE;
+int supported_options = UPS_NONE;
+int status = UPSSTATUS_NONE;
+
+double ups_utility_voltage = 0.0L;
+double ups_battery_percent = 0.0L;
+double ups_load_percent = 0.0L;
+double ups_temperature = 0.0L;
+char ups_status[MAX_INPUT_BUFFER] = "N/A";
+
+int determine_status (void);
+int determine_supported_vars (void);
+int get_ups_variable (const char *, char *, int);
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+int validate_arguments (void);
+void print_help (void);
+void print_usage (void);
+
+int
+main (int argc, char **argv)
+{
+        int result = STATE_OK;
+        char output_message[MAX_INPUT_BUFFER];
+        char temp_buffer[MAX_INPUT_BUFFER];
+
+        double ups_utility_deviation = 0.0L;
+
+        if (process_arguments (argc, argv) != OK)
+                usage ("Invalid command arguments supplied\n");
+
+        /* initialize alarm signal handling */
+        signal (SIGALRM, socket_timeout_alarm_handler);
+
+        /* set socket timeout */
+        alarm (socket_timeout);
+
+        /* determine what variables the UPS supports */
+        if (determine_supported_vars () != OK)
+                return STATE_CRITICAL;
+
+        /* get the ups status if possible */
+        if (supported_options & UPS_STATUS) {
+
+                if (determine_status () != OK)
+                        return STATE_CRITICAL;
+                ups_status[0] = 0;
+                result = STATE_OK;
+
+                if (status & UPSSTATUS_OFF) {
+                        strcpy (ups_status, "Off");
+                        result = STATE_CRITICAL;
+                }
+                else if ((status & (UPSSTATUS_OB | UPSSTATUS_LB)) ==
+                                                 (UPSSTATUS_OB | UPSSTATUS_LB)) {
+                        strcpy (ups_status, "On Battery, Low Battery");
+                        result = STATE_CRITICAL;
+                }
+                else {
+                        if (status & UPSSTATUS_OL) {
+                                strcat (ups_status, "Online");
+                        }
+                        if (status & UPSSTATUS_OB) {
+                                strcat (ups_status, "On Battery");
+                                result = STATE_WARNING;
+                        }
+                        if (status & UPSSTATUS_LB) {
+                                strcat (ups_status, ", Low Battery");
+                                result = STATE_WARNING;
+                        }
+                        if (status & UPSSTATUS_CAL) {
+                                strcat (ups_status, ", Calibrating");
+                        }
+                        if (status & UPSSTATUS_UNKOWN) {
+                                strcat (ups_status, ", Unknown");
+                        }
+                }
+        }
+
+        /* get the ups utility voltage if possible */
+        if (supported_options & UPS_UTILITY) {
+
+                if (get_ups_variable ("UTILITY", temp_buffer, sizeof (temp_buffer)) != OK)
+                        return STATE_CRITICAL;
+
+                ups_utility_voltage = atof (temp_buffer);
+
+                if (ups_utility_voltage > 120.0)
+                        ups_utility_deviation = 120.0 - ups_utility_voltage;
+                else
+                        ups_utility_deviation = ups_utility_voltage - 120.0;
+
+                if (check_variable == UPS_UTILITY) {
+                        if (check_critical_value == TRUE
+                                        && ups_utility_deviation >= critical_value) result = STATE_CRITICAL;
+                        else if (check_warning_value == TRUE
+                                                         && ups_utility_deviation >= warning_value
+                                                         && result < STATE_WARNING) result = STATE_WARNING;
+                }
+        }
+
+        /* get the ups battery percent if possible */
+        if (supported_options & UPS_BATTPCT) {
+
+                if (get_ups_variable ("BATTPCT", temp_buffer, sizeof (temp_buffer)) != OK)
+                        return STATE_CRITICAL;
+
+                ups_battery_percent = atof (temp_buffer);
+
+                if (check_variable == UPS_BATTPCT) {
+                        if (check_critical_value == TRUE
+                                        && ups_battery_percent <= critical_value) result = STATE_CRITICAL;
+                        else if (check_warning_value == TRUE
+                                                         && ups_battery_percent <= warning_value
+                                                         && result < STATE_WARNING) result = STATE_WARNING;
+                }
+        }
+
+        /* get the ups load percent if possible */
+        if (supported_options & UPS_LOADPCT) {
+
+                if (get_ups_variable ("LOADPCT", temp_buffer, sizeof (temp_buffer)) != OK)
+                        return STATE_CRITICAL;
+
+                ups_load_percent = atof (temp_buffer);
+
+                if (check_variable == UPS_LOADPCT) {
+                        if (check_critical_value == TRUE && ups_load_percent >= critical_value)
+                                result = STATE_CRITICAL;
+                        else if (check_warning_value == TRUE
+                                                         && ups_load_percent >= warning_value && result < STATE_WARNING)
+                                result = STATE_WARNING;
+                }
+        }
+
+        /* get the ups temperature if possible */
+        if (supported_options & UPS_TEMP) {
+
+                if (get_ups_variable ("UPSTEMP", temp_buffer, sizeof (temp_buffer)) != OK)
+                        return STATE_CRITICAL;
+
+                ups_temperature = (atof (temp_buffer) * 1.8) + 32;
+
+                if (check_variable == UPS_TEMP) {
+                        if (check_critical_value == TRUE && ups_temperature >= critical_value)
+                                result = STATE_CRITICAL;
+                        else if (check_warning_value == TRUE && ups_temperature >= warning_value
+                                                         && result < STATE_WARNING)
+                                result = STATE_WARNING;
+                }
+        }
+
+        /* if the UPS does not support any options we are looking for, report an error */
+        if (supported_options == UPS_NONE)
+                result = STATE_CRITICAL;
+
+        /* reset timeout */
+        alarm (0);
+
+
+        sprintf (output_message, "UPS %s - ",
+                                         (result == STATE_OK) ? "ok" : "problem");
+
+        if (supported_options & UPS_STATUS) {
+                sprintf (temp_buffer, "Status=%s ", ups_status);
+                strcat (output_message, temp_buffer);
+        }
+        if (supported_options & UPS_UTILITY) {
+                sprintf (temp_buffer, "Utility=%3.1fV ", ups_utility_voltage);
+                strcat (output_message, temp_buffer);
+        }
+        if (supported_options & UPS_BATTPCT) {
+                sprintf (temp_buffer, "Batt=%3.1f%% ", ups_battery_percent);
+                strcat (output_message, temp_buffer);
+        }
+        if (supported_options & UPS_LOADPCT) {
+                sprintf (temp_buffer, "Load=%3.1f%% ", ups_load_percent);
+                strcat (output_message, temp_buffer);
+        }
+        if (supported_options & UPS_TEMP) {
+                sprintf (temp_buffer, "Temp=%3.1fF", ups_temperature);
+                strcat (output_message, temp_buffer);
+        }
+        if (supported_options == UPS_NONE) {
+                sprintf (temp_buffer,
+                                                 "UPS does not appear to support any available options\n");
+                strcat (output_message, temp_buffer);
+        }
+
+        printf ("%s\n", output_message);
+
+        return result;
+}
+
+
+
+/* determines what options are supported by the UPS */
+int
+determine_status (void)
+{
+        char recv_buffer[MAX_INPUT_BUFFER];
+        char temp_buffer[MAX_INPUT_BUFFER];
+        char *ptr;
+
+        if (get_ups_variable ("STATUS", recv_buffer, sizeof (recv_buffer)) !=
+                        STATE_OK) {
+                printf ("Invalid response received from hostn");
+                return ERROR;
+        }
+
+        recv_buffer[strlen (recv_buffer) - 1] = 0;
+
+        strcpy (temp_buffer, recv_buffer);
+        for (ptr = (char *) strtok (temp_buffer, " "); ptr != NULL;
+                         ptr = (char *) strtok (NULL, " ")) {
+                if (!strcmp (ptr, "OFF"))
+                        status |= UPSSTATUS_OFF;
+                else if (!strcmp (ptr, "OL"))
+                        status |= UPSSTATUS_OL;
+                else if (!strcmp (ptr, "OB"))
+                        status |= UPSSTATUS_OB;
+                else if (!strcmp (ptr, "LB"))
+                        status |= UPSSTATUS_LB;
+                else if (!strcmp (ptr, "CAL"))
+                        status |= UPSSTATUS_CAL;
+                else
+                        status |= UPSSTATUS_UNKOWN;
+        }
+
+        return OK;
+}
+
+
+/* determines what options are supported by the UPS */
+int
+determine_supported_vars (void)
+{
+        char send_buffer[MAX_INPUT_BUFFER];
+        char recv_buffer[MAX_INPUT_BUFFER];
+        char temp_buffer[MAX_INPUT_BUFFER];
+        char *ptr;
+
+
+        /* get the list of variables that this UPS supports */
+        if (ups_name)
+                sprintf (send_buffer, "LISTVARS %s\r\n", ups_name);
+        else
+                sprintf (send_buffer, "LISTVARS\r\n");
+        if (process_tcp_request
+                        (server_address, server_port, send_buffer, recv_buffer,
+                         sizeof (recv_buffer)) != STATE_OK) {
+                printf ("Invalid response received from host\n");
+                return ERROR;
+        }
+
+        recv_buffer[strlen (recv_buffer) - 1] = 0;
+
+        if (ups_name)
+                ptr = recv_buffer + 5 + strlen (ups_name) + 2;
+        else
+                ptr = recv_buffer + 5;
+
+        strcpy (temp_buffer, recv_buffer);
+
+        for (ptr = (char *) strtok (temp_buffer, " "); ptr != NULL;
+                         ptr = (char *) strtok (NULL, " ")) {
+                if (!strcmp (ptr, "UTILITY"))
+                        supported_options |= UPS_UTILITY;
+                else if (!strcmp (ptr, "BATTPCT"))
+                        supported_options |= UPS_BATTPCT;
+                else if (!strcmp (ptr, "LOADPCT"))
+                        supported_options |= UPS_LOADPCT;
+                else if (!strcmp (ptr, "STATUS"))
+                        supported_options |= UPS_STATUS;
+                else if (!strcmp (ptr, "UPSTEMP"))
+                        supported_options |= UPS_TEMP;
+        }
+
+        return OK;
+}
+
+
+/* gets a variable value for a specific UPS  */
+int
+get_ups_variable (const char *varname, char *buf, int buflen)
+{
+        /*  char command[MAX_INPUT_BUFFER]; */
+        char temp_buffer[MAX_INPUT_BUFFER];
+        char send_buffer[MAX_INPUT_BUFFER];
+        char *ptr;
+
+        /* create the command string to send to the UPS daemon */
+        if (ups_name)
+                sprintf (send_buffer, "REQ %s@%s\n", varname, ups_name);
+        else
+                sprintf (send_buffer, "REQ %s\n", varname);
+
+        /* send the command to the daemon and get a response back */
+        if (process_tcp_request
+                        (server_address, server_port, send_buffer, temp_buffer,
+                         sizeof (temp_buffer)) != STATE_OK) {
+                printf ("Invalid response received from host\n");
+                return ERROR;
+        }
+
+        if (ups_name)
+                ptr = temp_buffer + strlen (varname) + 5 + strlen (ups_name) + 1;
+        else
+                ptr = temp_buffer + strlen (varname) + 5;
+
+        if (!strcmp (ptr, "NOT-SUPPORTED")) {
+                printf ("Error: Variable '%s' is not supported\n", varname);
+                return ERROR;
+        }
+
+        if (!strcmp (ptr, "DATA-STALE")) {
+                printf ("Error: UPS data is stale\n");
+                return ERROR;
+        }
+
+        if (!strcmp (ptr, "UNKNOWN-UPS")) {
+                if (ups_name)
+                        printf ("Error: UPS '%s' is unknown\n", ups_name);
+                else
+                        printf ("Error: UPS is unknown\n");
+                return ERROR;
+        }
+
+        strncpy (buf, ptr, buflen - 1);
+        buf[buflen - 1] = 0;
+
+        return OK;
+}
+
+
+
+
+
+/* Command line: CHECK_UPS <host_address> [-u ups] [-p port] [-v variable] 
+                           [-wv warn_value] [-cv crit_value] [-to to_sec] */
+
+
+/* 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");
+                else if (strcmp ("-wt", argv[c]) == 0)
+                        strcpy (argv[c], "-w");
+                else if (strcmp ("-ct", argv[c]) == 0)
+                        strcpy (argv[c], "-c");
+        }
+
+        c = 0;
+        while ((c += (call_getopt (argc - c, &argv[c]))) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (server_address == NULL) {
+                        if (is_host (argv[c])) {
+                                server_address = argv[c];
+                        }
+                        else {
+                                usage ("Invalid host name");
+                        }
+                }
+        }
+
+        if (server_address == NULL)
+                server_address = strscpy (NULL, "127.0.0.1");
+
+        return validate_arguments ();
+}
+
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"hostname", required_argument, 0, 'H'},
+                {"ups", required_argument, 0, 'u'},
+                {"port", required_argument, 0, 'p'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"timeout", required_argument, 0, 't'},
+                {"variable", required_argument, 0, 'v'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c =
+                        getopt_long (argc, argv, "+hVH:u:p:v:c:w:t:", long_options,
+                                                                         &option_index);
+#else
+                c = getopt (argc, argv, "+?hVH:u:p:v:c:w:t:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 'H':
+                case 'u':
+                case 'p':
+                case 'v':
+                case 'c':
+                case 'w':
+                case 't':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* help */
+                        usage ("Invalid argument\n");
+                case 'H':                                                                       /* hostname */
+                        if (is_host (optarg)) {
+                                server_address = optarg;
+                        }
+                        else {
+                                usage ("Invalid host name\n");
+                        }
+                        break;
+                case 'u':                                                                       /* ups name */
+                        ups_name = optarg;
+                        break;
+                case 'p':                                                                       /* port */
+                        if (is_intpos (optarg)) {
+                                server_port = atoi (optarg);
+                        }
+                        else {
+                                usage ("Server port must be a positive integer\n");
+                        }
+                        break;
+                case 'c':                                                                       /* critical time threshold */
+                        if (is_intnonneg (optarg)) {
+                                critical_value = atoi (optarg);
+                                check_critical_value = TRUE;
+                        }
+                        else {
+                                usage ("Critical time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'w':                                                                       /* warning time threshold */
+                        if (is_intnonneg (optarg)) {
+                                warning_value = atoi (optarg);
+                                check_warning_value = TRUE;
+                        }
+                        else {
+                                usage ("Warning time must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'v':                                                                       /* variable */
+                        if (!strcmp (optarg, "LINE"))
+                                check_variable = UPS_UTILITY;
+                        else if (!strcmp (optarg, "TEMP"))
+                                check_variable = UPS_TEMP;
+                        else if (!strcmp (optarg, "BATTPCT"))
+                                check_variable = UPS_BATTPCT;
+                        else if (!strcmp (optarg, "LOADPCT"))
+                                check_variable = UPS_LOADPCT;
+                        else
+                                usage ("Unrecognized UPS variable\n");
+                        break;
+                case 't':                                                                       /* timeout */
+                        if (is_intnonneg (optarg)) {
+                                socket_timeout = atoi (optarg);
+                        }
+                        else {
+                                usage ("Time interval must be a nonnegative integer\n");
+                        }
+                        break;
+                case 'V':                                                                       /* version */
+                        print_revision (PROGNAME, "$Revision$");
+                        exit (STATE_OK);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                }
+        }
+        return i;
+}
+
+
+
+
+
+int
+validate_arguments (void)
+{
+        return OK;
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 2000 Tom Shields/Karl DeBisschop\n\n"
+                 "This plugin tests the UPS service on the specified host.\n\n");
+        print_usage ();
+        printf
+                ("\nOptions:\n"
+                 " -H, --hostname=STRING or IPADDRESS\n"
+                 "   Check server on the indicated host\n"
+                 " -p, --port=INTEGER\n"
+                 "   Make connection on the indicated port (default: %d)\n"
+                 " -u, --ups=STRING\n"
+                 "   Name of UPS\n"
+                 " -w, --warning=INTEGER\n"
+                 "   Seconds necessary to result in a warning status\n"
+                 " -c, --critical=INTEGER\n"
+                 "   Seconds necessary to result in a critical status\n"
+                 " -t, --timeout=INTEGER\n"
+                 "   Seconds before connection attempt times out (default: %d)\n"
+                 " -v, --verbose\n"
+                 "   Print extra information (command-line use only)\n"
+                 " -h, --help\n"
+                 "   Print detailed help screen\n"
+                 " -V, --version\n"
+                 "   Print version information\n\n", PORT, DEFAULT_SOCKET_TIMEOUT);
+        support ();
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf
+                ("Usage: %s -H host [-e expect] [-p port] [-w warn] [-c crit]\n"
+                 "            [-t timeout] [-v]\n"
+                 "       %s --help\n"
+                 "       %s --version\n", PROGNAME, PROGNAME, PROGNAME);
+}
diff --git a/plugins/check_users.c b/plugins/check_users.c
new file mode 100644
index 00000000..2b8fa15b
--- /dev/null
+++ b/plugins/check_users.c
@@ -0,0 +1,257 @@
+/******************************************************************************
+ *
+ * CHECK_USERS.C
+ *
+ * Program: Current users plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ *
+ * Last Modified: $Date$
+ * Modifications: 
+ *
+ * 1999-11-17 Karl DeBisschop
+ *  - check stderr and status from spoen/spclose
+ *  - reformat commenst to fit 80-cahr screen
+ *  - set default result to STATE_UNKNOWN
+ *  - initialize users at -1, eliminate 'found' variable
+ *
+ * Command line: CHECK_USERS <wusers> <cusers>
+ *
+ * Description:
+ *
+ * This plugin will use the /usr/bin/who command to check the number
+ * of users currently logged into the system.  If number of logged in
+ * user exceeds the number specified by the <cusers> option, a
+ * STATE_CRITICAL is return.  It it exceeds <wusers>, a STATE_WARNING
+ * is returned.  Errors reading the output from the who command result
+ * in a STATE_UNKNOWN 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"
+
+#define PROGNAME "check_users"
+
+#define possibly_set(a,b) ((a) == 0 ? (b) : 0)
+
+int process_arguments (int, char **);
+int call_getopt (int, char **);
+void print_usage (void);
+void print_help (void);
+
+int wusers = -1;
+int cusers = -1;
+
+int
+main (int argc, char **argv)
+{
+        int users = -1;
+        int result = STATE_OK;
+        char input_buffer[MAX_INPUT_BUFFER];
+
+        if (process_arguments (argc, argv) == ERROR)
+                usage ("Could not parse arguments\n");
+
+        /* run the command */
+        child_process = spopen (WHO_COMMAND);
+        if (child_process == NULL) {
+                printf ("Could not open pipe: %s\n", WHO_COMMAND);
+                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", WHO_COMMAND);
+
+        users = 0;
+
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+
+                /* increment 'users' on all lines except total user count */
+                if (input_buffer[0] != '#') {
+                        users++;
+                        continue;
+                }
+
+                /* get total logged in users */
+                if (sscanf (input_buffer, "# users=%d", &users) == 1)
+                        break;
+
+        }
+
+        /* check STDERR */
+        if (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
+                result = possibly_set (result, STATE_UNKNOWN);
+        (void) fclose (child_stderr);
+
+        /* close the pipe */
+        if (spclose (child_process))
+                result = possibly_set (result, STATE_UNKNOWN);
+
+        /* else check the user count against warning and critical thresholds */
+        if (users >= cusers)
+                result = STATE_CRITICAL;
+        else if (users >= wusers)
+                result = STATE_WARNING;
+        else if (users >= 0)
+                result = STATE_OK;
+
+        if (result == STATE_UNKNOWN)
+                printf ("Unable to read output\n");
+        else
+                printf ("USERS %s - %d users currently logged in\n", state_text (result),
+                                                users);
+
+        return result;
+}
+
+
+
+
+
+/* process command-line arguments */
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+        if (argc < 2)
+                usage ("\n");
+
+        c = 0;
+        while ((c += call_getopt (argc - c, &argv[c])) < argc) {
+
+                if (is_option (argv[c]))
+                        continue;
+
+                if (wusers == -1 && argc > c) {
+                        if (is_intnonneg (argv[c]) == FALSE)
+                                usage ("Warning threshold must be a nonnegative integer\n");
+                        wusers = atoi (argv[c]);
+
+                }
+                else if (cusers == -1 && argc > c) {
+                        if (is_intnonneg (argv[c]) == FALSE)
+                                usage ("Warning threshold must be a nonnegative integer\n");
+                        cusers = atoi (argv[c]);
+                }
+        }
+
+        return OK;
+}
+
+
+
+
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 0;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"version", no_argument, 0, 'V'},
+                {"help", no_argument, 0, 'h'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c = getopt_long (argc, argv, "+hVvc:w:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+hVvc:w:");
+#endif
+
+                i++;
+
+                if (c == -1 || c == EOF || c == 1)
+                        break;
+
+                switch (c) {
+                case 'c':
+                case 'w':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* print short usage statement if args not parsable */
+                        printf ("%s: Unknown argument: %s\n\n", my_basename (argv[0]), optarg);
+                        print_usage ();
+                        exit (STATE_UNKNOWN);
+                case 'h':                                                                       /* help */
+                        print_help ();
+                        exit (STATE_OK);
+                case 'V':                                                                       /* version */
+                        print_revision (my_basename (argv[0]), "$Revision$");
+                        exit (STATE_OK);
+                case 'c':                                                                       /* critical */
+                        if (!is_intnonneg (optarg))
+                                usage ("Critical threshold must be a nonnegative integer\n");
+                        cusers = atoi (optarg);
+                        break;
+                case 'w':                                                                       /* warning */
+                        if (!is_intnonneg (optarg))
+                                usage ("Warning threshold must be a nonnegative integer\n");
+                        wusers = atoi (optarg);
+                        break;
+                }
+        }
+        return i;
+}
+
+
+
+
+
+void
+print_usage (void)
+{
+        printf ("Usage: %s -w <users> -c <users>\n", PROGNAME);
+}
+
+
+
+
+
+void
+print_help (void)
+{
+        print_revision (PROGNAME, "$Revision$");
+        printf
+                ("Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)\n\n"
+                 "This plugin checks the number of users currently logged in on the local\n"
+                 "system and generates an error if the number exceeds the thresholds specified.\n");
+        print_usage ();
+        printf
+                ("Options:\n"
+                 " -w, --warning=INTEGER\n"
+                 "    Set WARNING status if more than INTEGER users are logged in\n"
+                 " -c, --critical=INTEGER\n"
+                 "    Set CRITICAL status if more than INTEGER users are logged in\n"
+                 " -h, --help\n"
+                 "    Print detailed help screen\n"
+                 " -V, --version\n" "    Print version information\n");
+}
diff --git a/plugins/check_vsz.c b/plugins/check_vsz.c
new file mode 100644
index 00000000..c8ca82bd
--- /dev/null
+++ b/plugins/check_vsz.c
@@ -0,0 +1,287 @@
+/******************************************************************************
+ *
+ * CHECK_VSZ.C
+ *
+ * Program: Process plugin for Nagios
+ * License: GPL
+ * Copyright (c) 1999,2000 Karl DeBisschop <kdebiss@alum.mit.edu>
+ *
+ * Last Modified: $Date$
+ *
+ * Description:
+ *
+ * This plugin will check for processes whose total image size exceeds
+ * the warning or critical thresholds given on the command line.   With
+ * no command_name, everything that shows up on ps is evaluated.
+ * Otherwise, only jobs with the command_name given are examined.
+ * This program is particularly useful if you have to run a piece of
+ * commercial software that has a memory leak.  With it you can shut
+ * down and restart the processes whenever the program threatens to
+ * take over your system.
+ *
+ * Modifications:
+ *
+ * 11-18-1999 Karl DeBisschop (kdebiss@alum.mit.edu)
+ *            change to getopt, use print_help
+ * 08-18-1999 Ethan Galstad (nagios@nagios.org)
+ *            Changed code to use common include file
+ *            Changed fclose() to pclose()
+ * 09-09-1999 Ethan Galstad (nagios@nagios.org)
+ *            Changed popen()/pclose() to spopen()/spclose()
+ * 11-18-1999 Karl DeBisschop (kdebiss@alum.mit.edu)
+ *            set STATE_WARNING of stderr written or nonzero status returned
+ *
+ *****************************************************************************/
+
+#include "common.h"
+#include "popen.h"
+#include "utils.h"
+
+int process_arguments (int argc, char **argv);
+int call_getopt (int argc, char **argv);
+void print_help (char *cmd);
+void print_usage (char *cmd);
+
+int warn = -1;
+int crit = -1;
+char *proc = NULL;
+
+int
+main (int argc, char **argv)
+{
+        int len;
+        int result = STATE_OK;
+        int line = 0;
+        int proc_size = -1;
+        char input_buffer[MAX_INPUT_BUFFER];
+        char proc_name[MAX_INPUT_BUFFER];
+        char *message = NULL;
+
+        if (!process_arguments (argc, argv)) {
+                printf ("%s: failure parsing arguments\n", my_basename (argv[0]));
+                print_help (my_basename (argv[0]));
+                return STATE_UNKNOWN;
+        }
+
+        /* run the command */
+        child_process = spopen (VSZ_COMMAND);
+        if (child_process == NULL) {
+                printf ("Unable to open pipe: %s\n", VSZ_COMMAND);
+                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", VSZ_COMMAND);
+
+        message = malloc ((size_t) 1);
+        message[0] = 0;
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+
+                line++;
+
+                /* skip the first line */
+                if (line == 1)
+                        continue;
+
+                if (sscanf (input_buffer, VSZ_FORMAT, &proc_size, proc_name) == 2) {
+                        if (proc == NULL) {
+                                if (proc_size > warn) {
+                                        len = strlen (message) + strlen (proc_name) + 23;
+                                        message = realloc (message, len);
+                                        if (message == NULL)
+                                                terminate (STATE_UNKNOWN,
+                                                                                         "check_vsz: could not malloc message (1)");
+                                        sprintf (message, "%s %s(%d)", message, proc_name, proc_size);
+                                        result = max (result, STATE_WARNING);
+                                }
+                                if (proc_size > crit) {
+                                        result = STATE_CRITICAL;
+                                }
+                        }
+                        else if (strstr (proc_name, proc)) {
+                                len = strlen (message) + 21;
+                                message = realloc (message, len);
+                                if (message == NULL)
+                                        terminate (STATE_UNKNOWN,
+                                                                                 "check_vsz: could not malloc message (2)");
+                                sprintf (message, "%s %d", message, proc_size);
+                                if (proc_size > warn) {
+                                        result = max (result, STATE_WARNING);
+                                }
+                                if (proc_size > crit) {
+                                        result = STATE_CRITICAL;
+                                }
+                        }
+                }
+        }
+
+        /* If we get anything on STDERR, at least set warning */
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
+                result = max (result, STATE_WARNING);
+
+        (void) fclose (child_stderr);
+
+        /* close the pipe */
+        if (spclose (child_process))
+                result = max (result, STATE_WARNING);
+
+        if (result == STATE_OK)
+                printf ("ok (all VSZ<%d): %s\n", warn, message);
+        else if (result == STATE_UNKNOWN)
+                printf ("Unable to read output\n");
+        else if (result == STATE_WARNING)
+                printf ("WARNING (VSZ>%d):%s\n", warn, message);
+        else
+                printf ("CRITICAL (VSZ>%d):%s\n", crit, message);
+
+        return result;
+}
+
+
+
+
+int
+process_arguments (int argc, char **argv)
+{
+        int c;
+
+        if (argc < 2)
+                return ERROR;
+
+        c = 0;
+        while (c += (call_getopt (argc - c, &argv[c]))) {
+                if (argc <= c)
+                        break;
+                if (warn == -1) {
+                        if (!is_intnonneg (argv[c])) {
+                                printf ("%s: critical threshold must be an integer: %s\n",
+                                                                my_basename (argv[0]), argv[c]);
+                                print_usage (my_basename (argv[0]));
+                                exit (STATE_UNKNOWN);
+                        }
+                        warn = atoi (argv[c]);
+                }
+                else if (crit == -1) {
+                        if (!is_intnonneg (argv[c])) {
+                                printf ("%s: critical threshold must be an integer: %s\n",
+                                                                my_basename (argv[0]), argv[c]);
+                                print_usage (my_basename (argv[0]));
+                                exit (STATE_UNKNOWN);
+                        }
+                        crit = atoi (argv[c]);
+                }
+                else if (proc == NULL) {
+                        proc = malloc (strlen (argv[c]) + 1);
+                        if (proc == NULL)
+                                terminate (STATE_UNKNOWN,
+                                                                         "check_vsz: failed malloc of proc in process_arguments");
+                        strcpy (proc, argv[c]);
+                }
+        }
+        return c;
+}
+
+int
+call_getopt (int argc, char **argv)
+{
+        int c, i = 1;
+
+#ifdef HAVE_GETOPT_H
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"help", no_argument, 0, 'h'},
+                {"version", no_argument, 0, 'V'},
+                {"critical", required_argument, 0, 'c'},
+                {"warning", required_argument, 0, 'w'},
+                {"command", required_argument, 0, 'C'},
+                {0, 0, 0, 0}
+        };
+#endif
+
+        while (1) {
+#ifdef HAVE_GETOPT_H
+                c = getopt_long (argc, argv, "+hVc:w:C:", long_options, &option_index);
+#else
+                c = getopt (argc, argv, "+hVc:w:C:");
+#endif
+                if (c == EOF)
+                        break;
+
+                i++;
+                switch (c) {
+                case 'c':
+                case 'w':
+                case 'C':
+                        i++;
+                }
+
+                switch (c) {
+                case '?':                                                                       /* help */
+                        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$");
+                        exit (STATE_OK);
+                case 'c':                                                                       /* critical threshold */
+                        if (!is_intnonneg (optarg)) {
+                                printf ("%s: critical threshold must be an integer: %s\n",
+                                                                my_basename (argv[0]), optarg);
+                                print_usage (my_basename (argv[0]));
+                                exit (STATE_UNKNOWN);
+                        }
+                        crit = atoi (optarg);
+                        break;
+                case 'w':                                                                       /* warning threshold */
+                        if (!is_intnonneg (optarg)) {
+                                printf ("%s: warning threshold must be an integer: %s\n",
+                                                                my_basename (argv[0]), optarg);
+                                print_usage (my_basename (argv[0]));
+                                exit (STATE_UNKNOWN);
+                        }
+                        warn = atoi (optarg);
+                        break;
+                case 'C':                                                                       /* command name */
+                        proc = malloc (strlen (optarg) + 1);
+                        if (proc == NULL)
+                                terminate (STATE_UNKNOWN,
+                                                                         "check_vsz: failed malloc of proc in process_arguments");
+                        strcpy (proc, optarg);
+                        break;
+                }
+        }
+        return i;
+}
+
+void
+print_usage (char *cmd)
+{
+        printf ("Usage: %s -w <wsize> -c <csize> [-C command]\n"
+                                        "       %s --help\n" "       %s --version\n", cmd, cmd, cmd);
+}
+
+void
+print_help (char *cmd)
+{
+        print_revision ("check_vsz", "$Revision$");
+        printf
+                ("Copyright (c) 2000 Karl DeBisschop <kdebiss@alum.mit.edu>\n\n"
+                 "This plugin checks the image size of a running program and returns an\n"
+                 "error if the number is above either of the thresholds given.\n\n");
+        print_usage (cmd);
+        printf
+                ("\nOptions:\n"
+                 " -h, --help\n"
+                 "    Print detailed help\n"
+                 " -V, --version\n"
+                 "    Print version numbers and license information\n"
+                 " -w, --warning=INTEGER\n"
+                 "    Program image size necessary to cause a WARNING state\n"
+                 " -c, --critical=INTEGER\n"
+                 "    Program image size necessary to cause a CRITICAL state\n"
+                 " -C, --command=STRING\n" "    Program to search for [optional]\n");
+}
diff --git a/plugins/common.h.in b/plugins/common.h.in
new file mode 100644
index 00000000..9cb4bcbb
--- /dev/null
+++ b/plugins/common.h.in
@@ -0,0 +1,159 @@
+/******************************************************************************
+ *
+ * Nagios plugins common include file
+ *
+ * License: GPL
+ * Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+ *
+ * Last Modified: 11-05-1999
+ *
+ * Description:
+ *
+ * This file contains common include files and defines used in many of
+ * the plugins.
+ *
+ * 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 <stdio.h>                                                      /* obligatory includes */
+#include <stdlib.h>
+#include <errno.h>
+
+#include "config.h"
+
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# ifdef HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+
+/* #ifdef HAVE_GETOPT_H */
+#include <getopt.h>
+/* #endif */
+
+#include <ctype.h>
+
+
+/*
+ *
+ * Missing Functions
+ *
+ */
+
+#ifndef HAVE_STRTOL
+# define strtol(a,b,c) atol((a))
+#endif
+
+#ifndef HAVE_STRTOUL
+# define strtoul(a,b,c) (unsigned long)atol((a))
+#endif
+
+/*
+ *
+ * Standard Values
+ *
+ */
+
+#define OK              0
+#define ERROR           -1
+
+#define TRUE            1
+#define FALSE           0
+
+#define STATE_CRITICAL  2                               /* service state return codes */
+#define STATE_WARNING   1
+#define STATE_OK        0
+#define STATE_UNKNOWN   -1
+#define STATE_DEPENDENT -2
+
+#define DEFAULT_SOCKET_TIMEOUT  10      /* timeout after 10 seconds */
+
+#define MAX_INPUT_BUFFER        1024    /* max size of most buffers we use */
+
+#define MAX_HOST_ADDRESS_LENGTH 256     /* max size of a host address */
+
+
+#ifndef HAVE_SNPRINTF
+/*
+int snprintf (char *str, size_t n, const char *fmt, ...);
+int snprintf (char *str, size_t n, const char *fmt, ...)
+{
+        char *buf;
+        int i;
+        int j=0;
+        va_list ap;
+        int d;
+        char c, *p, *s;
+        
+        if((buf=malloc(n))==NULL){ 
+                puts("could not malloc snprintf buffer\n");
+                exit(-1);
+        }
+        va_start(ap,fmt);
+        i=strlen(fmt);
+        while((jj=index(&fmt[j],'%'))){
+                j+=jj+1;
+                switch fmt[j]
+                        {
+                        case 's':
+                                s = va_arg(ap, char *);
+                                i+=strlen(s);
+                                break;
+                        case 'd':
+                                d = va_arg(ap, int);
+                                i++;
+                                if (d<0) i++;
+                                while((d=d/10)>0) i++;
+                                break;
+                        case 'c':
+                                c = va_arg(ap, char);
+                                i++;
+                                break;
+                        }
+        }
+        va_end(ap);
+        vsprintf(buf,fmt,ap);
+        strcpy(str,buf[1:n-1]);
+        exit(result);
+}
+*/
+#endif
diff --git a/plugins/getopt.c b/plugins/getopt.c
new file mode 100644
index 00000000..364a1459
--- /dev/null
+++ b/plugins/getopt.c
@@ -0,0 +1,724 @@
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
+   before changing it!
+
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95
+        Free Software Foundation, Inc.
+
+   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, 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
+   Ditto for AIX 3.2 and <stdlib.h>.  */
+#ifndef _NO_PROTO
+#define _NO_PROTO
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#if !defined (__STDC__) || !__STDC__
+/* This is a separate conditional since some stdc systems
+   reject `defined (const)'.  */
+#ifndef const
+#define const
+#endif
+#endif
+
+#include <stdio.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.  Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
+
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef  __GNU_LIBRARY__
+/* Don't include stdlib.h for non-GNU C libraries because some of them
+   contain conflicting prototypes for getopt.  */
+#include <stdlib.h>
+#endif /* GNU C library.  */
+
+#ifndef _
+/* This is for other GNU distributions with internationalized messages.
+   When compiling libc, the _ macro is predefined.  */
+#ifdef HAVE_LIBINTL_H
+# include <libintl.h>
+# define _(msgid)       gettext (msgid)
+#else
+# define _(msgid)       (msgid)
+#endif
+#endif
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+#include "getopt.h"
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+char *optarg = NULL;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+/* XXX 1003.2 says this must be 1 before any call.  */
+int optind = 0;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+   for unrecognized options.  */
+
+int opterr = 1;
+
+/* Set to an option character which was unrecognized.
+   This must be initialized on some systems to avoid linking in the
+   system's own getopt implementation.  */
+
+int optopt = '?';
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect options and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
+
+static enum
+{
+        REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+}
+ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+static char *posixly_correct;
+
+#ifdef  __GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
+#include <string.h>
+#define my_index        strchr
+#else
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+char *getenv ();
+
+static char *
+my_index (str, chr)
+                 const char *str;
+                 int chr;
+{
+        while (*str) {
+                if (*str == chr)
+                        return (char *) str;
+                str++;
+        }
+        return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+   If not using GCC, it is ok not to declare it.  */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+   That was relevant to code that was here before.  */
+#if !defined (__STDC__) || !__STDC__
+/* gcc with -traditional declares the built-in strlen to return int,
+   and has done so at least since version 2.4.5. -- rms.  */
+extern int strlen (const char *);
+#endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,optind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+static void
+exchange (argv)
+                 char **argv;
+{
+        int bottom = first_nonopt;
+        int middle = last_nonopt;
+        int top = optind;
+        char *tem;
+
+        /* Exchange the shorter segment with the far end of the longer segment.
+           That puts the shorter segment into the right place.
+           It leaves the longer segment in the right place overall,
+           but it consists of two parts that need to be swapped next.  */
+
+        while (top > middle && middle > bottom) {
+                if (top - middle > middle - bottom) {
+                        /* Bottom segment is the short one.  */
+                        int len = middle - bottom;
+                        register int i;
+
+                        /* Swap it with the top part of the top segment.  */
+                        for (i = 0; i < len; i++) {
+                                tem = argv[bottom + i];
+                                argv[bottom + i] = argv[top - (middle - bottom) + i];
+                                argv[top - (middle - bottom) + i] = tem;
+                        }
+                        /* Exclude the moved bottom segment from further swapping.  */
+                        top -= len;
+                }
+                else {
+                        /* Top segment is the short one.  */
+                        int len = top - middle;
+                        register int i;
+
+                        /* Swap it with the bottom part of the bottom segment.  */
+                        for (i = 0; i < len; i++) {
+                                tem = argv[bottom + i];
+                                argv[bottom + i] = argv[middle + i];
+                                argv[middle + i] = tem;
+                        }
+                        /* Exclude the moved top segment from further swapping.  */
+                        bottom += len;
+                }
+        }
+
+        /* Update records for the slots the non-options now occupy.  */
+
+        first_nonopt += (optind - last_nonopt);
+        last_nonopt = optind;
+}
+
+/* Initialize the internal data when the first call is made.  */
+
+static const char *
+_getopt_initialize (optstring)
+                 const char *optstring;
+{
+        /* Start processing options with ARGV-element 1 (since ARGV-element 0
+           is the program name); the sequence of previously skipped
+           non-option ARGV-elements is empty.  */
+
+        first_nonopt = last_nonopt = optind = 1;
+
+        nextchar = NULL;
+
+        posixly_correct = getenv ("POSIXLY_CORRECT");
+
+        /* Determine how to handle the ordering of options and nonoptions.  */
+
+        if (optstring[0] == '-') {
+                ordering = RETURN_IN_ORDER;
+                ++optstring;
+        }
+        else if (optstring[0] == '+') {
+                ordering = REQUIRE_ORDER;
+                ++optstring;
+        }
+        else if (posixly_correct != NULL)
+                ordering = REQUIRE_ORDER;
+        else
+                ordering = PERMUTE;
+
+        return optstring;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.  If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `optind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns `EOF'.
+   Then `optind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.  If you set `opterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `optarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `optarg', otherwise `optarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct option' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.  */
+
+int
+_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+                 int argc;
+                 char *const *argv;
+                 const char *optstring;
+                 const struct option *longopts;
+                 int *longind;
+                 int long_only;
+{
+        optarg = NULL;
+
+        if (optind == 0) {
+                optstring = _getopt_initialize (optstring);
+                optind = 1;                                                                     /* Don't scan ARGV[0], the program name.  */
+        }
+
+        if (nextchar == NULL || *nextchar == '\0') {
+                /* Advance to the next ARGV-element.  */
+
+                if (ordering == PERMUTE) {
+                        /* If we have just processed some options following some non-options,
+                           exchange them so that the options come first.  */
+
+                        if (first_nonopt != last_nonopt && last_nonopt != optind)
+                                exchange ((char **) argv);
+                        else if (last_nonopt != optind)
+                                first_nonopt = optind;
+
+                        /* Skip any additional non-options
+                           and extend the range of non-options previously skipped.  */
+
+                        while (optind < argc
+                                                 && (argv[optind][0] != '-' || argv[optind][1] == '\0')) optind++;
+                        last_nonopt = optind;
+                }
+
+                /* The special ARGV-element `--' means premature end of options.
+                   Skip it like a null option,
+                   then exchange with previous non-options as if it were an option,
+                   then skip everything else like a non-option.  */
+
+                if (optind != argc && !strcmp (argv[optind], "--")) {
+                        optind++;
+
+                        if (first_nonopt != last_nonopt && last_nonopt != optind)
+                                exchange ((char **) argv);
+                        else if (first_nonopt == last_nonopt)
+                                first_nonopt = optind;
+                        last_nonopt = argc;
+
+                        optind = argc;
+                }
+
+                /* If we have done all the ARGV-elements, stop the scan
+                   and back over any non-options that we skipped and permuted.  */
+
+                if (optind == argc) {
+                        /* Set the next-arg-index to point at the non-options
+                           that we previously skipped, so the caller will digest them.  */
+                        if (first_nonopt != last_nonopt)
+                                optind = first_nonopt;
+                        return EOF;
+                }
+
+                /* If we have come to a non-option and did not permute it,
+                   either stop the scan or describe it to the caller and pass it by.  */
+
+                if ((argv[optind][0] != '-' || argv[optind][1] == '\0')) {
+                        if (ordering == REQUIRE_ORDER)
+                                return EOF;
+                        optarg = argv[optind++];
+                        return 1;
+                }
+
+                /* We have found another option-ARGV-element.
+                   Skip the initial punctuation.  */
+
+                nextchar = (argv[optind] + 1
+                                                                + (longopts != NULL && argv[optind][1] == '-'));
+        }
+
+        /* Decode the current option-ARGV-element.  */
+
+        /* Check whether the ARGV-element is a long option.
+
+           If long_only and the ARGV-element has the form "-f", where f is
+           a valid short option, don't consider it an abbreviated form of
+           a long option that starts with f.  Otherwise there would be no
+           way to give the -f short option.
+
+           On the other hand, if there's a long option "fubar" and
+           the ARGV-element is "-fu", do consider that an abbreviation of
+           the long option, just like "--fu", and not "-f" with arg "u".
+
+           This distinction seems to be the most useful approach.  */
+
+        if (longopts != NULL
+                        && (argv[optind][1] == '-'
+                                        || (long_only
+                                                        && (argv[optind][2]
+                                                                        || !my_index (optstring, argv[optind][1]))))) {
+                char *nameend;
+                const struct option *p;
+                const struct option *pfound = NULL;
+                int exact = 0;
+                int ambig = 0;
+                int indfound;
+                int option_index;
+
+                for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+                        /* Do nothing.  */ ;
+
+                /* Test all long options for either exact match
+                   or abbreviated matches.  */
+                for (p = longopts, option_index = 0; p->name; p++, option_index++)
+                        if (!strncmp (p->name, nextchar, nameend - nextchar)) {
+                                if (nameend - nextchar == strlen (p->name)) {
+                                        /* Exact match found.  */
+                                        pfound = p;
+                                        indfound = option_index;
+                                        exact = 1;
+                                        break;
+                                }
+                                else if (pfound == NULL) {
+                                        /* First nonexact match found.  */
+                                        pfound = p;
+                                        indfound = option_index;
+                                }
+                                else
+                                        /* Second or later nonexact match found.  */
+                                        ambig = 1;
+                        }
+
+                if (ambig && !exact) {
+                        if (opterr)
+                                fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
+                                                                 argv[0], argv[optind]);
+                        nextchar += strlen (nextchar);
+                        optind++;
+                        return '?';
+                }
+
+                if (pfound != NULL) {
+                        option_index = indfound;
+                        optind++;
+                        if (*nameend) {
+                                /* Don't test has_arg with >, because some C compilers don't
+                                   allow it to be used on enums.  */
+                                if (pfound->has_arg)
+                                        optarg = nameend + 1;
+                                else {
+                                        if (opterr)
+                                                if (argv[optind - 1][1] == '-')
+                                                        /* --option */
+                                                        fprintf (stderr,
+                                                                                         _("%s: option `--%s' doesn't allow an argument\n"),
+                                                                                         argv[0], pfound->name);
+                                                else
+                                                        /* +option or -option */
+                                                        fprintf (stderr,
+                                                                                         _("%s: option `%c%s' doesn't allow an argument\n"),
+                                                                                         argv[0], argv[optind - 1][0], pfound->name);
+
+                                        nextchar += strlen (nextchar);
+                                        return '?';
+                                }
+                        }
+                        else if (pfound->has_arg == 1) {
+                                if (optind < argc)
+                                        optarg = argv[optind++];
+                                else {
+                                        if (opterr)
+                                                fprintf (stderr,
+                                                                                 _("%s: option `%s' requires an argument\n"),
+                                                                                 argv[0], argv[optind - 1]);
+                                        nextchar += strlen (nextchar);
+                                        return optstring[0] == ':' ? ':' : '?';
+                                }
+                        }
+                        nextchar += strlen (nextchar);
+                        if (longind != NULL)
+                                *longind = option_index;
+                        if (pfound->flag) {
+                                *(pfound->flag) = pfound->val;
+                                return 0;
+                        }
+                        return pfound->val;
+                }
+
+                /* Can't find it as a long option.  If this is not getopt_long_only,
+                   or the option starts with '--' or is not a valid short
+                   option, then it's an error.
+                   Otherwise interpret it as a short option.  */
+                if (!long_only || argv[optind][1] == '-'
+                                || my_index (optstring, *nextchar) == NULL) {
+                        if (opterr) {
+                                if (argv[optind][1] == '-')
+                                        /* --option */
+                                        fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
+                                                                         argv[0], nextchar);
+                                else
+                                        /* +option or -option */
+                                        fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
+                                                                         argv[0], argv[optind][0], nextchar);
+                        }
+                        nextchar = (char *) "";
+                        optind++;
+                        return '?';
+                }
+        }
+
+        /* Look at and handle the next short option-character.  */
+
+        {
+                char c = *nextchar++;
+                char *temp = my_index (optstring, c);
+
+                /* Increment `optind' when we start to process its last character.  */
+                if (*nextchar == '\0')
+                        ++optind;
+
+                if (temp == NULL || c == ':') {
+                        if (opterr) {
+                                if (posixly_correct)
+                                        /* 1003.2 specifies the format of this message.  */
+                                        fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c);
+                                else
+                                        fprintf (stderr, _("%s: invalid option -- %c\n"), argv[0], c);
+                        }
+                        optopt = c;
+                        return '?';
+                }
+                if (temp[1] == ':') {
+                        if (temp[2] == ':') {
+                                /* This is an option that accepts an argument optionally.  */
+                                if (*nextchar != '\0') {
+                                        optarg = nextchar;
+                                        optind++;
+                                }
+                                else
+                                        optarg = NULL;
+                                nextchar = NULL;
+                        }
+                        else {
+                                /* This is an option that requires an argument.  */
+                                if (*nextchar != '\0') {
+                                        optarg = nextchar;
+                                        /* If we end this ARGV-element by taking the rest as an arg,
+                                           we must advance to the next element now.  */
+                                        optind++;
+                                }
+                                else if (optind == argc) {
+                                        if (opterr) {
+                                                /* 1003.2 specifies the format of this message.  */
+                                                fprintf (stderr,
+                                                                                 _("%s: option requires an argument -- %c\n"),
+                                                                                 argv[0], c);
+                                        }
+                                        optopt = c;
+                                        if (optstring[0] == ':')
+                                                c = ':';
+                                        else
+                                                c = '?';
+                                }
+                                else
+                                        /* We already incremented `optind' once;
+                                           increment it again when taking next ARGV-elt as argument.  */
+                                        optarg = argv[optind++];
+                                nextchar = NULL;
+                        }
+                }
+                return c;
+        }
+}
+
+int
+getopt (argc, argv, optstring)
+                 int argc;
+                 char *const *argv;
+                 const char *optstring;
+{
+        return _getopt_internal (argc, argv, optstring,
+                                                                                                         (const struct option *) 0, (int *) 0, 0);
+}
+
+#endif /* _LIBC or not __GNU_LIBRARY__.  */
+
+#ifdef TEST
+
+/* Compile with -DTEST to make an executable for use in testing
+   the above definition of `getopt'.  */
+
+int
+main (argc, argv)
+                 int argc;
+                 char **argv;
+{
+        int c;
+        int digit_optind = 0;
+
+        while (1) {
+                int this_option_optind = optind ? optind : 1;
+
+                c = getopt (argc, argv, "abc:d:0123456789");
+                if (c == EOF)
+                        break;
+
+                switch (c) {
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                        if (digit_optind != 0 && digit_optind != this_option_optind)
+                                printf ("digits occur in two different argv-elements.\n");
+                        digit_optind = this_option_optind;
+                        printf ("option %c\n", c);
+                        break;
+
+                case 'a':
+                        printf ("option a\n");
+                        break;
+
+                case 'b':
+                        printf ("option b\n");
+                        break;
+
+                case 'c':
+                        printf ("option c with value `%s'\n", optarg);
+                        break;
+
+                case '?':
+                        break;
+
+                default:
+                        printf ("?? getopt returned character code 0%o ??\n", c);
+                }
+        }
+
+        if (optind < argc) {
+                printf ("non-option ARGV-elements: ");
+                while (optind < argc)
+                        printf ("%s ", argv[optind++]);
+                printf ("\n");
+        }
+
+        exit (0);
+}
+
+#endif /* TEST */
diff --git a/plugins/getopt1.c b/plugins/getopt1.c
new file mode 100644
index 00000000..bbac373b
--- /dev/null
+++ b/plugins/getopt1.c
@@ -0,0 +1,176 @@
+/* getopt_long and getopt_long_only entry points for GNU getopt.
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 1993, 1994
+        Free Software Foundation, Inc.
+
+   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, 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "getopt.h"
+
+#if !defined (__STDC__) || !__STDC__
+/* This is a separate conditional since some stdc systems
+   reject `defined (const)'.  */
+#ifndef const
+#define const
+#endif
+#endif
+
+#include <stdio.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.  Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
+
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef __GNU_LIBRARY__
+#include <stdlib.h>
+#else
+char *getenv ();
+#endif
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+int
+getopt_long (argc, argv, options, long_options, opt_index)
+                 int argc;
+                 char *const *argv;
+                 const char *options;
+                 const struct option *long_options;
+                 int *opt_index;
+{
+        return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
+}
+
+/* Like getopt_long, but '-' as well as '--' can indicate a long option.
+   If an option that starts with '-' (not '--') doesn't match a long option,
+   but does match a short option, it is parsed as a short option
+   instead.  */
+
+int
+getopt_long_only (argc, argv, options, long_options, opt_index)
+                 int argc;
+                 char *const *argv;
+                 const char *options;
+                 const struct option *long_options;
+                 int *opt_index;
+{
+        return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
+}
+
+
+#endif /* _LIBC or not __GNU_LIBRARY__.  */
+
+#ifdef TEST
+
+#include <stdio.h>
+
+int
+main (argc, argv)
+                 int argc;
+                 char **argv;
+{
+        int c;
+        int digit_optind = 0;
+
+        while (1) {
+                int this_option_optind = optind ? optind : 1;
+                int option_index = 0;
+                static struct option long_options[] = {
+                        {"add", 1, 0, 0},
+                        {"append", 0, 0, 0},
+                        {"delete", 1, 0, 0},
+                        {"verbose", 0, 0, 0},
+                        {"create", 0, 0, 0},
+                        {"file", 1, 0, 0},
+                        {0, 0, 0, 0}
+                };
+
+                c = getopt_long (argc, argv, "abc:d:0123456789",
+                                                                                 long_options, &option_index);
+                if (c == EOF)
+                        break;
+
+                switch (c) {
+                case 0:
+                        printf ("option %s", long_options[option_index].name);
+                        if (optarg)
+                                printf (" with arg %s", optarg);
+                        printf ("\n");
+                        break;
+
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                        if (digit_optind != 0 && digit_optind != this_option_optind)
+                                printf ("digits occur in two different argv-elements.\n");
+                        digit_optind = this_option_optind;
+                        printf ("option %c\n", c);
+                        break;
+
+                case 'a':
+                        printf ("option a\n");
+                        break;
+
+                case 'b':
+                        printf ("option b\n");
+                        break;
+
+                case 'c':
+                        printf ("option c with value `%s'\n", optarg);
+                        break;
+
+                case 'd':
+                        printf ("option d with value `%s'\n", optarg);
+                        break;
+
+                case '?':
+                        break;
+
+                default:
+                        printf ("?? getopt returned character code 0%o ??\n", c);
+                }
+        }
+
+        if (optind < argc) {
+                printf ("non-option ARGV-elements: ");
+                while (optind < argc)
+                        printf ("%s ", argv[optind++]);
+                printf ("\n");
+        }
+
+        exit (0);
+}
+
+#endif /* TEST */
diff --git a/plugins/netutils.c b/plugins/netutils.c
new file mode 100644
index 00000000..e5d35281
--- /dev/null
+++ b/plugins/netutils.c
@@ -0,0 +1,431 @@
+/****************************************************************************
+*
+* Nagios plugins network utilities
+*
+* License: GPL
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+*
+* Last Modified: $Date$
+*
+* Description:
+*
+* This file contains commons functions used in many of the plugins.
+*
+* 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 "config.h"
+#include "common.h"
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+extern int socket_timeout;
+RETSIGTYPE socket_timeout_alarm_handler (int);
+
+int process_tcp_request2 (char *, int, char *, char *, int);
+int process_tcp_request (char *, int, char *, char *, int);
+int process_udp_request (char *, int, char *, char *, int);
+int process_request (char *, int, char *, char *, char *, int);
+
+int my_tcp_connect (char *, int, int *);
+int my_udp_connect (char *, int, int *);
+int my_connect (char *, int, int *, char *);
+
+int my_inet_aton (register const char *, struct in_addr *);
+
+/* handles socket timeouts */
+void
+socket_timeout_alarm_handler (int sig)
+{
+
+        printf ("Socket timeout after %d seconds\n", socket_timeout);
+
+        exit (STATE_CRITICAL);
+}
+
+
+/* connects to a host on a specified TCP port, sends a string,
+   and gets a response */
+int
+process_tcp_request (char *server_address,
+                                                                                 int server_port,
+                                                                                 char *send_buffer, char *recv_buffer, int recv_size)
+{
+        int result;
+        char proto[4] = "tcp";
+
+        result = process_request (server_address,
+                                                                                                                server_port,
+                                                                                                                proto, send_buffer, recv_buffer, recv_size);
+
+        return result;
+}
+
+
+/* connects to a host on a specified UDP port, sends a string, and gets a
+    response */
+int
+process_udp_request (char *server_address,
+                                                                                 int server_port,
+                                                                                 char *send_buffer, char *recv_buffer, int recv_size)
+{
+        int result;
+        char proto[4] = "udp";
+
+        result = process_request (server_address,
+                                                                                                                server_port,
+                                                                                                                proto, send_buffer, recv_buffer, recv_size);
+
+        return result;
+}
+
+
+
+/* connects to a host on a specified tcp port, sends a string, and gets a 
+         response. loops on select-recv until timeout or eof to get all of a 
+         multi-packet answer */
+int
+process_tcp_request2 (char *server_address,
+                                                                                        int server_port,
+                                                                                        char *send_buffer, char *recv_buffer, int recv_size)
+{
+
+        int result;
+        int send_result;
+        int recv_result;
+        int sd;
+        struct timeval tv;
+        fd_set readfds;
+        int recv_length = 0;
+
+        result = my_connect (server_address, server_port, &sd, "tcp");
+        if (result != STATE_OK)
+                return STATE_CRITICAL;
+
+        send_result = send (sd, send_buffer, strlen (send_buffer), 0);
+        if (send_result != strlen (send_buffer)) {
+                printf ("send() failed\n");
+                result = STATE_WARNING;
+        }
+
+        while (1) {
+                /* wait up to the number of seconds for socket timeout
+                   minus one for data from the host */
+                tv.tv_sec = socket_timeout - 1;
+                tv.tv_usec = 0;
+                FD_ZERO (&readfds);
+                FD_SET (sd, &readfds);
+                select (sd + 1, &readfds, NULL, NULL, &tv);
+
+                /* make sure some data has arrived */
+                if (!FD_ISSET (sd, &readfds)) { /* it hasn't */
+                        if (!recv_length) {
+                                strcpy (recv_buffer, "");
+                                printf ("No data was recieved from host!\n");
+                                result = STATE_WARNING;
+                        }
+                        else {                                                                          /* this one failed, but previous ones worked */
+                                recv_buffer[recv_length] = 0;
+                        }
+                        break;
+                }
+                else {                                                                                  /* it has */
+                        recv_result =
+                                recv (sd, recv_buffer + recv_length, recv_size - recv_length - 1, 0);
+                        if (recv_result == -1) {        /* recv failed, bail out */
+                                strcpy (recv_buffer + recv_length, "");
+                                result = STATE_WARNING;
+                                break;
+                        }
+                        else if (recv_result == 0) {    /* end of file ? */
+                                recv_buffer[recv_length] = 0;
+                                break;
+                        }
+                        else {                                                                          /* we got data! */
+                                recv_length += recv_result;
+                                if (recv_length >= recv_size - 1) {     /* buffer full, we're done */
+                                        recv_buffer[recv_size - 1] = 0;
+                                        break;
+                                }
+                        }
+                }                                                                                                               /* end if(!FD_ISSET(sd,&readfds)) */
+        }                                                                                                                       /* end while(1) */
+
+        close (sd);
+        return result;
+}
+
+/* connects to a host on a specified port, sends a string, and gets a 
+   response */
+int
+process_request (char *server_address,
+                                                                 int server_port,
+                                                                 char *proto,
+                                                                 char *send_buffer, char *recv_buffer, int recv_size)
+{
+        int result;
+        int send_result;
+        int recv_result;
+        int sd;
+        struct timeval tv;
+        fd_set readfds;
+
+        result = STATE_OK;
+
+        result = my_connect (server_address, server_port, &sd, proto);
+        if (result != STATE_OK)
+                return STATE_CRITICAL;
+
+        send_result = send (sd, send_buffer, strlen (send_buffer), 0);
+        if (send_result != strlen (send_buffer)) {
+                printf ("send() failed\n");
+                result = STATE_WARNING;
+        }
+
+        /* wait up to the number of seconds for socket timeout minus one 
+           for data from the host */
+        tv.tv_sec = socket_timeout - 1;
+        tv.tv_usec = 0;
+        FD_ZERO (&readfds);
+        FD_SET (sd, &readfds);
+        select (sd + 1, &readfds, NULL, NULL, &tv);
+
+        /* make sure some data has arrived */
+        if (!FD_ISSET (sd, &readfds)) {
+                strcpy (recv_buffer, "");
+                printf ("No data was recieved from host!\n");
+                result = STATE_WARNING;
+        }
+
+        else {
+                recv_result = recv (sd, recv_buffer, recv_size - 1, 0);
+                if (recv_result == -1) {
+                        strcpy (recv_buffer, "");
+                        if (!strcmp (proto, "tcp"))
+                                printf ("recv() failed\n");
+                        result = STATE_WARNING;
+                }
+                else
+                        recv_buffer[recv_result] = 0;
+
+                /* terminate returned string */
+                recv_buffer[recv_size - 1] = 0;
+        }
+
+        close (sd);
+
+        return result;
+}
+
+
+/* opens a connection to a remote host/tcp port */
+int
+my_tcp_connect (char *host_name, int port, int *sd)
+{
+        int result;
+        char proto[4] = "tcp";
+
+        result = my_connect (host_name, port, sd, proto);
+
+        return result;
+}
+
+
+/* opens a connection to a remote host/udp port */
+int
+my_udp_connect (char *host_name, int port, int *sd)
+{
+        int result;
+        char proto[4] = "udp";
+
+        result = my_connect (host_name, port, sd, proto);
+
+        return result;
+}
+
+
+/* opens a tcp or udp connection to a remote host */
+int
+my_connect (char *host_name, int port, int *sd, char *proto)
+{
+        struct sockaddr_in servaddr;
+        struct hostent *hp;
+        struct protoent *ptrp;
+        int result;
+
+        bzero ((char *) &servaddr, sizeof (servaddr));
+        servaddr.sin_family = AF_INET;
+        servaddr.sin_port = htons (port);
+
+        /* try to bypass using a DNS lookup if this is just an IP address */
+        if (!my_inet_aton (host_name, &servaddr.sin_addr)) {
+
+                /* else do a DNS lookup */
+                hp = gethostbyname ((const char *) host_name);
+                if (hp == NULL) {
+                        printf ("Invalid host name '%s'\n", host_name);
+                        return STATE_UNKNOWN;
+                }
+
+                memcpy (&servaddr.sin_addr, hp->h_addr, hp->h_length);
+        }
+
+        /* map transport protocol name to protocol number */
+        if ((ptrp = getprotobyname (proto)) == NULL) {
+                printf ("Cannot map \"%s\" to protocol number\n", proto);
+                return STATE_UNKNOWN;
+        }
+
+        /* create a socket */
+        *sd =
+                socket (PF_INET, (!strcmp (proto, "udp")) ? SOCK_DGRAM : SOCK_STREAM,
+                                                ptrp->p_proto);
+        if (*sd < 0) {
+                printf ("Socket creation failed\n");
+                return STATE_UNKNOWN;
+        }
+
+        /* open a connection */
+        result = connect (*sd, (struct sockaddr *) &servaddr, sizeof (servaddr));
+        if (result < 0) {
+                switch (errno) {
+                case ECONNREFUSED:
+                        printf ("Connection refused by host\n");
+                        break;
+                case ETIMEDOUT:
+                        printf ("Timeout while attempting connection\n");
+                        break;
+                case ENETUNREACH:
+                        printf ("Network is unreachable\n");
+                        break;
+                default:
+                        printf ("Connection refused or timed out\n");
+                }
+
+                return STATE_CRITICAL;
+        }
+
+        return STATE_OK;
+}
+
+
+
+/* This code was taken from Fyodor's nmap utility, which was originally
+         taken from the GLIBC 2.0.6 libraries because Solaris doesn't contain
+         the inet_aton() funtion. */
+int
+my_inet_aton (register const char *cp, struct in_addr *addr)
+{
+        register unsigned int val;              /* changed from u_long --david */
+        register int base, n;
+        register char c;
+        u_int parts[4];
+        register u_int *pp = parts;
+
+        c = *cp;
+
+        for (;;) {
+
+                /*
+                 * Collect number up to ``.''.
+                 * Values are specified as for C:
+                 * 0x=hex, 0=octal, isdigit=decimal.
+                 */
+                if (!isdigit ((int) c))
+                        return (0);
+                val = 0;
+                base = 10;
+
+                if (c == '0') {
+                        c = *++cp;
+                        if (c == 'x' || c == 'X')
+                                base = 16, c = *++cp;
+                        else
+                                base = 8;
+                }
+
+                for (;;) {
+                        if (isascii ((int) c) && isdigit ((int) c)) {
+                                val = (val * base) + (c - '0');
+                                c = *++cp;
+                        }
+                        else if (base == 16 && isascii ((int) c) && isxdigit ((int) c)) {
+                                val = (val << 4) | (c + 10 - (islower ((int) c) ? 'a' : 'A'));
+                                c = *++cp;
+                        }
+                        else
+                                break;
+                }
+
+                if (c == '.') {
+
+                        /*
+                         * Internet format:
+                         *  a.b.c.d
+                         *  a.b.c (with c treated as 16 bits)
+                         *  a.b (with b treated as 24 bits)
+                         */
+                        if (pp >= parts + 3)
+                                return (0);
+                        *pp++ = val;
+                        c = *++cp;
+                }
+                else
+                        break;
+        }
+
+        /* Check for trailing characters */
+        if (c != '\0' && (!isascii ((int) c) || !isspace ((int) c)))
+                return (0);
+
+        /* Concoct the address according to the number of parts specified */
+        n = pp - parts + 1;
+        switch (n) {
+
+        case 0:
+                return (0);                                                                     /* initial nondigit */
+
+        case 1:                                                                                 /* a -- 32 bits */
+                break;
+
+        case 2:                                                                                 /* a.b -- 8.24 bits */
+                if (val > 0xffffff)
+                        return (0);
+                val |= parts[0] << 24;
+                break;
+
+        case 3:                                                                                 /* a.b.c -- 8.8.16 bits */
+                if (val > 0xffff)
+                        return (0);
+                val |= (parts[0] << 24) | (parts[1] << 16);
+                break;
+
+        case 4:                                                                                 /* a.b.c.d -- 8.8.8.8 bits */
+                if (val > 0xff)
+                        return (0);
+                val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
+                break;
+        }
+
+        if (addr)
+                addr->s_addr = htonl (val);
+
+        return (1);
+}
diff --git a/plugins/netutils.h.in b/plugins/netutils.h.in
new file mode 100644
index 00000000..be4ae241
--- /dev/null
+++ b/plugins/netutils.h.in
@@ -0,0 +1,63 @@
+/******************************************************************************
+*
+* Nagios plugins net utilities include file
+*
+* License: GPL
+* Copyright (c) 1999 Ethan Galstad (nagios@nagios.org)
+*
+* Last Modified: $Date$
+*
+* Description:
+*
+* This file contains common include files and function definitions
+* used in many of the plugins.
+*
+* 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.
+*
+******************************************************************************/
+
+#undef STDC_HEADERS
+#undef HAVE_STRINGS_H
+#undef HAVE_STRING_H
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+void socket_timeout_alarm_handler (int);
+
+int process_tcp_request2 (char *address, int port, char *sbuffer,
+                                                                                                        char *rbuffer, int rsize);
+int process_tcp_request (char *address, int port, char *sbuffer,
+                                                                                                 char *rbuffer, int rsize);
+int process_udp_request (char *address, int port, char *sbuffer,
+                                                                                                 char *rbuffer, int rsize);
+int process_request (char *address, int port, char *proto, char *sbuffer,
+                                                                                 char *rbuffer, int rsize);
+
+int my_tcp_connect (char *address, int port, int *sd);
+int my_udp_connect (char *address, int port, int *sd);
+int my_connect (char *address, int port, int *sd, char *proto);
+
+int my_inet_aton (register const char *cp, struct in_addr *addr);
+
+#ifndef DEFAULT_SOCKET_TIMEOUT
+#include "config.h"
+#include "common.h"
+#endif
+int socket_timeout = DEFAULT_SOCKET_TIMEOUT;
diff --git a/plugins/popen.c b/plugins/popen.c
new file mode 100644
index 00000000..cde3c764
--- /dev/null
+++ b/plugins/popen.c
@@ -0,0 +1,314 @@
+/******************************************************************************
+ * popen.c
+ *
+ * A safe alternative to popen
+ * 
+ * Provides spopen and spclose
+
+FILE * spopen(const char *);
+int spclose(FILE *);
+
+ *
+ * Code taken with liitle modification from "Advanced Programming for the Unix
+ * Environment" by W. Richard Stevens
+ *
+ * This is considered safe in that no shell is spawned, and the environment and
+ * path passed to the exec'd program are esstially empty. (popen create a shell
+ * and passes the environment to it).
+ *
+ ******************************************************************************/
+
+#include <config.h>
+#include <common.h>
+
+/* extern so plugin has pid to kill exec'd process on timeouts */
+extern int timeout_interval;
+extern pid_t *childpid;
+extern int *child_stderr_array;
+extern FILE *child_process;
+
+FILE *spopen (const char *);
+int spclose (FILE *);
+RETSIGTYPE popen_timeout_alarm_handler (int);
+
+#include <stdarg.h>                                                     /* ANSI C header file */
+#include <fcntl.h>
+
+#include <limits.h>
+#include <sys/resource.h>
+
+#ifdef HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
+
+#ifndef WEXITSTATUS
+# define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
+#endif
+
+#ifndef WIFEXITED
+# define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
+#endif
+
+/* 4.3BSD Reno <signal.h> doesn't define SIG_ERR */
+#if defined(SIG_IGN) && !defined(SIG_ERR)
+#define SIG_ERR ((Sigfunc *)-1)
+#endif
+
+#define min(a,b)        ((a) < (b) ? (a) : (b))
+#define max(a,b)        ((a) > (b) ? (a) : (b))
+int open_max (void);                                            /* {Prog openmax} */
+void err_sys (const char *, ...);
+char *rtrim (char *, const char *);
+
+/*int *childerr = NULL;*//* ptr to array allocated at run-time */
+/*extern pid_t *childpid = NULL; *//* ptr to array allocated at run-time */
+static int maxfd;                                                               /* from our open_max(), {Prog openmax} */
+
+FILE *
+spopen (const char *cmdstring)
+{
+        char *environ[] = { NULL };
+        char *cmd = NULL;
+        char **argv = NULL;
+        char *str;
+        int argc;
+
+        int i = 0, pfd[2], pfderr[2];
+        pid_t pid;
+
+#ifdef  RLIMIT_CORE
+        /* do not leave core files */
+        struct rlimit limit;
+        getrlimit (RLIMIT_CORE, &limit);
+        limit.rlim_cur = 0;
+        setrlimit (RLIMIT_CORE, &limit);
+#endif
+
+        /* if no command was passed, return with no error */
+        if (cmdstring == NULL)
+                return (NULL);
+
+        /* make copy of command string so strtok() doesn't silently modify it */
+        /* (the calling program may want to access it later) */
+        cmd = malloc (strlen (cmdstring) + 1);
+        if (cmd == NULL)
+                return NULL;
+        strcpy (cmd, cmdstring);
+
+        /* This is not a shell, so we don't handle "???" */
+        if (strstr (cmdstring, "\""))
+                return NULL;
+
+        /* allow single quotes, but only if non-whitesapce doesn't occur on both sides */
+        if (strstr (cmdstring, " ' ") || strstr (cmdstring, "'''"))
+                return NULL;
+
+        /* there cannot be more args than characters */
+        argc = strlen (cmdstring) + 1;  /* add 1 for NULL termination */
+        argv = malloc (sizeof(char*)*argc);
+        if (argv == NULL) {
+                printf ("Could not malloc argv array in popen()\n");
+                return NULL;
+        }
+
+        /* loop to get arguments to command */
+        while (cmd) {
+                str = cmd;
+                str += strspn (str, " \t\r\n"); /* trim any leading whitespace */
+
+                if (i >= argc - 2) {
+                        printf ("You've got a big problem buddy! You need more args!!!\n");
+                        return (NULL);
+                }
+
+                if (strstr (str, "'") == str) { /* handle SIMPLE quoted strings */
+                        str++;
+                        if (!strstr (str, "'"))
+                                return NULL;                                            /* balanced? */
+                        cmd = 1 + strstr (str, "'");
+                        str[strcspn (str, "'")] = 0;
+                }
+                else {
+                        if (strpbrk (str, " \t\r\n")) {
+                                cmd = 1 + strpbrk (str, " \t\r\n");
+                                str[strcspn (str, " \t\r\n")] = 0;
+                        }
+                        else {
+                                cmd = NULL;
+                        }
+                }
+
+                if (cmd && strlen (cmd) == strspn (cmd, " \t\r\n"))
+                        cmd = NULL;
+
+                argv[i++] = str;
+
+        }
+        argv[i] = NULL;
+
+        if (childpid == NULL) {                         /* first time through */
+                maxfd = open_max ();                            /* allocate zeroed out array for child pids */
+                if ((childpid = calloc (maxfd, sizeof (pid_t))) == NULL)
+                        return (NULL);
+        }
+
+        if (child_stderr_array == NULL) {       /* first time through */
+                maxfd = open_max ();                            /* allocate zeroed out array for child pids */
+                if ((child_stderr_array = calloc (maxfd, sizeof (int))) == NULL)
+                        return (NULL);
+        }
+
+        if (pipe (pfd) < 0)
+                return (NULL);                                                  /* errno set by pipe() */
+
+        if (pipe (pfderr) < 0)
+                return (NULL);                                                  /* errno set by pipe() */
+
+        if ((pid = fork ()) < 0)
+                return (NULL);                                                  /* errno set by fork() */
+        else if (pid == 0) {                                    /* child */
+                close (pfd[0]);
+                if (pfd[1] != STDOUT_FILENO) {
+                        dup2 (pfd[1], STDOUT_FILENO);
+                        close (pfd[1]);
+                }
+                close (pfderr[0]);
+                if (pfderr[1] != STDERR_FILENO) {
+                        dup2 (pfderr[1], STDERR_FILENO);
+                        close (pfderr[1]);
+                }
+                /* close all descriptors in childpid[] */
+                for (i = 0; i < maxfd; i++)
+                        if (childpid[i] > 0)
+                                close (i);
+
+                execve (argv[0], argv, environ);
+                _exit (0);
+        }
+
+        close (pfd[1]);                                                         /* parent */
+        if ((child_process = fdopen (pfd[0], "r")) == NULL)
+                return (NULL);
+        close (pfderr[1]);
+
+        childpid[fileno (child_process)] = pid; /* remember child pid for this fd */
+        child_stderr_array[fileno (child_process)] = pfderr[0]; /* remember STDERR */
+        return (child_process);
+}
+
+int
+spclose (FILE * fp)
+{
+        int fd, stat;
+        pid_t pid;
+
+        if (childpid == NULL)
+                return (-1);                                                            /* popen() has never been called */
+
+        fd = fileno (fp);
+        if ((pid = childpid[fd]) == 0)
+                return (-1);                                                            /* fp wasn't opened by popen() */
+
+        childpid[fd] = 0;
+        if (fclose (fp) == EOF)
+                return (-1);
+
+        while (waitpid (pid, &stat, 0) < 0)
+                if (errno != EINTR)
+                        return (-1);                                                    /* error other than EINTR from waitpid() */
+
+        if (WIFEXITED (stat))
+                return (WEXITSTATUS (stat));    /* return child's termination status */
+
+        return (STATE_UNKNOWN);
+}
+
+#ifdef  OPEN_MAX
+static int openmax = OPEN_MAX;
+#else
+static int openmax = 0;
+#endif
+
+#define OPEN_MAX_GUESS  256                     /* if OPEN_MAX is indeterminate */
+                                /* no guarantee this is adequate */
+
+void
+popen_timeout_alarm_handler (int signo)
+{
+        if (signo == SIGALRM) {
+                kill (childpid[fileno (child_process)], SIGKILL);
+                printf ("CRITICAL - Plugin timed out after %d seconds\n",
+                                                timeout_interval);
+                exit (STATE_CRITICAL);
+        }
+}
+
+int
+open_max (void)
+{
+        if (openmax == 0) {                                             /* first time through */
+                errno = 0;
+                if ((openmax = sysconf (_SC_OPEN_MAX)) < 0) {
+                        if (errno == 0)
+                                openmax = OPEN_MAX_GUESS;       /* it's indeterminate */
+                        else
+                                err_sys ("sysconf error for _SC_OPEN_MAX");
+                }
+        }
+        return (openmax);
+}
+
+
+static void err_doit (int, const char *, va_list);
+
+char *pname = NULL;                                                     /* caller can set this from argv[0] */
+
+/* Fatal error related to a system call.
+ * Print a message and terminate. */
+
+void
+err_sys (const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start (ap, fmt);
+        err_doit (1, fmt, ap);
+        va_end (ap);
+        exit (1);
+}
+
+/* Print a message and return to caller.
+ * Caller specifies "errnoflag". */
+
+#define MAXLINE 2048
+static void
+err_doit (int errnoflag, const char *fmt, va_list ap)
+{
+        int errno_save;
+        char buf[MAXLINE];
+
+        errno_save = errno;                                             /* value caller might want printed */
+        vsprintf (buf, fmt, ap);
+        if (errnoflag)
+                sprintf (buf + strlen (buf), ": %s", strerror (errno_save));
+        strcat (buf, "\n");
+        fflush (stdout);                                                        /* in case stdout and stderr are the same */
+        fputs (buf, stderr);
+        fflush (NULL);                                                          /* flushes all stdio output streams */
+        return;
+}
+
+char *
+rtrim (char *str, const char *tok)
+{
+        int i = 0;
+
+        while (str != NULL) {
+                if (*(str + i) == *tok) {
+                        sprintf (str + i, "%s", "\0");
+                        return str;
+                }
+                i++;
+        }
+        return str;
+}
diff --git a/plugins/popen.h.in b/plugins/popen.h.in
new file mode 100644
index 00000000..adae2ecf
--- /dev/null
+++ b/plugins/popen.h.in
@@ -0,0 +1,9 @@
+FILE *spopen (const char *);
+int spclose (FILE *);
+RETSIGTYPE popen_timeout_alarm_handler (int);
+
+int timeout_interval;
+pid_t *childpid;
+int *child_stderr_array;
+FILE *child_process;
+FILE *child_stderr;
diff --git a/plugins/snprintf.c b/plugins/snprintf.c
new file mode 100644
index 00000000..1474b639
--- /dev/null
+++ b/plugins/snprintf.c
@@ -0,0 +1,377 @@
+/*
+ * Copyright (c) 1983, 1995, 1996 Eric P. Allman
+ * Copyright (c) 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.
+ */
+
+/* Some changes made by bbraun@synack.net for use with xinetd */
+
+#if !defined(HAVE_SNPRINTF)
+
+/* Extracted from sendmail 8.8.5 */
+#ifndef lint
+static char sccsid[] = "@(#)$Id$ excerpted from conf.c 8.333 (Berkeley) 1/21/97";
+#endif /* not lint */
+# ifdef __STDC__
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef __P
+#define __P(p)  p
+#endif
+
+#include <stdarg.h>
+#define VA_LOCAL_DECL   va_list ap;
+#define VA_START(f)     va_start(ap, f)
+#define VA_END          va_end(ap)
+
+#else
+
+#include <sys/types.h>
+#include <stdio.h>
+
+#ifndef __P
+#define __P(p)  ()
+#endif
+
+#include <varargs.h>
+#define VA_LOCAL_DECL   va_list ap;
+#define VA_START(f)     va_start(ap)
+#define VA_END          va_end(ap)
+
+#endif
+/*
+**  SNPRINTF, VSNPRINT -- counted versions of printf
+**
+**      These versions have been grabbed off the net.  They have been
+**      cleaned up to compile properly and support for .precision and
+**      %lx has been added.
+*/
+
+/**************************************************************
+ * Original:
+ * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
+ * A bombproof version of doprnt (dopr) included.
+ * Sigh.  This sort of thing is always nasty do deal with.  Note that
+ * the version here does not include floating point...
+ *
+ * snprintf() is used instead of sprintf() as it does limit checks
+ * for string length.  This covers a nasty loophole.
+ *
+ * The other functions are there to prevent NULL pointers from
+ * causing nast effects.
+ **************************************************************/
+
+/*static char _id[] = "$Id$";*/
+static void dopr();
+static char *end;
+#ifndef _SCO_DS
+/* VARARGS3 */
+int
+# ifdef __STDC__
+snprintf(char *str, size_t count, const char *fmt, ...)
+# else
+snprintf(str, count, fmt, va_alist)
+        char *str;
+        size_t count;
+        char *fmt;
+        va_dcl
+#endif
+{
+        int len;
+        VA_LOCAL_DECL
+
+        VA_START(fmt);
+        len = vsnprintf(str, count, fmt, ap);
+        VA_END;
+        return len;
+}
+#endif 
+
+# ifndef luna2
+int
+# ifdef __STDC__
+vsnprintf(char *str, size_t count, const char *fmt, va_list args)
+#else
+vsnprintf(str, count, fmt, args)
+        char *str;
+        int count;
+        char *fmt;
+        va_list args;
+#endif
+{
+        str[0] = 0;
+        end = str + count - 1;
+        dopr( str, fmt, args );
+        if (count > 0)
+                end[0] = 0;
+        return strlen(str);
+}
+
+/*
+ * dopr(): poor man's version of doprintf
+ */
+
+static void fmtstr __P((char *value, int ljust, int len, int zpad, int maxwidth));
+static void fmtnum __P((long value, int base, int dosign, int ljust, int len, int zpad));
+static void dostr __P(( char * , int ));
+static char *output;
+static void dopr_outch __P(( int c ));
+
+static void
+# ifdef __STDC__
+dopr(char  * buffer, const char * format, va_list args )
+#else
+dopr( buffer, format, args )
+       char *buffer;
+       char *format;
+       va_list args;
+#endif
+{
+       int ch;
+       long value;
+       int longflag  = 0;
+       int pointflag = 0;
+       int maxwidth  = 0;
+       char *strvalue;
+       int ljust;
+       int len;
+       int zpad;
+
+       output = buffer;
+       while( (ch = *format++) ){
+               switch( ch ){
+               case '%':
+                       ljust = len = zpad = maxwidth = 0;
+                       longflag = pointflag = 0;
+               nextch:
+                       ch = *format++;
+                       switch( ch ){
+                       case 0:
+                               dostr( "**end of format**" , 0);
+                               return;
+                       case '-': ljust = 1; goto nextch;
+                       case '0': /* set zero padding if len not set */
+                               if(len==0 && !pointflag) zpad = '0';
+                       case '1': case '2': case '3':
+                       case '4': case '5': case '6':
+                       case '7': case '8': case '9':
+                               if (pointflag)
+                                 maxwidth = maxwidth*10 + ch - '0';
+                               else
+                                 len = len*10 + ch - '0';
+                               goto nextch;
+                       case '*': 
+                               if (pointflag)
+                                 maxwidth = va_arg( args, int );
+                               else
+                                 len = va_arg( args, int );
+                               goto nextch;
+                       case '.': pointflag = 1; goto nextch;
+                       case 'l': longflag = 1; goto nextch;
+                       case 'u': case 'U':
+                               /*fmtnum(value,base,dosign,ljust,len,zpad) */
+                               if( longflag ){
+                                       value = va_arg( args, long );
+                               } else {
+                                       value = va_arg( args, int );
+                               }
+                               fmtnum( value, 10,0, ljust, len, zpad ); break;
+                       case 'o': case 'O':
+                               /*fmtnum(value,base,dosign,ljust,len,zpad) */
+                               if( longflag ){
+                                       value = va_arg( args, long );
+                               } else {
+                                       value = va_arg( args, int );
+                               }
+                               fmtnum( value, 8,0, ljust, len, zpad ); break;
+                       case 'd': case 'D':
+                               if( longflag ){
+                                       value = va_arg( args, long );
+                               } else {
+                                       value = va_arg( args, int );
+                               }
+                               fmtnum( value, 10,1, ljust, len, zpad ); break;
+                       case 'x':
+                               if( longflag ){
+                                       value = va_arg( args, long );
+                               } else {
+                                       value = va_arg( args, int );
+                               }
+                               fmtnum( value, 16,0, ljust, len, zpad ); break;
+                       case 'X':
+                               if( longflag ){
+                                       value = va_arg( args, long );
+                               } else {
+                                       value = va_arg( args, int );
+                               }
+                               fmtnum( value,-16,0, ljust, len, zpad ); break;
+                       case 's':
+                               strvalue = va_arg( args, char *);
+                               if (maxwidth > 0 || !pointflag) {
+                                 if (pointflag && len > maxwidth)
+                                   len = maxwidth; /* Adjust padding */
+                                 fmtstr( strvalue,ljust,len,zpad, maxwidth);
+                               }
+                               break;
+                       case 'c':
+                               ch = va_arg( args, int );
+                               dopr_outch( ch ); break;
+                       case '%': dopr_outch( ch ); continue;
+                       default:
+                               dostr(  "???????" , 0);
+                       }
+                       break;
+               default:
+                       dopr_outch( ch );
+                       break;
+               }
+       }
+       *output = 0;
+}
+
+static void
+fmtstr(  value, ljust, len, zpad, maxwidth )
+       char *value;
+       int ljust, len, zpad, maxwidth;
+{
+       int padlen, strlen;     /* amount to pad */
+
+       if( value == 0 ){
+               value = "<NULL>";
+       }
+       for( strlen = 0; value[strlen]; ++ strlen ); /* strlen */
+       if (strlen > maxwidth && maxwidth)
+         strlen = maxwidth;
+       padlen = len - strlen;
+       if( padlen < 0 ) padlen = 0;
+       if( ljust ) padlen = -padlen;
+       while( padlen > 0 ) {
+               dopr_outch( ' ' );
+               --padlen;
+       }
+       dostr( value, maxwidth );
+       while( padlen < 0 ) {
+               dopr_outch( ' ' );
+               ++padlen;
+       }
+}
+
+static void
+fmtnum(  value, base, dosign, ljust, len, zpad )
+       long value;
+       int base, dosign, ljust, len, zpad;
+{
+       int signvalue = 0;
+       unsigned long uvalue;
+       char convert[20];
+       int place = 0;
+       int padlen = 0; /* amount to pad */
+       int caps = 0;
+
+       /* DEBUGP(("value 0x%x, base %d, dosign %d, ljust %d, len %d, zpad %d\n",
+               value, base, dosign, ljust, len, zpad )); */
+       uvalue = value;
+       if( dosign ){
+               if( value < 0 ) {
+                       signvalue = '-';
+                       uvalue = -value;
+               }
+       }
+       if( base < 0 ){
+               caps = 1;
+               base = -base;
+       }
+       do{
+               convert[place++] =
+                       (caps? "0123456789ABCDEF":"0123456789abcdef")
+                        [uvalue % (unsigned)base  ];
+               uvalue = (uvalue / (unsigned)base );
+       }while(uvalue);
+       convert[place] = 0;
+       padlen = len - place;
+       if( padlen < 0 ) padlen = 0;
+       if( ljust ) padlen = -padlen;
+       /* DEBUGP(( "str '%s', place %d, sign %c, padlen %d\n",
+               convert,place,signvalue,padlen)); */
+       if( zpad && padlen > 0 ){
+               if( signvalue ){
+                       dopr_outch( signvalue );
+                       --padlen;
+                       signvalue = 0;
+               }
+               while( padlen > 0 ){
+                       dopr_outch( zpad );
+                       --padlen;
+               }
+       }
+       while( padlen > 0 ) {
+               dopr_outch( ' ' );
+               --padlen;
+       }
+       if( signvalue ) dopr_outch( signvalue );
+       while( place > 0 ) dopr_outch( convert[--place] );
+       while( padlen < 0 ){
+               dopr_outch( ' ' );
+               ++padlen;
+       }
+}
+
+static void
+dostr( str , cut)
+     char *str;
+     int cut;
+{
+  if (cut) {
+    while(*str && cut-- > 0) dopr_outch(*str++);
+  } else {
+    while(*str) dopr_outch(*str++);
+  }
+}
+
+static void
+dopr_outch( c )
+       int c;
+{
+#if 0
+       if( iscntrl(c) && c != '\n' && c != '\t' ){
+               c = '@' + (c & 0x1F);
+               if( end == 0 || output < end )
+                       *output++ = '^';
+       }
+#endif
+       if( end == 0 || output < end )
+               *output++ = c;
+}
+
+# endif /* !luna2 */
+
+#endif /* HAVE_SNPRINTF */
diff --git a/plugins/t/check_disk.t b/plugins/t/check_disk.t
new file mode 100644
index 00000000..f1e436dc
--- /dev/null
+++ b/plugins/t/check_disk.t
@@ -0,0 +1,31 @@
+use strict;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 6; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_disk 100 100 /";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^(Disk ok - +[\.0-9]+|DISK OK - )/';
+
+$cmd = "./check_disk -w 0 -c 0 /";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^(Disk ok - +[\.0-9]+|DISK OK - )/';
+
+$cmd = "./check_disk 0 0 /";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/^(Only +[\.0-9]+|DISK CRITICAL - )/';
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_dns.t b/plugins/t/check_dns.t
new file mode 100644
index 00000000..a85e2e76
--- /dev/null
+++ b/plugins/t/check_dns.t
@@ -0,0 +1,29 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 3; plan tests => $tests}
+
+#`nslookup localhost > /dev/null 2>&1` || exit(77);
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_dns 127.0.0.1 -to 5";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/DNS ok - +[\.0-9]+ seconds response time, Address\(es\) is\/are /';
+
+$cmd = "./check_dns $Cache::nullhost -to 1";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_fping.t b/plugins/t/check_fping.t
new file mode 100644
index 00000000..629ee35f
--- /dev/null
+++ b/plugins/t/check_fping.t
@@ -0,0 +1,37 @@
+#! /usr/bin/perl -w
+# $Id$
+
+use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 3; plan tests => $tests}
+
+exit(0) unless (-x "./check_fping");
+
+#`fping 127.0.0.1 > /dev/null 2>&1` || exit(77);
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+my $stat;
+
+
+$cmd = "./check_fping 127.0.0.1";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^FPING OK - 127.0.0.1/';
+
+$cmd = "./check_fping $Cache::nullhost";
+$str = `$cmd`;
+if ($?>>8 == 1 or $?>>8 == 2) {
+        $stat = 2;
+}
+$t += ok $stat,2;
+print "Test was: $cmd\n" if (($?>>8) < 1);
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_ftp.t b/plugins/t/check_ftp.t
new file mode 100644
index 00000000..c3f74d92
--- /dev/null
+++ b/plugins/t/check_ftp.t
@@ -0,0 +1,32 @@
+#! /usr/bin/perl -w
+
+#use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 3; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_ftp $Cache::hostname -wt 300 -ct 600";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/FTP ok - [0-9]+ second response time/';
+
+#$cmd = "./check_ftp $Cache::noserver -wt 0 -ct 0";
+#$str = `$cmd`;
+#$t += ok $?>>8,2;
+#print "Test was: $cmd\n" unless ($?);
+
+$cmd = "./check_ftp $Cache::nullhost -wt 0 -ct 0 -to 1";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_hpjd.t b/plugins/t/check_hpjd.t
new file mode 100644
index 00000000..b4e198d2
--- /dev/null
+++ b/plugins/t/check_hpjd.t
@@ -0,0 +1,32 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Helper;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 4; plan tests => $tests}
+
+exit(0) unless (-x "./check_hpjd");
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+my $printer = get_option("hpjd_printer","HP Jet-Direct card address");
+
+$cmd = "./check_hpjd $printer";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^Printer ok - /';
+
+$cmd = "./check_hpjd $Cache::noserver";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/Timeout: No response from /';
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_http.t b/plugins/t/check_http.t
new file mode 100644
index 00000000..2782fcd5
--- /dev/null
+++ b/plugins/t/check_http.t
@@ -0,0 +1,22 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 3; plan tests => $tests}
+
+my $null = '';
+my $str;
+my $t;
+
+$str = `./check_http $Cache::hostname -wt 300 -ct 600`;
+$t += ok $?>>8,0;
+$t += ok $str, '/HTTP\/1.1 [0-9]{3} (OK|Found) - [0-9]+ second response time/';
+
+$str = `./check_http $Cache::nullhost -wt 1 -ct 2`;
+$t += ok $?>>8,2;
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_imap.t b/plugins/t/check_imap.t
new file mode 100644
index 00000000..47494e59
--- /dev/null
+++ b/plugins/t/check_imap.t
@@ -0,0 +1,34 @@
+#! /usr/bin/perl -w
+
+#use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 3; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_imap $Cache::mailhost";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+
+$cmd = "./check_imap -H $Cache::mailhost -p 143 -w 9 -c 9 -t 10 -e '* OK'";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+
+
+# Reverse compatibility
+$cmd = "./check_imap $Cache::mailhost -p 143 -wt 9 -ct 9 -to 10 -e '* OK'";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
+
diff --git a/plugins/t/check_load.t b/plugins/t/check_load.t
new file mode 100644
index 00000000..ac14620f
--- /dev/null
+++ b/plugins/t/check_load.t
@@ -0,0 +1,27 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 4; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_load 100 100 100 100 100 100";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^load average: +[\.0-9]+, +[\.0-9]+, +[\.0-9]+$/';
+
+$cmd = "./check_load 0 0 0 0 0 0";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/^load average: +[\.0-9]+, +[\.0-9]+, +[\.0-9]+ CRITICAL$/';
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_mysql.t b/plugins/t/check_mysql.t
new file mode 100644
index 00000000..ae2a0087
--- /dev/null
+++ b/plugins/t/check_mysql.t
@@ -0,0 +1,23 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 1; plan tests => $tests}
+
+exit(0) unless (-x "./check_mysql");
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_mysql -H 127.0.0.1 -P 3306";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_ping.t b/plugins/t/check_ping.t
new file mode 100644
index 00000000..97bc660e
--- /dev/null
+++ b/plugins/t/check_ping.t
@@ -0,0 +1,33 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 5; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_ping 127.0.0.1 100 100 1000 1000 -p 1";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/PING (ok|OK) - Packet loss = +[0-9]{1,2}\%, +RTA = [\.0-9]+ ms/';
+
+$cmd = "./check_ping 127.0.0.1 0 0 0 0 -p 1";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/Packet loss = +[0-9]{1,2}\%, +RTA = [\.0-9]+ ms/';
+
+$cmd = "./check_ping $Cache::nullhost 0 0 0 0 -p 1 -to 1";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_pop.t b/plugins/t/check_pop.t
new file mode 100644
index 00000000..60b5a4ef
--- /dev/null
+++ b/plugins/t/check_pop.t
@@ -0,0 +1,31 @@
+#! /usr/bin/perl -w
+
+#use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 3; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_pop $Cache::mailhost";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+
+$cmd = "./check_pop -H $Cache::mailhost -p 110 -w 9 -c 9 -t 10 -e '+OK'";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+
+$cmd = "./check_pop $Cache::mailhost -p 110 -wt 9 -ct 9 -to 10 -e '+OK'";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_procs.t b/plugins/t/check_procs.t
new file mode 100644
index 00000000..9c2330f9
--- /dev/null
+++ b/plugins/t/check_procs.t
@@ -0,0 +1,51 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 10; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+# Reverse Compatibility
+$cmd = "./check_procs 100000 100000";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^OK - [0-9]+ processes running$/';
+
+# Reverse Compatibility
+$cmd = "./check_procs 100000 100000 Z";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^OK - [0-9]+ processes running with /';
+
+# Reverse Compatibility
+$cmd = "./check_procs 0 10000000";
+$str = `$cmd`;
+$t += ok $?>>8,1;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/^WARNING - [0-9]+ processes running$/';
+
+# Reverse Compatibility
+$cmd = "./check_procs 0 0";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/^CRITICAL - [0-9]+ processes running$/';
+
+# Reverse Compatibility
+$cmd = "./check_procs 0 0 S";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/^CRITICAL - [0-9]+ processes running with /';
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_smtp.t b/plugins/t/check_smtp.t
new file mode 100644
index 00000000..2a82b877
--- /dev/null
+++ b/plugins/t/check_smtp.t
@@ -0,0 +1,31 @@
+#! /usr/bin/perl -w
+
+#use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 3; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_smtp $Cache::mailhost";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+
+$cmd = "./check_smtp -H $Cache::mailhost -p 25 -t 1 -w 9 -c 9 -t 10 -e 220";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+
+$cmd = "./check_smtp -H $Cache::mailhost -p 25 -wt 9 -ct 9 -to 10 -e 220";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_snmp.t b/plugins/t/check_snmp.t
new file mode 100644
index 00000000..162b0b9b
--- /dev/null
+++ b/plugins/t/check_snmp.t
@@ -0,0 +1,52 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Helper;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 8; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+my $community=get_option("snmp_community","SNMP community name");
+
+exit(0) unless (-x "./check_snmp");
+
+$cmd = "./check_snmp -H 127.0.0.1 -C $community -o system.sysUpTime.0 -w 1: -c 1:";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+chomp $str;
+$t += ok $str, '/^SNMP OK - \d+/';
+
+$cmd = "./check_snmp -H 127.0.0.1 -C $community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w 1:1 -c 1:1";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+chomp $str;
+$t += ok $str, '/^SNMP OK - 1\s*$/';
+
+$cmd = "./check_snmp -H 127.0.0.1 -C $community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w 0 -c 1:";
+$str = `$cmd`;
+$t += ok $?>>8,1;
+print "Test was: $cmd\n" unless ($?);
+chomp $str;
+$t += ok $str, '/^SNMP WARNING - \*1\*\s*$/';
+
+$cmd = "./check_snmp -H 127.0.0.1 -C $community -o host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 -w :0 -c 0";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+chomp $str;
+$t += ok $str, '/^SNMP CRITICAL - \*1\*\s*$/';
+
+#host.hrSWRun.hrSWRunTable.hrSWRunEntry.hrSWRunIndex.1 = 1
+#enterprises.ucdavis.memory.memAvailSwap.0
+#./check_snmp 127.0.0.1 -C staff -o enterprises.ucdavis.diskTable.dskEntry.dskAvail.1,enterprises.ucdavis.diskTable.dskEntry.dskPercent.1 -w 100000: -c 50000: -l Space on root -u 'bytes free (','% used)'
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_swap.t b/plugins/t/check_swap.t
new file mode 100644
index 00000000..5b702f00
--- /dev/null
+++ b/plugins/t/check_swap.t
@@ -0,0 +1,34 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 6; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_swap 100 100";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^Swap ok - Swap used\: +[0-9]{1,2}\% \([0-9]+ bytes out of [0-9]+\)$/';
+
+$cmd = "./check_swap 0 0";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/^CRITICAL - Swap used\: +[0-9]{1,2}\% \([0-9]+ bytes out of [0-9]+\)$/';
+
+$cmd = "./check_swap 100 100 1000000000 1000000000";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/^CRITICAL - Swap used\: +[0-9]{1,2}\% \([0-9]+ bytes out of [0-9]+\)$/';
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_tcp.t b/plugins/t/check_tcp.t
new file mode 100644
index 00000000..1abec769
--- /dev/null
+++ b/plugins/t/check_tcp.t
@@ -0,0 +1,27 @@
+#! /usr/bin/perl -w
+
+#use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 3; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_tcp $Cache::hostname -p 80 -wt 300 -ct 600";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "$cmd\n" if ($?);
+$t += ok $str, '/^TCP OK - [0-9]+ second response time on port 80/';
+
+$cmd = "./check_tcp $Cache::nullhost -p 81 -wt 0 -ct 0 -to 1";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "$cmd\n" unless ($?);
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_time.t b/plugins/t/check_time.t
new file mode 100644
index 00000000..4d8c5c2b
--- /dev/null
+++ b/plugins/t/check_time.t
@@ -0,0 +1,52 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Cache;
+use Helper;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 6; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+my $udp_hostname=get_option("udp_hostname","UDP host name");
+
+# standard mode
+
+$cmd = "./check_time -H $udp_hostname -w 999999,59 -c 999999,59 -t 60";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^TIME OK - [0-9]+ second time difference$/';
+
+$cmd = "./check_time -H $udp_hostname -w 999999 -W 59 -c 999999 -C 59 -t 60";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^TIME OK - [0-9]+ second time difference$/';
+
+# reverse compatibility mode
+
+$cmd = "./check_time $udp_hostname -wt 59 -ct 59 -cd 999999 -wd 999999 -to 60";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^TIME OK - [0-9]+ second time difference$/';
+
+# failure mode
+
+#$cmd = "./check_time -H $Cache::nullhost -t 1";
+#$str = `$cmd`;
+#$t += ok $?>>8,255;
+#print "Test was: $cmd\n" unless ($?);
+
+#$cmd = "./check_time -H $Cache::noserver -t 1";
+#$str = `$cmd`;
+#$t += ok $?>>8,255;
+#print "$cmd\n" unless ($?);
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_udp.t b/plugins/t/check_udp.t
new file mode 100644
index 00000000..abbf5e49
--- /dev/null
+++ b/plugins/t/check_udp.t
@@ -0,0 +1,24 @@
+#! /usr/bin/perl -w
+
+#use strict;
+use Cache;
+use Helper;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 3; plan tests => $tests}
+
+my $null = '';
+my $str;
+my $t;
+my $hostname=get_option("udp_hostname","UDP host name");
+
+$str = `./check_udp $hostname -p 37 -wt 300 -ct 600`;
+$t += ok $?>>8,0;
+$t += ok $str, '/^Connection accepted on port 37 - [0-9]+ second response time$/';
+
+$str = `./check_udp $Cache::nullhost -p 80 -wt 0 -ct 0 -to 1`;
+$t += ok $?>>8,2;
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_users.t b/plugins/t/check_users.t
new file mode 100644
index 00000000..593f1737
--- /dev/null
+++ b/plugins/t/check_users.t
@@ -0,0 +1,28 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 4; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_users 1000 1000";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^USERS OK - +[0-9]+ users currently logged in$/';
+
+$cmd = "./check_users 0 0";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/^USERS CRITICAL - [0-9]+ +users currently logged in$/';
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/t/check_vsz.t b/plugins/t/check_vsz.t
new file mode 100644
index 00000000..95972619
--- /dev/null
+++ b/plugins/t/check_vsz.t
@@ -0,0 +1,28 @@
+#! /usr/bin/perl -w
+
+use strict;
+use Cache;
+use Test;
+use vars qw($tests);
+
+BEGIN {$tests = 4; plan tests => $tests}
+
+my $null = '';
+my $cmd;
+my $str;
+my $t;
+
+$cmd = "./check_vsz 100000 1000000 init";
+$str = `$cmd`;
+$t += ok $?>>8,0;
+print "Test was: $cmd\n" if ($?);
+$t += ok $str, '/^ok \(all VSZ\<[0-9]+\)/';
+
+$cmd = "./check_vsz 0 0";
+$str = `$cmd`;
+$t += ok $?>>8,2;
+print "Test was: $cmd\n" unless ($?);
+$t += ok $str, '/^CRITICAL \(VSZ\>[0-9]+\)/';
+
+exit(0) if defined($Test::Harness::VERSION);
+exit($tests - $t);
diff --git a/plugins/tests/check_disk b/plugins/tests/check_disk
new file mode 100644
index 00000000..c4323e0b
--- /dev/null
+++ b/plugins/tests/check_disk
@@ -0,0 +1,9 @@
+check_disk
+
+[normal]
+100 100 /
+^Disk ok - +[\.0-9]+
+
+[critical]
+0 0 /
+^Only +[\.0-9]+
diff --git a/plugins/tests/check_dns b/plugins/tests/check_dns
new file mode 100644
index 00000000..2e9b9a09
--- /dev/null
+++ b/plugins/tests/check_dns
@@ -0,0 +1,9 @@
+check_dns
+
+[normal]
+127.0.0.1
+DNS ok - +[\.0-9]+ seconds response time, Address\(es\) is\/are 127\.0\.0\.1
+
+[critical]
+$nullhost
+DNS (problem - Probably a non-existent host/domain|CRITICAL - Non-existent host/domain|CRITICAL - Connection timed out after [0-9]+ seconds)
diff --git a/plugins/tests/check_ftp b/plugins/tests/check_ftp
new file mode 100644
index 00000000..4266ebdc
--- /dev/null
+++ b/plugins/tests/check_ftp
@@ -0,0 +1,9 @@
+check_ftp
+
+[normal]
+$hostname -wt 300 -ct 600
+FTP ok - [0-9]+ second response time
+
+[critical]
+$noserver -wt 0 -ct 0
+(Invalid FTP response received from host|Connection refused by host)
diff --git a/plugins/tests/check_hpjd b/plugins/tests/check_hpjd
new file mode 100644
index 00000000..df35996f
--- /dev/null
+++ b/plugins/tests/check_hpjd
@@ -0,0 +1,9 @@
+check_hpjd
+
+[normal]
+$printer
+^Printer ok - 
+
+[critical]
+$noserver
+Timeout: No response from ns
diff --git a/plugins/tests/check_http b/plugins/tests/check_http
new file mode 100644
index 00000000..e09f6ff7
--- /dev/null
+++ b/plugins/tests/check_http
@@ -0,0 +1,9 @@
+check_http
+
+[normal]
+www.infoplease.com -wt 300 -ct 600
+HTTP/1.1 200 OK - [0-9]+ second response time
+
+[critical]
+$nullhost -wt 1 -ct 2
+(Connection refused by host|Network is unreachable|Connection refused or timed out|Socket timeout after [0-9]+ seconds)$
diff --git a/plugins/tests/check_load b/plugins/tests/check_load
new file mode 100644
index 00000000..5e4be3a4
--- /dev/null
+++ b/plugins/tests/check_load
@@ -0,0 +1,9 @@
+check_load
+
+[normal]
+100 100 100 100 100 100
+^load average: +[\.0-9]+, +[\.0-9]+, +[\.0-9]+$
+
+[critical]
+0 0 0 0 0 0
+^load average: +[\.0-9]+, +[\.0-9]+, +[\.0-9]+ CRITICAL$
diff --git a/plugins/tests/check_ping b/plugins/tests/check_ping
new file mode 100644
index 00000000..115cbaa3
--- /dev/null
+++ b/plugins/tests/check_ping
@@ -0,0 +1,13 @@
+check_ping
+
+[normal]
+127.0.0.1 100 100 1000 1000 -p 1
+PING ok - Packet loss = +[0-9]{1,2}\%, +RTA = [\.0-9]+ ms
+
+[critical]
+127.0.0.1 0 0 0 0 -p 1
+Packet loss = +[0-9]{1,2}\%, +RTA = [\.0-9]+ ms
+
+[critical]
+$nullhost 0 0 0 0 -p 1 -to 1
+CRITICAL - Plugin timed out after 1 seconds
diff --git a/plugins/tests/check_procs b/plugins/tests/check_procs
new file mode 100644
index 00000000..f7c65222
--- /dev/null
+++ b/plugins/tests/check_procs
@@ -0,0 +1,23 @@
+check_procs
+
+# this is a comment
+
+[normal]
+100000 100000
+^OK - [0-9]+ processes running$
+
+[normal]
+100000 100000 Z
+^OK - [0-9]+ processes with Z status$
+
+[warning]
+0 10000000
+^WARNING - [0-9]+ processes running$
+
+[critical]
+0 0
+^CRITICAL - [0-9]+ processes running$
+
+[critical]
+0 0 S
+^CRITICAL - [0-9]+ processes with S status$
diff --git a/plugins/tests/check_swap b/plugins/tests/check_swap
new file mode 100644
index 00000000..b6cbb42f
--- /dev/null
+++ b/plugins/tests/check_swap
@@ -0,0 +1,13 @@
+check_swap
+
+[normal]
+100 100
+^Swap ok - Swap used\: +[0-9]{1,2}\% \([0-9]+ bytes out of [0-9]+\)$
+
+[critical]
+0 0
+^CRITICAL - Swap used\: +[0-9]{1,2}\% \([0-9]+ bytes out of [0-9]+\)$
+
+[critical]
+100 100 1000000000 10000000000
+^CRITICAL - Swap used\: +[0-9]{1,2}\% \([0-9]+ bytes out of [0-9]+\)$
diff --git a/plugins/tests/check_users b/plugins/tests/check_users
new file mode 100644
index 00000000..5a7959a5
--- /dev/null
+++ b/plugins/tests/check_users
@@ -0,0 +1,9 @@
+check_users
+
+[normal]
+1000 1000
+^Users ok - +[0-9]+ users logged in$
+
+[critical]
+0 0
+^[0-9]+ +users currently logged in$
diff --git a/plugins/tests/check_vsz b/plugins/tests/check_vsz
new file mode 100644
index 00000000..4fdec936
--- /dev/null
+++ b/plugins/tests/check_vsz
@@ -0,0 +1,9 @@
+check_vsz
+
+[normal]
+100000 1000000 init
+^ok \(all VSZ\<[0-9]+\)
+
+[critical]
+0 0
+^CRITICAL \(VSZ\>[0-9]+\)
diff --git a/plugins/urlize.c b/plugins/urlize.c
new file mode 100644
index 00000000..83c37dac
--- /dev/null
+++ b/plugins/urlize.c
@@ -0,0 +1,141 @@
+/******************************************************************************
+ *
+ * urlize.c
+ *
+ * Program: plugin wrapper for Nagios
+ * License: GPL
+ * Copyright (c) 2000 Karl DeBisschop (kdebiss@alum.mit.edu)
+ *
+ * Last Modified: $Date$
+ * 2000-06-01 Karl DeBisschop <karl@debisschop.net>
+ *  Written based of concept in urlize.pl
+ *
+ * Usage: urlize <url> <plugin> <arg1> ... <argN>
+ *
+ * Description:
+ *
+ * This plugin wraps the text output of another command (plugin) in HTML
+ * <A> tags, thus displaying the plugin output in as a clickable link in
+ * the Nagios status screen.  The return status is the same as the plugin
+ * invoked by urlize
+ *
+ * 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 "utils.h"
+#include "popen.h"
+
+void print_usage (char *);
+void print_help (char *);
+
+int
+main (int argc, char **argv)
+{
+        int i = 0, found = 0, result = STATE_UNKNOWN;
+        char command_line[MAX_INPUT_BUFFER] = "";
+        char input_buffer[MAX_INPUT_BUFFER];
+
+        if (argc < 2) {
+                print_usage (my_basename (argv[0]));
+                exit (STATE_UNKNOWN);
+        }
+
+        if (!strcmp (argv[1], "-h") || !strcmp (argv[1], "--help")) {
+                print_help (argv[0]);
+                exit (STATE_OK);
+        }
+
+        if (!strcmp (argv[1], "-V") || !strcmp (argv[1], "--version")) {
+                print_revision (my_basename (argv[0]), "$Revision$");
+                exit (STATE_OK);
+        }
+
+        if (argc < 2) {
+                print_usage (my_basename (argv[0]));
+                exit (STATE_UNKNOWN);
+        }
+
+        sprintf (command_line, "%s", argv[2]);
+        for (i = 3; i < argc; i++) {
+                sprintf (command_line, "%s %s", command_line, argv[i]);
+        }
+
+        child_process = spopen (command_line);
+        if (child_process == NULL) {
+                printf ("Could not open pipe: %s\n", command_line);
+                exit (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);
+        }
+
+        printf ("<A href=\"%s\">", argv[1]);
+        while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+                found++;
+                if (index (input_buffer, '\n')) {
+                        input_buffer[strcspn (input_buffer, "\n")] = 0;
+                        printf ("%s", input_buffer);
+                }
+                else {
+                        printf ("%s", input_buffer);
+                }
+        }
+
+        if (!found) {
+                printf ("%s problem - No data recieved from host\nCMD: %s\n", argv[0],
+                                                command_line);
+                exit (STATE_UNKNOWN);
+        }
+
+        /* close the pipe */
+        result = spclose (child_process);
+
+        /* WARNING if output found on stderr */
+        if (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr))
+                result = max (result, STATE_WARNING);
+
+        /* close stderr */
+        (void) fclose (child_stderr);
+
+        printf ("</A>\n");
+        return result;
+}
+
+void
+print_usage (char *cmd)
+{
+        printf ("Usage:\n %s <url> <plugin> <arg1> ... <argN>\n",
+                                        my_basename (cmd));
+}
+
+void
+print_help (char *cmd)
+{
+        print_revision ("urlize", "$Revision$");
+        printf
+                ("Copyright (c) 2000 Karl DeBisschop (kdebiss@alum.mit.edu)\n\n"
+                 "\nThis plugin wraps the text output of another command (plugin) in HTML\n"
+                 "<A> tags, thus displaying the plugin output in as a clickable link in\n"
+                 "the Nagios status screen.  The return status is the same as the invoked\n"
+                 "plugin.\n\n");
+        print_usage (cmd);
+        exit (STATE_OK);
+}
diff --git a/plugins/utils.c b/plugins/utils.c
new file mode 100644
index 00000000..49e4d3d7
--- /dev/null
+++ b/plugins/utils.c
@@ -0,0 +1,610 @@
+/*****************************************************************************
+ *
+ * utils.c
+ *
+ * Library of useful functions for plugins
+ *
+ * Copyright (c) 2000 Karl DeBisschop (karl@debisschop.net)
+ * License: GPL
+ *
+ * $Revision$
+ * $Date$
+ ****************************************************************************/
+
+#include "config.h"
+#include "common.h"
+#include "version.h"
+#include <stdarg.h>
+#include <limits.h>
+
+extern int timeout_interval;
+
+char *my_basename (char *);
+void support (void);
+char *clean_revstring (const char *);
+void print_revision (char *, const char *);
+void terminate (int, const char *fmt, ...);
+RETSIGTYPE timeout_alarm_handler (int);
+
+int is_host (char *);
+int is_dotted_quad (char *);
+int is_hostname (char *);
+
+int is_integer (char *);
+int is_intpos (char *);
+int is_intneg (char *);
+int is_intnonneg (char *);
+int is_intpercent (char *);
+
+int is_numeric (char *);
+int is_positive (char *);
+int is_negative (char *);
+int is_nonnegative (char *);
+int is_percentage (char *);
+
+int is_option (char *str);
+
+void strip (char *);
+char *strscpy (char *dest, const char *src);
+char *strscat (char *dest, const char *src);
+char *strnl (char *str);
+char *ssprintf (char *str, const char *fmt, ...);
+char *strpcpy (char *dest, const char *src, const char *str);
+char *strpcat (char *dest, const char *src, const char *str);
+
+#define LABELLEN 63
+#define STRLEN 64
+#define TXTBLK 128
+
+#define max(a,b) ((a)>(b))?(a):(b)
+
+char *
+my_basename (char *path)
+{
+        if (!strstr (path, "/"))
+                return path;
+        else
+                return 1 + strrchr (path, '/');
+}
+
+
+void
+support (void)
+{
+        printf
+                ("Send email to nagios-users@lists.sourceforge.net if you have questions\n"
+                 "regarding use of this software. To submit patches or suggest improvements,\n"
+                 "send email to nagiosplug-devel@lists.sourceforge.net\n");
+}
+
+
+char *
+clean_revstring (const char *revstring)
+{
+        char plugin_revision[STRLEN];
+        if (sscanf (revstring,"$Revision: %[0-9.]",plugin_revision) == 1)
+                return strscpy (NULL, plugin_revision);
+        else
+          return strscpy (NULL, "N/A");
+}
+
+void
+print_revision (char *command_name, const char *revision_string)
+{
+        char plugin_revision[STRLEN];
+
+        if (sscanf (revision_string, "$Revision: %[0-9.]", plugin_revision) != 1)
+                strncpy (plugin_revision, "N/A", STRLEN);
+        printf ("%s (nagios-plugins %s) %s\n",
+                                        my_basename (command_name), VERSION, plugin_revision);
+        printf
+                ("The nagios plugins come with ABSOLUTELY NO WARRANTY. You may redistribute\n"
+                 "copies of the plugins under the terms of the GNU General Public License.\n"
+                 "For more information about these matters, see the file named COPYING.\n");
+
+}
+
+
+void
+terminate (int result, const char *fmt, ...)
+{
+        va_list ap;
+        va_start (ap, fmt);
+        vprintf (fmt, ap);
+        va_end (ap);
+        exit (result);
+}
+
+void
+timeout_alarm_handler (int signo)
+{
+        if (signo == SIGALRM) {
+                printf ("CRITICAL - Plugin timed out after %d seconds\n",
+                                                timeout_interval);
+                exit (STATE_CRITICAL);
+        }
+}
+
+int
+is_host (char *address)
+{
+        if (is_dotted_quad (address) || is_hostname (address))
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_dotted_quad (char *address)
+{
+        int o1, o2, o3, o4;
+        char c[1];
+
+        if (sscanf (address, "%d.%d.%d.%d%c", &o1, &o2, &o3, &o4, c) != 4)
+                return FALSE;
+        else if (o1 > 255 || o2 > 255 || o3 > 255 || o4 > 255)
+                return FALSE;
+        else if (o1 < 0 || o2 < 0 || o3 < 0 || o4 < 0)
+                return FALSE;
+        else
+                return TRUE;
+}
+
+/* from RFC-1035
+ * 
+ * The labels must follow the rules for ARPANET host names.  They must
+ * start with a letter, end with a letter or digit, and have as interior
+ * characters only letters, digits, and hyphen.  There are also some
+ * restrictions on the length.  Labels must be 63 characters or less. */
+
+int
+is_hostname (char *s1)
+{
+        if (strlen (s1) > 63)
+                return FALSE;
+        if (strcspn
+                        (s1,
+                         "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUWVXYZ0123456789-.") !=
+                        0) return FALSE;
+        if (strspn (s1, "0123456789-.") == 1)
+                return FALSE;
+        while ((s1 = index (s1, '.'))) {
+                s1++;
+                if (strspn (s1, "0123456789-.") == 1) {
+                        printf ("%s\n", s1);
+                        return FALSE;
+                }
+        }
+        return TRUE;
+}
+
+int
+is_numeric (char *number)
+{
+        char tmp[1];
+        float x;
+        if (sscanf (number, "%f%c", &x, tmp) == 1)
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_positive (char *number)
+{
+        if (is_numeric (number) && atof (number) > 0.0)
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_negative (char *number)
+{
+        if (is_numeric (number) && atof (number) < 0.0)
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_nonnegative (char *number)
+{
+        if (is_numeric (number) && atof (number) >= 0.0)
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_percentage (char *number)
+{
+        int x;
+        if (is_numeric (number) && (x = atof (number)) >= 0 && x <= 100)
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_integer (char *number)
+{
+        long int n;
+
+        if (strspn (number, "-0123456789 ") != strlen (number))
+                return (FALSE);
+
+        n = strtol (number, NULL, 10);
+        if (errno != ERANGE && n >= INT_MIN && n <= INT_MAX)
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_intpos (char *number)
+{
+        if (is_integer (number) && atoi (number) > 0)
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_intneg (char *number)
+{
+        if (is_integer (number) && atoi (number) < 0)
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_intnonneg (char *number)
+{
+        if (is_integer (number) && atoi (number) >= 0)
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_intpercent (char *number)
+{
+        int i;
+        if (is_integer (number) && (i = atoi (number)) >= 0 && i <= 100)
+                return (TRUE);
+        return (FALSE);
+}
+
+int
+is_option (char *str)
+{
+        if (strspn (str, "-") == 1 || strspn (str, "-") == 2)
+                return TRUE;
+        return FALSE;
+}
+
+
+
+
+
+void
+strip (char *buffer)
+{
+        size_t x;
+        int i;
+
+        for (x = strlen (buffer); x >= 1; x--) {
+                i = x - 1;
+                if (buffer[i] == ' ' ||
+                                buffer[i] == '\r' || buffer[i] == '\n' || buffer[i] == '\t')
+                        buffer[i] = '\0';
+                else
+                        break;
+        }
+        return;
+}
+
+
+
+
+
+/******************************************************************************
+ *
+ * Copies one string to another
+ *
+ * Given a pointer destination string, which may or may not already
+ * hold some text, and a source string with additional text (possibly
+ * NULL or empty), returns a pointer to a a copy of the source
+ * string. Uses realloc to free memory held by the dest argument if
+ * new storage space is required, and any previously existing data in
+ * the destination string is lost.
+ *
+ * Example:
+ *
+ * char *str=NULL;
+ * str = strscpy("This is a line of text with no trailing newline");
+ *
+ *****************************************************************************/
+
+char *
+strscpy (char *dest, const char *src)
+{
+        size_t len;
+
+        if (src == NULL)
+                return dest;
+
+        len = strlen (src) + 1;
+        if (dest == NULL)
+                dest = malloc (len);
+        else if (strlen (dest) < len)
+                dest = realloc (dest, len);
+        if (dest == NULL)
+                terminate (STATE_UNKNOWN, "failed realloc in strscpy\n");
+
+        strncpy (dest, src, len);
+
+        return dest;
+}
+
+
+
+
+
+/******************************************************************************
+ *
+ * Concatenates one string to the end of another
+ *
+ * Given a pointer destination string, which may or may not already
+ * hold some text, and a source string with additional text (possibly
+ * NULL or empty), returns a pointer to a string that is the first
+ * string with the second concatenated to it. Uses realloc to free 
+ * memory held by the dest argument if new storage space is required.
+ *
+ * Example:
+ *
+ * char *str=NULL;
+ * str = strscpy("This is a line of text with no trailing newline");
+ * str = strscat(str,"\n");
+ *
+ *****************************************************************************/
+
+char *
+strscat (char *dest, const char *src)
+{
+        size_t len, l2;
+
+        if (src)
+                l2 = strlen (src);
+        else
+                return dest;
+
+        if (dest)
+                len = strlen (dest);
+        else
+                len = 0;
+
+        dest = realloc (dest, len + l2 + 1);
+        if (dest == NULL)
+                terminate (STATE_UNKNOWN, "failed malloc in strscat\n");
+
+        strncpy (dest + len, src, l2);
+        dest[len + l2] = '\0';
+
+        return dest;
+}
+
+
+
+
+
+/******************************************************************************
+ *
+ * Returns a pointer to the next line of a multiline string buffer
+ *
+ * Given a pointer string, find the text following the next sequence
+ * of \r and \n characters. This has the effect of skipping blank
+ * lines as well
+ *
+ * Example:
+ *
+ * Given text as follows:
+ *
+ * ==============================
+ * This
+ * is
+ * a
+ * 
+ * multiline string buffer
+ * ==============================
+ *
+ * int i=0;
+ * char *str=NULL;
+ * char *ptr=NULL;
+ * str = strscpy(str,"This\nis\r\na\n\nmultiline string buffer\n");
+ * ptr = str;
+ * while (ptr) {
+ *   printf("%d %s",i++,firstword(ptr));
+ *   ptr = strnl(ptr);
+ * }
+ * 
+ * Produces the following:
+ *
+ * 1 This
+ * 2 is
+ * 3 a
+ * 4 multiline
+ *
+ * NOTE: The 'firstword()' function is conceptual only and does not
+ *       exist in this package.
+ *
+ * NOTE: Although the second 'ptr' variable is not strictly needed in
+ *       this example, it is good practice with these utilities. Once
+ *       the * pointer is advance in this manner, it may no longer be
+ *       handled with * realloc(). So at the end of the code fragment
+ *       above, * strscpy(str,"foo") work perfectly fine, but
+ *       strscpy(ptr,"foo") will * cause the the program to crash with
+ *       a segmentation fault.
+ *
+ *****************************************************************************/
+
+char *
+strnl (char *str)
+{
+        size_t len;
+        if (str == NULL)
+                return NULL;
+        str = strpbrk (str, "\r\n");
+        if (str == NULL)
+                return NULL;
+        len = strspn (str, "\r\n");
+        if (str[len] == '\0')
+                return NULL;
+        str += len;
+        if (strlen (str) == 0)
+                return NULL;
+        return str;
+}
+
+
+
+
+
+/******************************************************************************
+ *
+ * Does a formatted print to a string variable
+ *
+ * Given a pointer destination string, which may or may not already
+ * hold some text, and a source string with additional text (possibly
+ * NULL or empty), returns a pointer to a string that cntains the
+ * results of the specified formatted print
+ *
+ * Example:
+ *
+ * char *str=NULL;
+ * str = ssprintf(str,"%d %s",1,"string");
+ *
+ *****************************************************************************/
+
+char *
+ssprintf (char *ptr, const char *fmt, ...)
+{
+        va_list ap;
+        int nchars;
+        size_t size;
+        char *str = NULL;
+
+        if (str == NULL) {
+                str = malloc (TXTBLK);
+                if (str == NULL)
+                        terminate (STATE_UNKNOWN, "malloc failed in ssprintf");
+                size = TXTBLK;
+        }
+        else
+                size = max (strlen (str), TXTBLK);
+
+        va_start (ap, fmt);
+
+        while (1) {
+
+                nchars = vsnprintf (str, size, fmt, ap);
+
+                if (nchars > -1)
+                        if (nchars < (int) size) {
+                                va_end (ap);
+                                str[nchars] = '\0';
+                                if (ptr)
+                                        free (ptr);
+                                return str;
+                        }
+                        else {
+                                size = (size_t) (nchars + 1);
+                        }
+
+                else
+                        size *= 2;
+
+                str = realloc (str, size);
+
+                if (str == NULL)
+                        terminate (STATE_UNKNOWN, "realloc failed in ssprintf");
+        }
+
+}
+
+
+
+
+
+/******************************************************************************
+ *
+ * Like strscpy, except only the portion of the source string up to
+ * the provided delimiter is copied.
+ *
+ * Example:
+ *
+ * str = strpcpy(str,"This is a line of text with no trailing newline","x");
+ * printf("%s\n",str);
+ *
+ * Produces:
+ *
+ *This is a line of te
+ *
+ *****************************************************************************/
+
+char *
+strpcpy (char *dest, const char *src, const char *str)
+{
+        size_t len;
+
+        if (src)
+                len = strcspn (src, str);
+        else
+                return NULL;
+
+        if (dest == NULL || strlen (dest) < len)
+                dest = realloc (dest, len + 1);
+        if (dest == NULL)
+                terminate (STATE_UNKNOWN, "failed realloc in strpcpy\n");
+
+        strncpy (dest, src, len);
+        dest[len] = '\0';
+
+        return dest;
+}
+
+
+
+
+
+/******************************************************************************
+ *
+ * Like strscat, except only the portion of the source string up to
+ * the provided delimiter is copied.
+ *
+ * str = strpcpy(str,"This is a line of text with no trailing newline","x");
+ * str = strpcat(str,"This is a line of text with no trailing newline","x");
+ * printf("%s\n",str);
+ * 
+ *This is a line of texThis is a line of tex
+ *
+ *****************************************************************************/
+
+char *
+strpcat (char *dest, const char *src, const char *str)
+{
+        size_t len, l2;
+
+        if (dest)
+                len = strlen (dest);
+        else
+                len = 0;
+
+        if (src) {
+                l2 = strcspn (src, str);
+        }
+        else {
+                return dest;
+        }
+
+        dest = realloc (dest, len + l2 + 1);
+        if (dest == NULL)
+                terminate (STATE_UNKNOWN, "failed malloc in strscat\n");
+
+        strncpy (dest + len, src, l2);
+        dest[len + l2] = '\0';
+
+        return dest;
+}
diff --git a/plugins/utils.h.in b/plugins/utils.h.in
new file mode 100644
index 00000000..a21d63d6
--- /dev/null
+++ b/plugins/utils.h.in
@@ -0,0 +1,92 @@
+/* header file for nagios plugins uitls.c */
+
+/* this file should be included in all plugins */
+
+/* The purpose of this package is to provide safer alternantives to C
+functions that might otherwise be vulnerable to hacking. This
+currently includes a standard suite of validation routines to be sure
+that an string argument acually converts to its intended type and a
+suite of string handling routine that do their own memory management
+in order to resist overflow attacks. In addition, a few functions are
+provided to standardize version and error reporting accross the entire
+suite of plugins. */
+
+/* Standardize version information, termination */
+
+char *my_basename (char *);
+void support (void);
+char *clean_revstring (const char *revstring);
+void print_revision (char *, const char *);
+void terminate (int result, char *msg, ...);
+extern RETSIGTYPE timeout_alarm_handler (int);
+
+/* Handle timeouts */
+
+time_t start_time, end_time;
+int timeout_interval = DEFAULT_SOCKET_TIMEOUT;
+
+/* Test input types */
+
+int is_host (char *);
+int is_dotted_quad (char *);
+int is_hostname (char *);
+
+int is_integer (char *);
+int is_intpos (char *);
+int is_intneg (char *);
+int is_intnonneg (char *);
+int is_intpercent (char *);
+
+int is_numeric (char *);
+int is_positive (char *);
+int is_negative (char *);
+int is_nonnegative (char *);
+int is_percentage (char *);
+
+int is_option (char *);
+
+/* Handle strings safely */
+
+void strip (char *buffer);
+char *strscpy (char *dest, char *src);
+char *strscat (char *dest, char *src);
+char *strnl (char *str);
+char *ssprintf (char *str, const char *fmt, ...);
+char *strpcpy (char *dest, const char *src, const char *str);
+char *strpcat (char *dest, const char *src, const char *str);
+
+#define max(a,b) ((a)>(b))?(a):(b)
+
+#define usage(msg) {\
+  printf(msg);\
+  print_usage();\
+exit(STATE_UNKNOWN);\
+}
+
+#define usage2(msg,arg) {\
+  printf("%s: %s - %s\n",PROGNAME,msg,arg);\
+  print_usage();\
+  exit(STATE_UNKNOWN);\
+}
+
+#define state_text(a) \
+(a)==0?"OK":\
+(a)==1?"WARNING":\
+(a)==2?"CRITICAL":\
+(a)==-2?"DEPENDENT":\
+"UNKNOWN"
+
+/* The idea here is that, although not every plugin will use all of these, 
+   most will or should.  Therefore, for consistency, these very common 
+   options should have only these meanings throughout the overall suite */
+
+#define STD_OPTS "Vvht:c:w:H:F:"
+#define STD_OPTS_LONG \
+{"version",no_argument,0,'V'},\
+{"verbose",no_argument,0,'v'},\
+{"help",no_argument,0,'h'},\
+{"timeout",required_argument,0,'t'},\
+{"critical",required_argument,0,'c'},\
+{"warning",required_argument,0,'w'},\
+{"hostname",required_argument,0,'H'},\
+{"file",required_argument,0,'F'}
diff --git a/plugins/version.h.in b/plugins/version.h.in
new file mode 100644
index 00000000..e41aaee0
--- /dev/null
+++ b/plugins/version.h.in
@@ -0,0 +1,2 @@
+#define PACKAGE_VERSION "1.3.0-alpha1"
+#define CVS_DATE "$Date$"