Back to index

nagios-plugins  1.4.16
Enumerations | Functions | Variables
check_nwstat.c File Reference
#include "common.h"
#include "netutils.h"
#include "utils.h"

Go to the source code of this file.

Enumerations

enum  checkvar {
  NONE, LOAD1, LOAD5, LOAD15,
  CONNS, VPF, VMF, VMU,
  VMP, VKF, LTCH, CBUFF,
  CDBUFF, LRUM, DSDB, LOGINS,
  NRMH, PUPRB, UPRB, SAPENTRIES,
  OFILES, VKP, VPP, VKNP,
  VPNP, ABENDS, CSPROCS, TSYNC,
  LRUS, DCB, TCB, DSVER,
  UPTIME, NLM, NRMP, NRMM,
  NRMS, NSS1, NSS2, NSS3,
  NSS4, NSS5, NSS6, NSS7,
  NONE, LOAD1, LOAD5, LOAD15,
  DPU, PROCS, NETSTAT, UPTIME
}
enum  { PORT = 9999 }

Functions

enum checkvar int sap_number int process_arguments (int, char **)
void print_help (void)
void print_usage (void)
int main (int argc, char **argv)

Variables

const char * progname = "check_nwstat"
const char * copyright = "2000-2007"
const char * email = "nagiosplug-devel@lists.sourceforge.net"
char * server_address = NULL
char * volume_name = NULL
char * nlm_name = NULL
char * nrmp_name = NULL
char * nrmm_name = NULL
char * nrms_name = NULL
char * nss1_name = NULL
char * nss2_name = NULL
char * nss3_name = NULL
char * nss4_name = NULL
char * nss5_name = NULL
char * nss6_name = NULL
char * nss7_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

Enumeration Type Documentation

anonymous enum
Enumerator:
PORT 

Definition at line 87 of file check_nwstat.c.

     {
       PORT = 9999
};
enum checkvar
Enumerator:
NONE 
LOAD1 
LOAD5 
LOAD15 
CONNS 
VPF 
VMF 
VMU 
VMP 
VKF 
LTCH 
CBUFF 
CDBUFF 
LRUM 
DSDB 
LOGINS 
NRMH 
PUPRB 
UPRB 
SAPENTRIES 
OFILES 
VKP 
VPP 
VKNP 
VPNP 
ABENDS 
CSPROCS 
TSYNC 
LRUS 
DCB 
TCB 
DSVER 
UPTIME 
NLM 
NRMP 
NRMM 
NRMS 
NSS1 
NSS2 
NSS3 
NSS4 
NSS5 
NSS6 
NSS7 
NONE 
LOAD1 
LOAD5 
LOAD15 
DPU 
PROCS 
NETSTAT 
UPTIME 

