Back to index

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

Go to the source code of this file.

Enumerations

enum  checkvars {
  CHECK_NONE, CHECK_CLIENTVERSION, CHECK_CPULOAD, CHECK_UPTIME,
  CHECK_USEDDISKSPACE, CHECK_SERVICESTATE, CHECK_PROCSTATE, CHECK_MEMUSE,
  CHECK_COUNTER, CHECK_FILEAGE, CHECK_INSTANCES
}
enum  { MAX_VALUE_LIST = 30, PORT = 1248 }

Functions

enum checkvars int show_all
char recv_buffer[MAX_INPUT_BUFFER]
void 
fetch_data (const char *address, int port, const char *sendb)
int process_arguments (int, char **)
void preparelist (char *string)
int strtoularray (unsigned long *array, char *string, const char *delim)
void print_help (void)
void print_usage (void)
int main (int argc, char **argv)

Variables

const char * progname = "check_nt"
const char * copyright = "2000-2007"
const char * email = "nagiosplug-devel@lists.sourceforge.net"
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_warning_value = FALSE
int check_critical_value = FALSE

Enumeration Type Documentation

anonymous enum
Enumerator:
MAX_VALUE_LIST 
PORT 

Definition at line 57 of file check_nt.c.

     {
       MAX_VALUE_LIST = 30,
       PORT = 1248
};
enum checkvars
Enumerator:
CHECK_NONE 
CHECK_CLIENTVERSION 
CHECK_CPULOAD 
CHECK_UPTIME 
CHECK_USEDDISKSPACE 
CHECK_SERVICESTATE 
CHECK_PROCSTATE 
CHECK_MEMUSE 
CHECK_COUNTER 
CHECK_FILEAGE 
CHECK_INSTANCES 

Definition at line 43 of file check_nt.c.


Function Documentation

void fetch_data ( const char *  address,
int  port,
const char *  sendb 
) [abstract]