Definition at line 40 of file check_nwstat.c.

              {
       NONE,
       LOAD1,      /* check 1 minute CPU load */
       LOAD5,      /* check 5 minute CPU load */
       LOAD15,     /* check 15 minute CPU load */
       CONNS,      /* check number of connections */
       VPF,        /* check % free space on volume */
       VMF,       /* check MB free space on volume */
       VMU,       /* check MB used space on volume */
       VMP,       /* check MB purgeable space on volume */
       VKF,        /* check KB free space on volume */
       LTCH,       /* check long-term cache hit percentage */
       CBUFF,      /* check total cache buffers */
       CDBUFF,     /* check dirty cache buffers */
       LRUM,       /* check LRU sitting time in minutes */
       DSDB,       /* check to see if DS Database is open */
       LOGINS,     /* check to see if logins are enabled */
       NRMH,      /* check to see NRM Health Status */
       PUPRB,      /* check % of used packet receive buffers */
       UPRB,       /* check used packet receive buffers */
       SAPENTRIES, /* check SAP entries */
       OFILES,     /* check number of open files */
       VKP,        /* check KB purgeable space on volume */
       VPP,        /* check % purgeable space on volume */
       VKNP,       /* check KB not yet purgeable space on volume */
       VPNP,       /* check % not yet purgeable space on volume */
       ABENDS,     /* check abended thread count */
       CSPROCS,    /* check number of current service processes */
       TSYNC,      /* check timesync status 0=no 1=yes in sync to the network */
       LRUS,       /* check LRU sitting time in seconds */
       DCB,        /* check dirty cache buffers as a percentage of the total */
       TCB,        /* check total cache buffers as a percentage of the original */
       DSVER,      /* check NDS version */
       UPTIME,     /* check server uptime */
       NLM,        /* check NLM loaded */
       NRMP,      /* check NRM Process Values */
       NRMM,      /* check NRM Memory Values */
       NRMS,       /* check NRM Values */
       NSS1,       /* check Statistics from _Admin:Manage_NSS\GeneralStats.xml */
       NSS2,       /* check Statistics from _Admin:Manage_NSS\BufferCache.xml */
       NSS3,       /* check statistics from _Admin:Manage_NSS\NameCache.xml */
       NSS4,       /* check statistics from _Admin:Manage_NSS\FileStats.xml */
       NSS5,       /* check statistics from _Admin:Manage_NSS\ObjectCache.xml */
       NSS6,       /* check statistics from _Admin:Manage_NSS\Thread.xml */
       NSS7        /* check statistics from _Admin:Manage_NSS\AuthorizationCache.xml */
};

Function Documentation

int main ( int  argc,
char **  argv 
)

Definition at line 120 of file check_nwstat.c.

                            {
       int result = STATE_UNKNOWN;
       int sd;
       char *send_buffer=NULL;
       char recv_buffer[MAX_INPUT_BUFFER];
       char *output_message=NULL;
       char *temp_buffer=NULL;
       char *netware_version=NULL;

       int time_sync_status=0;
       int nrm_health_status=0;
       unsigned long total_cache_buffers=0;
       unsigned long dirty_cache_buffers=0;
       unsigned long open_files=0;
       unsigned long abended_threads=0;
       unsigned long max_service_processes=0;
       unsigned long current_service_processes=0;
       unsigned long free_disk_space=0L;
       unsigned long nrmp_value=0L;
       unsigned long nrmm_value=0L;
       unsigned long nrms_value=0L;
       unsigned long nss1_value=0L;
       unsigned long nss2_value=0L;
       unsigned long nss3_value=0L;
       unsigned long nss4_value=0L;
       unsigned long nss5_value=0L;
       unsigned long nss6_value=0L;
       unsigned long nss7_value=0L;
       unsigned long total_disk_space=0L;
       unsigned long purgeable_disk_space=0L;
       unsigned long non_purgeable_disk_space=0L;
       unsigned long percent_free_space=0;
       unsigned long percent_purgeable_space=0;
       unsigned long percent_non_purgeable_space=0;
       unsigned long current_connections=0L;
       unsigned long utilization=0L;
       unsigned long cache_hits=0;
       unsigned long cache_buffers=0L;
       unsigned long lru_time=0L;
       unsigned long max_packet_receive_buffers=0;
       unsigned long used_packet_receive_buffers=0;
       unsigned long percent_used_packet_receive_buffers=0L;
       unsigned long sap_entries=0;
       char uptime[MAX_INPUT_BUFFER];

       setlocale (LC_ALL, "");
       bindtextdomain (PACKAGE, LOCALEDIR);
       textdomain (PACKAGE);

       /* Parse extra opts if any */
       argv=np_extra_opts(&argc, argv, progname);

       if (process_arguments(argc,argv) == ERROR)
              usage4 (_("Could not parse arguments"));

       /* initialize alarm signal handling */
       signal(SIGALRM,socket_timeout_alarm_handler);

       /* set socket timeout */
       alarm(socket_timeout);

       /* open connection */
       my_tcp_connect (server_address, server_port, &sd);

       /* get OS version string */
       if (check_netware_version==TRUE) {
              send_buffer = strdup ("S19\r\n");
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;
              if (!strcmp(recv_buffer,"-1\n"))
                     netware_version = strdup("");
              else {
                     recv_buffer[strlen(recv_buffer)-1]=0;
                     asprintf (&netware_version,_("NetWare %s: "),recv_buffer);
              }
       } else
              netware_version = strdup("");


       /* check CPU load */
       if (vars_to_check==LOAD1 || vars_to_check==LOAD5 || vars_to_check==LOAD15) {

              switch(vars_to_check) {
              case LOAD1:
                     temp_buffer = strdup ("1");
                     break;
              case LOAD5:
                     temp_buffer = strdup ("5");
                     break;
              default:
                     temp_buffer = strdup ("15");
                     break;
              }

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"UTIL%s\r\n",temp_buffer);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;
              utilization=strtoul(recv_buffer,NULL,10);

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("UPTIME\r\n");
              result=send_tcp_request(sd,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;

              asprintf (&output_message,
                        _("Load %s - %s %s-min load average = %lu%%|load%s=%lu;%lu;%lu;0;100"),
                        state_text(result),
                        uptime,
                        temp_buffer,
                        utilization,
                       temp_buffer,
                       utilization,
                       warning_value,
                       critical_value);

              /* check number of user connections */
       } else if (vars_to_check==CONNS) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("CONNECT\r\n");
              result=send_tcp_request(sd,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;

              asprintf (&output_message,
                     _("Conns %s - %lu current connections|Conns=%lu;%lu;%lu;;"),
                        state_text(result),
                        current_connections,
                        current_connections,
                       warning_value,
                       critical_value);

              /* check % long term cache hits */
       } else if (vars_to_check==LTCH) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("S1\r\n");
              result=send_tcp_request(sd,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;

              asprintf (&output_message,
                        _("%s: Long term cache hits = %lu%%"),
                        state_text(result),
                        cache_hits);

              /* check cache buffers */
       } else if (vars_to_check==CBUFF) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("S2\r\n");
              result=send_tcp_request(sd,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;

              asprintf (&output_message,
                        _("%s: Total cache buffers = %lu|Cachebuffers=%lu;%lu;%lu;;"),
                        state_text(result),
                        cache_buffers,
                       cache_buffers,
                       warning_value,
                       critical_value);

              /* check dirty cache buffers */
       } else if (vars_to_check==CDBUFF) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("S3\r\n");
              result=send_tcp_request(sd,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;

              asprintf (&output_message,
                        _("%s: Dirty cache buffers = %lu|Dirty-Cache-Buffers=%lu;%lu;%lu;;"),
                        state_text(result),
                        cache_buffers,
                       cache_buffers,
                       warning_value,
                       critical_value);

              /* check LRU sitting time in minutes */
       } else if (vars_to_check==LRUM) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("S5\r\n");
              result=send_tcp_request(sd,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;

              asprintf (&output_message,
                        _("%s: LRU sitting time = %lu minutes"),
                        state_text(result),
                        lru_time);


              /* check KB free space on volume */
       } else if (vars_to_check==VKF) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"VKF%s\r\n",volume_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - 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;
                     asprintf (&output_message,
                               _("%s%lu KB free on volume %s|KBFree%s=%lu;%lu;%lu;;"),
                              (result==STATE_OK)?"":_("Only "),
                              free_disk_space,
                              volume_name,
                             volume_name,
                             free_disk_space,
                             warning_value,
                             critical_value);
              }

              /* check MB free space on volume */
       } else if (vars_to_check==VMF) {

              asprintf (&send_buffer,"VMF%s\r\n",volume_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - 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;
                     asprintf (&output_message,
                               _("%s%lu MB free on volume %s|MBFree%s=%lu;%lu;%lu;;"),
                              (result==STATE_OK)?"":_("Only "),
                              free_disk_space,
                              volume_name,
                             volume_name,
                             free_disk_space,
                             warning_value,
                             critical_value);
              }
              /* check MB used space on volume */
       } else if (vars_to_check==VMU) {

              asprintf (&send_buffer,"VMU%s\r\n",volume_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - 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;
                     asprintf (&output_message,
                               _("%s%lu MB used on volume %s|MBUsed%s=%lu;%lu;%lu;;"),
                              (result==STATE_OK)?"":_("Only "),
                              free_disk_space,
                              volume_name,
                             volume_name,
                             free_disk_space,
                             warning_value,
                             critical_value);
              }


              /* check % free space on volume */
       } else if (vars_to_check==VPF) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"VKF%s\r\n",volume_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {

                     asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
                     result=STATE_CRITICAL;

              } else {

                     free_disk_space=strtoul(recv_buffer,NULL,10);

                     close(sd);
                     my_tcp_connect (server_address, server_port, &sd);

                     asprintf (&send_buffer,"VKS%s\r\n",volume_name);
                     result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
                     if (result!=STATE_OK)
                            return result;
                     total_disk_space=strtoul(recv_buffer,NULL,10);

                     percent_free_space=(unsigned long)(((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;
                     total_disk_space/=1024;
                     asprintf (&output_message,_("%lu MB (%lu%%) free on volume %s - total %lu MB|FreeMB%s=%lu;%lu;%lu;0;100"),
                            free_disk_space,
                            percent_free_space,
                            volume_name,
                            total_disk_space,
                            volume_name,
                                percent_free_space,
                                warning_value,
                                critical_value
                                );
              }

              /* check to see if DS Database is open or closed */
       } else if (vars_to_check==DSDB) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("S11\r\n");
              result=send_tcp_request(sd,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;

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("S13\r\n");
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              temp_buffer=strtok(recv_buffer,"\r\n");

              asprintf (&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==LOGINS) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("S12\r\n");
              result=send_tcp_request(sd,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;

              asprintf (&output_message,_("Logins are %s"),(result==STATE_OK)?_("enabled"):_("disabled"));


              /* check NRM Health Status Summary*/
       } else if (vars_to_check==NRMH) {

              asprintf (&send_buffer,"NRMH\r\n");
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              nrm_health_status=atoi(recv_buffer);

              if (nrm_health_status==2) {
                     result=STATE_OK;
                     asprintf (&output_message,_("CRITICAL - NRM Status is bad!"));
              }
              else {
                     if (nrm_health_status==1) {
                            result=STATE_WARNING;
                            asprintf (&output_message,_("Warning - NRM Status is suspect!"));
                     }

                     asprintf (&output_message,_("OK - NRM Status is good!"));
              }



              /* check packet receive buffers */
       } else if (vars_to_check==UPRB || vars_to_check==PUPRB) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"S15\r\n");
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              used_packet_receive_buffers=atoi(recv_buffer);

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"S16\r\n");
              result=send_tcp_request(sd,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==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;
              }

              asprintf (&output_message,_("%lu of %lu (%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==SAPENTRIES) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              if (sap_number==-1)
                     asprintf (&send_buffer,"S9\r\n");
              else
                     asprintf (&send_buffer,"S9.%d\r\n",sap_number);
              result=send_tcp_request(sd,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)
                     asprintf (&output_message,_("%lu entries in SAP table"),sap_entries);
              else
                     asprintf (&output_message,_("%lu entries in SAP table for SAP type %d"),sap_entries,sap_number);

              /* check KB purgeable space on volume */
       } else if (vars_to_check==VKP) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"VKP%s\r\n",volume_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - 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;
                     asprintf (&output_message,_("%s%lu KB purgeable on volume %s|Purge%s=%lu;%lu;%lu;;"),
                             (result==STATE_OK)?"":_("Only "),
                             purgeable_disk_space,
                             volume_name,
                             volume_name,
                             purgeable_disk_space,
                             warning_value,
                             critical_value);
              }
              /* check MB purgeable space on volume */
       } else if (vars_to_check==VMP) {

              asprintf (&send_buffer,"VMP%s\r\n",volume_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - 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;
                     asprintf (&output_message,_("%s%lu MB purgeable on volume %s|Purge%s=%lu;%lu;%lu;;"),
                             (result==STATE_OK)?"":_("Only "),
                             purgeable_disk_space,
                             volume_name,
                             volume_name,
                             purgeable_disk_space,
                             warning_value,
                             critical_value);
              }

              /* check % purgeable space on volume */
       } else if (vars_to_check==VPP) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"VKP%s\r\n",volume_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {

                     asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
                     result=STATE_CRITICAL;

              } else {

                     purgeable_disk_space=strtoul(recv_buffer,NULL,10);

                     close(sd);
                     my_tcp_connect (server_address, server_port, &sd);

                     asprintf (&send_buffer,"VKS%s\r\n",volume_name);
                     result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
                     if (result!=STATE_OK)
                            return result;
                     total_disk_space=strtoul(recv_buffer,NULL,10);

                     percent_purgeable_space=(unsigned long)(((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;
                     asprintf (&output_message,_("%lu MB (%lu%%) purgeable on volume %s|Purgeable%s=%lu;%lu;%lu;0;100"),
                                   purgeable_disk_space,
                                   percent_purgeable_space,
                                   volume_name,
                                   volume_name,
                                   percent_purgeable_space,
                                   warning_value,
                                   critical_value
                                   );
              }

              /* check KB not yet purgeable space on volume */
       } else if (vars_to_check==VKNP) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - 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;
                     asprintf (&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==VPNP) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"VKNP%s\r\n",volume_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {

                     asprintf (&output_message,_("CRITICAL - Volume '%s' does not exist!"),volume_name);
                     result=STATE_CRITICAL;

              } else {

                     non_purgeable_disk_space=strtoul(recv_buffer,NULL,10);

                     close(sd);
                     my_tcp_connect (server_address, server_port, &sd);

                     asprintf (&send_buffer,"VKS%s\r\n",volume_name);
                     result=send_tcp_request(sd,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=(unsigned long)(((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;
                     asprintf (&output_message,_("%lu MB (%lu%%) 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==OFILES) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"S18\r\n");
              result=send_tcp_request(sd,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;

              asprintf (&output_message,_("%lu open files|Openfiles=%lu;%lu;%lu;0,0"),
                            open_files,
                            open_files,
                            warning_value,
                            critical_value);


              /* check # of abended threads (Netware > 5.x only) */
       } else if (vars_to_check==ABENDS) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"S17\r\n");
              result=send_tcp_request(sd,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;

              asprintf (&output_message,_("%lu abended threads|Abends=%lu;%lu;%lu;;"),
                            abended_threads,
                            abended_threads,
                            warning_value,
                            critical_value);

              /* check # of current service processes (Netware 5.x only) */
       } else if (vars_to_check==CSPROCS) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"S20\r\n");
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              max_service_processes=atoi(recv_buffer);

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"S21\r\n");
              result=send_tcp_request(sd,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;

              asprintf (&output_message,
                        _("%lu current service processes (%lu max)|Processes=%lu;%lu;%lu;0;%lu"),
                        current_service_processes,
                        max_service_processes,
                       current_service_processes,
                       warning_value,
                       critical_value,
                       max_service_processes);

              /* check # Timesync Status */
       } else if (vars_to_check==TSYNC) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"S22\r\n");
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              time_sync_status=atoi(recv_buffer);

              if (time_sync_status==0) {
                     result=STATE_CRITICAL;
                     asprintf (&output_message,_("CRITICAL - Time not in sync with network!"));
              }
              else {
                     asprintf (&output_message,_("OK - Time in sync with network!"));
              }





              /* check LRU sitting time in secondss */
       } else if (vars_to_check==LRUS) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("S4\r\n");
              result=send_tcp_request(sd,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;
              asprintf (&output_message,_("LRU sitting time = %lu seconds"),lru_time);


              /* check % dirty cacheobuffers as a percentage of the total*/
       } else if (vars_to_check==DCB) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("S6\r\n");
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;
              dirty_cache_buffers=atoi(recv_buffer);

              if (check_critical_value==TRUE && dirty_cache_buffers <= critical_value)
                     result=STATE_CRITICAL;
              else if (check_warning_value==TRUE && dirty_cache_buffers <= warning_value)
                     result=STATE_WARNING;
              asprintf (&output_message,_("Dirty cache buffers = %lu%% of the total|DCB=%lu;%lu;%lu;0;100"),
                            dirty_cache_buffers,
                            dirty_cache_buffers,
                            warning_value,
                            critical_value);

              /* check % total cache buffers as a percentage of the original*/
       } else if (vars_to_check==TCB) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              send_buffer = strdup ("S7\r\n");
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;
              total_cache_buffers=atoi(recv_buffer);

              if (check_critical_value==TRUE && total_cache_buffers <= critical_value)
                     result=STATE_CRITICAL;
              else if (check_warning_value==TRUE && total_cache_buffers <= warning_value)
                     result=STATE_WARNING;
              asprintf (&output_message,_("Total cache buffers = %lu%% of the original|TCB=%lu;%lu;%lu;0;100"),
                            total_cache_buffers,
                            total_cache_buffers,
                            warning_value,
                            critical_value);

       } else if (vars_to_check==DSVER) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"S13\r\n");
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              recv_buffer[strlen(recv_buffer)-1]=0;

              asprintf (&output_message,_("NDS Version %s"),recv_buffer);

       } else if (vars_to_check==UPTIME) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"UPTIME\r\n");
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;


              recv_buffer[sizeof(recv_buffer)-1]=0;
              recv_buffer[strlen(recv_buffer)-1]=0;

              asprintf (&output_message,_("Up %s"),recv_buffer);

       } else if (vars_to_check==NLM) {

              close(sd);
              my_tcp_connect (server_address, server_port, &sd);

              asprintf (&send_buffer,"S24:%s\r\n",nlm_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              recv_buffer[strlen(recv_buffer)-1]=0;
              if (strcmp(recv_buffer,"-1")) {
                     asprintf (&output_message,_("Module %s version %s is loaded"),nlm_name,recv_buffer);
              } else {
                     result=STATE_CRITICAL;
                     asprintf (&output_message,_("Module %s is not loaded"),nlm_name);

                     }
       } else if (vars_to_check==NRMP) {

              asprintf (&send_buffer,"NRMP:%s\r\n",nrmp_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nrmp_name);
                     result=STATE_CRITICAL;
              }      else {
                     nrmp_value=strtoul(recv_buffer,NULL,10);
                     if (check_critical_value==TRUE && nrmp_value <= critical_value)
                            result=STATE_CRITICAL;
                     else if (check_warning_value==TRUE && nrmp_value <= warning_value)
                            result=STATE_WARNING;
                     asprintf (&output_message,
                               _("%s is  %lu|%s=%lu;%lu;%lu;;"),
                              nrmp_name,
                              nrmp_value,
                             nrmp_name,
                             nrmp_value,
                             warning_value,
                             critical_value);
              }

       } else if (vars_to_check==NRMM) {

              asprintf (&send_buffer,"NRMM:%s\r\n",nrmm_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nrmm_name);
                     result=STATE_CRITICAL;
              }      else {
                     nrmm_value=strtoul(recv_buffer,NULL,10);
                     if (check_critical_value==TRUE && nrmm_value <= critical_value)
                            result=STATE_CRITICAL;
                     else if (check_warning_value==TRUE && nrmm_value <= warning_value)
                            result=STATE_WARNING;
                     asprintf (&output_message,
                               _("%s is  %lu|%s=%lu;%lu;%lu;;"),
                              nrmm_name,
                              nrmm_value,
                             nrmm_name,
                             nrmm_value,
                             warning_value,
                             critical_value);
              }

       } else if (vars_to_check==NRMS) {

              asprintf (&send_buffer,"NRMS:%s\r\n",nrms_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nrms_name);
                     result=STATE_CRITICAL;
              }      else {
                     nrms_value=strtoul(recv_buffer,NULL,10);
                     if (check_critical_value==TRUE && nrms_value >= critical_value)
                            result=STATE_CRITICAL;
                     else if (check_warning_value==TRUE && nrms_value >= warning_value)
                            result=STATE_WARNING;
                     asprintf (&output_message,
                               _("%s is  %lu|%s=%lu;%lu;%lu;;"),
                              nrms_name,
                              nrms_value,
                             nrms_name,
                             nrms_value,
                             warning_value,
                             critical_value);
              }

       } else if (vars_to_check==NSS1) {

              asprintf (&send_buffer,"NSS1:%s\r\n",nss1_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss1_name);
                     result=STATE_CRITICAL;
              }      else {
                     nss1_value=strtoul(recv_buffer,NULL,10);
                     if (check_critical_value==TRUE && nss1_value >= critical_value)
                            result=STATE_CRITICAL;
                     else if (check_warning_value==TRUE && nss1_value >= warning_value)
                            result=STATE_WARNING;
                     asprintf (&output_message,
                               _("%s is  %lu|%s=%lu;%lu;%lu;;"),
                              nss1_name,
                              nss1_value,
                             nss1_name,
                             nss1_value,
                             warning_value,
                             critical_value);
              }

       } else if (vars_to_check==NSS2) {

              asprintf (&send_buffer,"NSS2:%s\r\n",nss2_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss2_name);
                     result=STATE_CRITICAL;
              }      else {
                     nss2_value=strtoul(recv_buffer,NULL,10);
                     if (check_critical_value==TRUE && nss2_value >= critical_value)
                            result=STATE_CRITICAL;
                     else if (check_warning_value==TRUE && nss2_value >= warning_value)
                            result=STATE_WARNING;
                     asprintf (&output_message,
                               _("%s is  %lu|%s=%lu;%lu;%lu;;"),
                              nss2_name,
                              nss2_value,
                             nss2_name,
                             nss2_value,
                             warning_value,
                             critical_value);
              }

       } else if (vars_to_check==NSS3) {

              asprintf (&send_buffer,"NSS3:%s\r\n",nss3_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss3_name);
                     result=STATE_CRITICAL;
              }      else {
                     nss3_value=strtoul(recv_buffer,NULL,10);
                     if (check_critical_value==TRUE && nss3_value >= critical_value)
                            result=STATE_CRITICAL;
                     else if (check_warning_value==TRUE && nss3_value >= warning_value)
                            result=STATE_WARNING;
                     asprintf (&output_message,
                               _("%s is  %lu|%s=%lu;%lu;%lu;;"),
                              nss3_name,
                              nss3_value,
                             nss3_name,
                             nss3_value,
                             warning_value,
                             critical_value);
              }

       } else if (vars_to_check==NSS4) {

              asprintf (&send_buffer,"NSS4:%s\r\n",nss4_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss4_name);
                     result=STATE_CRITICAL;
              }      else {
                     nss4_value=strtoul(recv_buffer,NULL,10);
                     if (check_critical_value==TRUE && nss4_value >= critical_value)
                            result=STATE_CRITICAL;
                     else if (check_warning_value==TRUE && nss4_value >= warning_value)
                            result=STATE_WARNING;
                     asprintf (&output_message,
                               _("%s is  %lu|%s=%lu;%lu;%lu;;"),
                              nss4_name,
                              nss4_value,
                             nss4_name,
                             nss4_value,
                             warning_value,
                             critical_value);
              }

       } else if (vars_to_check==NSS5) {

              asprintf (&send_buffer,"NSS5:%s\r\n",nss5_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss5_name);
                     result=STATE_CRITICAL;
              }      else {
                     nss5_value=strtoul(recv_buffer,NULL,10);
                     if (check_critical_value==TRUE && nss5_value >= critical_value)
                            result=STATE_CRITICAL;
                     else if (check_warning_value==TRUE && nss5_value >= warning_value)
                            result=STATE_WARNING;
                     asprintf (&output_message,
                               _("%s is  %lu|%s=%lu;%lu;%lu;;"),
                              nss5_name,
                              nss5_value,
                             nss5_name,
                             nss5_value,
                             warning_value,
                             critical_value);
              }

       } else if (vars_to_check==NSS6) {

              asprintf (&send_buffer,"NSS6:%s\r\n",nss6_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss6_name);
                     result=STATE_CRITICAL;
              }      else {
                     nss6_value=strtoul(recv_buffer,NULL,10);
                     if (check_critical_value==TRUE && nss6_value >= critical_value)
                            result=STATE_CRITICAL;
                     else if (check_warning_value==TRUE && nss6_value >= warning_value)
                            result=STATE_WARNING;
                     asprintf (&output_message,
                               _("%s is  %lu|%s=%lu;%lu;%lu;;"),
                              nss6_name,
                              nss6_value,
                             nss6_name,
                             nss6_value,
                             warning_value,
                             critical_value);
              }

       } else if (vars_to_check==NSS7) {

              asprintf (&send_buffer,"NSS7:%s\r\n",nss7_name);
              result=send_tcp_request(sd,send_buffer,recv_buffer,sizeof(recv_buffer));
              if (result!=STATE_OK)
                     return result;

              if (!strcmp(recv_buffer,"-1\n")) {
                     asprintf (&output_message,_("CRITICAL - Value '%s' does not exist!"),nss7_name);
                     result=STATE_CRITICAL;
              }      else {
                     nss7_value=strtoul(recv_buffer,NULL,10);
                     if (check_critical_value==TRUE && nss7_value >= critical_value)
                            result=STATE_CRITICAL;
                     else if (check_warning_value==TRUE && nss7_value >= warning_value)
                            result=STATE_WARNING;
                     asprintf (&output_message,
                               _("%s is  %lu|%s=%lu;%lu;%lu;;"),
                              nss7_name,
                              nss7_value,
                             nss7_name,
                             nss7_value,
                             warning_value,
                             critical_value);
              }


}
       else {

              output_message = strdup (_("Nothing to check!\n"));
              result=STATE_UNKNOWN;

       }

       close (sd);

       /* reset timeout */
       alarm(0);

       printf("%s%s\n",netware_version,output_message);

       return result;
}