Definition at line 606 of file check_nt.c.

                                                                   {
       int result;

       result=process_tcp_request(address, port, sendb, recv_buffer,sizeof(recv_buffer));

       if(result!=STATE_OK)
              die (result, _("could not fetch information from server\n"));

       if (!strncmp(recv_buffer,"ERROR",5))
              die (STATE_UNKNOWN, "NSClient - %s\n",recv_buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int main ( int  argc,
char **  argv 
)

Definition at line 84 of file check_nt.c.

                               {

/* should be  int result = STATE_UNKNOWN; */

       int return_code = STATE_UNKNOWN;
       char *send_buffer=NULL;
       char *output_message=NULL;
       char *perfdata=NULL;
       char *temp_string=NULL;
       char *temp_string_perf=NULL;
       char *description=NULL,*counter_unit = NULL;
       char *minval = NULL, *maxval = NULL, *errcvt = NULL;
       char *fds=NULL, *tds=NULL;

       double total_disk_space=0;
       double free_disk_space=0;
       double percent_used_space=0;
       double warning_used_space=0;
       double critical_used_space=0;
       double mem_commitLimit=0;
       double mem_commitByte=0;
       double fminval = 0, fmaxval = 0;
       unsigned long utilization;
       unsigned long uptime;
       unsigned long age_in_minutes;
       double counter_value = 0.0;
       int offset=0;
       int updays=0;
       int uphours=0;
       int upminutes=0;

       int isPercent = FALSE;
       int allRight = FALSE;

       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);

       switch (vars_to_check) {

       case CHECK_CLIENTVERSION:

              asprintf(&send_buffer, "%s&1", req_password);
              fetch_data (server_address, server_port, send_buffer);
              if (value_list != NULL && strcmp(recv_buffer, value_list) != 0) {
                     asprintf (&output_message, _("Wrong client version - running: %s, required: %s"), recv_buffer, value_list);
                     return_code = STATE_WARNING;
              } else {
                     asprintf (&output_message, "%s", recv_buffer);
                     return_code = STATE_OK;
              }
              break;

       case CHECK_CPULOAD:

              if (value_list==NULL)
                     output_message = strdup (_("missing -l parameters"));
              else if (strtoularray(lvalue_list,value_list,",")==FALSE)
                     output_message = strdup (_("wrong -l parameter."));
              else {
                     /* -l parameters is present with only integers */
                     return_code=STATE_OK;
                     temp_string = strdup (_("CPU Load"));
                     temp_string_perf = strdup (" ");

                     /* loop until one of the parameters is wrong or not present */
                     while (lvalue_list[0+offset]> (unsigned long)0 &&
                                           lvalue_list[0+offset]<=(unsigned long)17280 &&
                                           lvalue_list[1+offset]> (unsigned long)0 &&
                                           lvalue_list[1+offset]<=(unsigned long)100 &&
                                           lvalue_list[2+offset]> (unsigned long)0 &&
                                           lvalue_list[2+offset]<=(unsigned long)100) {

                            /* Send request and retrieve data */
                            asprintf(&send_buffer,"%s&2&%lu",req_password,lvalue_list[0+offset]);
                            fetch_data (server_address, server_port, send_buffer);

                            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;

                            asprintf(&output_message,_(" %lu%% (%lu min average)"), utilization, lvalue_list[0+offset]);
                            asprintf(&temp_string,"%s%s",temp_string,output_message);
                            asprintf(&perfdata,_(" '%lu min avg Load'=%lu%%;%lu;%lu;0;100"), lvalue_list[0+offset], utilization,
                              lvalue_list[1+offset], lvalue_list[2+offset]);
                            asprintf(&temp_string_perf,"%s%s",temp_string_perf,perfdata);
                            offset+=3;    /* move across the array */
                     }

                     if (strlen(temp_string)>10) {  /* we had at least one loop */
                            output_message = strdup (temp_string);
                            perfdata = temp_string_perf;
                     } else
                            output_message = strdup (_("not enough values for -l parameters"));
              }
              break;

       case CHECK_UPTIME:

              asprintf(&send_buffer, "%s&3", req_password);
              fetch_data (server_address, server_port, send_buffer);
              uptime=strtoul(recv_buffer,NULL,10);
              updays = uptime / 86400;
              uphours = (uptime % 86400) / 3600;
              upminutes = ((uptime % 86400) % 3600) / 60;
              asprintf(&output_message,_("System Uptime - %u day(s) %u hour(s) %u minute(s)"),updays,uphours, upminutes);
              if (check_critical_value==TRUE && uptime <= critical_value)
                     return_code=STATE_CRITICAL;
              else if (check_warning_value==TRUE && uptime <= warning_value)
                     return_code=STATE_WARNING;
              else
                     return_code=STATE_OK;
              break;

       case CHECK_USEDDISKSPACE:

              if (value_list==NULL)
                     output_message = strdup (_("missing -l parameters"));
              else if (strlen(value_list)!=1)
                     output_message = strdup (_("wrong -l argument"));
              else {
                     asprintf(&send_buffer,"%s&4&%s", req_password, value_list);
                     fetch_data (server_address, server_port, send_buffer);
                     fds=strtok(recv_buffer,"&");
                     tds=strtok(NULL,"&");
                     if(fds!=NULL)
                            free_disk_space=atof(fds);
                     if(tds!=NULL)
                            total_disk_space=atof(tds);

                     if (total_disk_space>0 && free_disk_space>=0) {
                            percent_used_space = ((total_disk_space - free_disk_space) / total_disk_space) * 100;
                            warning_used_space = ((float)warning_value / 100) * total_disk_space;
                            critical_used_space = ((float)critical_value / 100) * total_disk_space;

                            asprintf(&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);
                            asprintf(&temp_string_perf,_("'%s:\\ Used Space'=%.2fGb;%.2f;%.2f;0.00;%.2f"), value_list,
                              (total_disk_space - free_disk_space) / 1073741824, warning_used_space / 1073741824,
                              critical_used_space / 1073741824, total_disk_space / 1073741824);

                            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 = strdup (temp_string);
                            perfdata = temp_string_perf;
                     } else {
                            output_message = strdup (_("Free disk space : Invalid drive"));
                            return_code=STATE_UNKNOWN;
                     }
              }
              break;

       case CHECK_SERVICESTATE:
       case CHECK_PROCSTATE:

              if (value_list==NULL)
                     output_message = strdup (_("No service/process specified"));
              else {
                     preparelist(value_list);           /* replace , between services with & to send the request */
                     asprintf(&send_buffer,"%s&%u&%s&%s", req_password,(vars_to_check==CHECK_SERVICESTATE)?5:6,
                                                  (show_all==TRUE) ? "ShowAll" : "ShowFail",value_list);
                     fetch_data (server_address, server_port, send_buffer);
                     return_code=atoi(strtok(recv_buffer,"&"));
                     temp_string=strtok(NULL,"&");
                     output_message = strdup (temp_string);
              }
              break;

       case CHECK_MEMUSE:

              asprintf(&send_buffer,"%s&7", req_password);
              fetch_data (server_address, server_port, send_buffer);
              mem_commitLimit=atof(strtok(recv_buffer,"&"));
              mem_commitByte=atof(strtok(NULL,"&"));
              percent_used_space = (mem_commitByte / mem_commitLimit) * 100;
              warning_used_space = ((float)warning_value / 100) * mem_commitLimit;
              critical_used_space = ((float)critical_value / 100) * mem_commitLimit;

              /* Divisor should be 1048567, not 3044515, as we are measuring "Commit Charge" here,
              which equals RAM + Pagefiles. */
              asprintf(&output_message,_("Memory usage: total:%.2f Mb - used: %.2f Mb (%.0f%%) - free: %.2f Mb (%.0f%%)"),
                mem_commitLimit / 1048567, mem_commitByte / 1048567, percent_used_space,
                (mem_commitLimit - mem_commitByte) / 1048567, (mem_commitLimit - mem_commitByte) / mem_commitLimit * 100);
              asprintf(&perfdata,_("'Memory usage'=%.2fMb;%.2f;%.2f;0.00;%.2f"), mem_commitByte / 1048567,
                warning_used_space / 1048567, critical_used_space / 1048567, mem_commitLimit / 1048567);

              return_code=STATE_OK;
              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;

              break;

       case CHECK_COUNTER:


              /*
              CHECK_COUNTER has been modified to provide extensive perfdata information.
              In order to do this, some modifications have been done to the code
              and some constraints have been introduced.

              1) For the sake of simplicity of the code, perfdata information will only be
               provided when the "description" field is added.

              2) If the counter you're going to measure is percent-based, the code will detect
               the percent sign in its name and will attribute minimum (0%) and maximum (100%)
               values automagically, as well the %" sign to graph units.

              3) OTOH, if the counter is "absolute", you'll have to provide the following
               the counter unit - that is, the dimensions of the counter you're getting. Examples:
               pages/s, packets transferred, etc.

              4) If you want, you may provide the minimum and maximum values to expect. They aren't mandatory,
               but once specified they MUST have the same order of magnitude and units of -w and -c; otherwise.
               strange things will happen when you make graphs of your data.
              */

              if (value_list == NULL)
                     output_message = strdup (_("No counter specified"));
              else
              {
                     preparelist (value_list);   /* replace , between services with & to send the request */
                     isPercent = (strchr (value_list, '%') != NULL);

                     strtok (value_list, "&");   /* burn the first parameters */
                     description = strtok (NULL, "&");
                     counter_unit = strtok (NULL, "&");
                     asprintf (&send_buffer, "%s&8&%s", req_password, value_list);
                     fetch_data (server_address, server_port, send_buffer);
                     counter_value = atof (recv_buffer);

                     if (description == NULL)
                     asprintf (&output_message, "%.f", counter_value);
                     else if (isPercent)
                     {
                            counter_unit = strdup ("%");
                            allRight = TRUE;
                     }

                     if ((counter_unit != NULL) && (!allRight))
                     {
                            minval = strtok (NULL, "&");
                            maxval = strtok (NULL, "&");

                            /* All parameters specified. Let's check the numbers */

                            fminval = (minval != NULL) ? strtod (minval, &errcvt) : -1;
                            fmaxval = (minval != NULL) ? strtod (maxval, &errcvt) : -1;

                            if ((fminval == 0) && (minval == errcvt))
                                   output_message = strdup (_("Minimum value contains non-numbers"));
                            else
                            {
                                   if ((fmaxval == 0) && (maxval == errcvt))
                                          output_message = strdup (_("Maximum value contains non-numbers"));
                                   else
                                          allRight = TRUE;     /* Everything is OK. */

                            }
                     }
                     else if ((counter_unit == NULL) && (description != NULL))
                            output_message = strdup (_("No unit counter specified"));

                     if (allRight)
                     {
                            /* Let's format the output string, finally... */
                                   if (strstr(description, "%") == NULL) {
                                          asprintf (&output_message, "%s = %.2f %s", description, counter_value, counter_unit);
                                   } else {
                                          /* has formatting, will segv if wrong */
                                          asprintf (&output_message, description, counter_value);
                                   }
                                   asprintf (&output_message, "%s |", output_message);
                                   asprintf (&output_message,"%s %s", output_message,
                                          fperfdata (description, counter_value,
                                                 counter_unit, 1, warning_value, 1, critical_value,
                                                 (!(isPercent) && (minval != NULL)), fminval,
                                                 (!(isPercent) && (minval != NULL)), fmaxval));
                     }
              }

              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 */
                     return_code = STATE_OK;
                     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;
              }
       break;

       case CHECK_FILEAGE:

              if (value_list==NULL)
                     output_message = strdup (_("No counter specified"));
              else {
                     preparelist(value_list);           /* replace , between services with & to send the request */
                     asprintf(&send_buffer,"%s&9&%s", req_password,value_list);
                     fetch_data (server_address, server_port, send_buffer);
                     age_in_minutes = atoi(strtok(recv_buffer,"&"));
                     description = strtok(NULL,"&");
                     output_message = strdup (description);

                     if (critical_value > warning_value) {        /* Normal thresholds */
                            if(check_critical_value==TRUE && age_in_minutes >= critical_value)
                                   return_code=STATE_CRITICAL;
                            else if (check_warning_value==TRUE && age_in_minutes >= warning_value)
                                   return_code=STATE_WARNING;
                            else
                                   return_code=STATE_OK;
                     }
                     else {                                       /* inverse thresholds */
                            if(check_critical_value==TRUE && age_in_minutes <= critical_value)
                                   return_code=STATE_CRITICAL;
                            else if (check_warning_value==TRUE && age_in_minutes <= warning_value)
                                   return_code=STATE_WARNING;
                            else
                                   return_code=STATE_OK;
                     }
              }
              break;

       case CHECK_INSTANCES:
              if (value_list==NULL)
                     output_message = strdup (_("No counter specified"));
              else {
                     asprintf(&send_buffer,"%s&10&%s", req_password,value_list);
                     fetch_data (server_address, server_port, send_buffer);
                     if (!strncmp(recv_buffer,"ERROR",5)) {
                            printf("NSClient - %s\n",recv_buffer);
                            exit(STATE_UNKNOWN);
                     }
                     asprintf(&output_message,"%s",recv_buffer);
                     return_code=STATE_OK;
              }
              break;

       case CHECK_NONE:
       default:
              usage4 (_("Please specify a variable to check"));
              break;

       }

       /* reset timeout */
       alarm(0);

       if (perfdata==NULL)
              printf("%s\n",output_message);
       else
              printf("%s | %s\n",output_message,perfdata);
       return return_code;
}