Here is the call graph for this function:

void print_help ( void  )
void print_usage ( void  )

Definition at line 389 of file check_cpqarray.c.

{
  printf("cpqarrayd [options]\n");
  printf("   -h         prints this text\n");
  printf("   -d         enables debugging\n");
}
enum checkvar int sap_number int process_arguments ( int  argc,
char **  argv 
) [abstract]

Variable Documentation

Definition at line 108 of file check_nwstat.c.

Definition at line 109 of file check_nwstat.c.

Definition at line 107 of file check_nwstat.c.

const char* copyright = "2000-2007"

Definition at line 33 of file check_nwstat.c.

unsigned long critical_value = 0L

Definition at line 106 of file check_nwstat.c.

const char* email = "nagiosplug-devel@lists.sourceforge.net"

Definition at line 34 of file check_nwstat.c.

char* nlm_name = NULL

Definition at line 93 of file check_nwstat.c.

char* nrmm_name = NULL

Definition at line 95 of file check_nwstat.c.

char* nrmp_name = NULL

Definition at line 94 of file check_nwstat.c.

char* nrms_name = NULL

Definition at line 96 of file check_nwstat.c.

char* nss1_name = NULL

Definition at line 97 of file check_nwstat.c.

char* nss2_name = NULL

Definition at line 98 of file check_nwstat.c.

char* nss3_name = NULL

Definition at line 99 of file check_nwstat.c.

char* nss4_name = NULL

Definition at line 100 of file check_nwstat.c.

char* nss5_name = NULL

Definition at line 101 of file check_nwstat.c.

char* nss6_name = NULL

Definition at line 102 of file check_nwstat.c.

char* nss7_name = NULL

Definition at line 103 of file check_nwstat.c.

const char* progname = "check_nwstat"

Definition at line 32 of file check_nwstat.c.

Definition at line 91 of file check_nwstat.c.

Definition at line 104 of file check_nwstat.c.

char* volume_name = NULL

Definition at line 92 of file check_nwstat.c.

unsigned long warning_value = 0L

Definition at line 105 of file check_nwstat.c.