Here is the call graph for this function:

void preparelist ( char *  string)

Definition at line 637 of file check_nt.c.

                               {
       /* Replace all , with & which is the delimiter for the request */
       int i;

       for (i = 0; (size_t)i < strlen(string); i++)
              if (string[i] == ',') {
                     string[i]='&';
              }
}

Here is the caller 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");
}
int process_arguments ( int  argc,
char **  argv 
)
int strtoularray ( unsigned long *  array,
char *  string,
const char *  delim 
)

Definition at line 618 of file check_nt.c.

                                                                        {
       /* split a <delim> delimited string into a long array */
       int idx=0;
       char *t1;

       for (idx=0;idx<MAX_VALUE_LIST;idx++)
              array[idx]=0;

       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;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 71 of file check_nt.c.

Definition at line 70 of file check_nt.c.

const char* copyright = "2000-2007"

Definition at line 36 of file check_nt.c.

unsigned long critical_value = 0L

Definition at line 69 of file check_nt.c.

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

Definition at line 37 of file check_nt.c.

unsigned long lvalue_list[MAX_VALUE_LIST]

Definition at line 67 of file check_nt.c.

const char* progname = "check_nt"

Definition at line 35 of file check_nt.c.

char* req_password = NULL

Definition at line 66 of file check_nt.c.

Definition at line 62 of file check_nt.c.

Definition at line 64 of file check_nt.c.

char* value_list = NULL

Definition at line 65 of file check_nt.c.

char* volume_name = NULL

Definition at line 63 of file check_nt.c.

unsigned long warning_value = 0L

Definition at line 68 of file check_nt.c.