Back to index

nagios-plugins  1.4.16
Classes | Defines | Typedefs | Functions
utils_base.h File Reference
#include "sha1.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  range_struct
struct  thresholds_struct
struct  state_data_struct
struct  state_key_struct
struct  np_struct

Defines

#define OUTSIDE   0
#define INSIDE   1
#define NP_STATE_FORMAT_VERSION   1
#define NP_THRESHOLDS_CHARS   "0123456789.:@~"
#define NP_RANGE_UNPARSEABLE   1
#define NP_WARN_WITHIN_CRIT   2
#define np_extract_ntpvar(l, n)   np_extract_value(l, n, ',')

Typedefs

typedef struct range_struct range
typedef struct thresholds_struct thresholds
typedef struct state_data_struct state_data
typedef struct state_key_struct state_key
typedef struct np_struct nagios_plugin

Functions

rangeparse_range_string (char *)
int _set_thresholds (thresholds **, char *, char *)
void set_thresholds (thresholds **, char *, char *)
void print_thresholds (const char *, thresholds *)
int check_range (double, range *)
int get_status (double, thresholds *)
char * np_escaped_string (const char *)
void die (int, const char *,...) __attribute__((noreturn
void format (printf, 2, 3)))
int np_check_if_root (void)
int np_warn_if_not_root (void)
char * np_extract_value (const char *, const char *, char)
void np_enable_state (char *, int)
state_datanp_state_read ()
void np_state_write_string (time_t, char *)
void np_init (char *, int argc, char **argv)
void np_set_args (int argc, char **argv)
void np_cleanup ()

Class Documentation

struct range_struct

Definition at line 20 of file utils_base.h.

Class Members
int alert_on
double end
int end_infinity
double start
int start_infinity
struct thresholds_struct

Definition at line 28 of file utils_base.h.

Collaboration diagram for thresholds_struct:
Class Members
range * critical
range * warning
struct state_data_struct

Definition at line 35 of file utils_base.h.

Class Members
void * data
int length
time_t time
struct state_key_struct

Definition at line 42 of file utils_base.h.

Collaboration diagram for state_key_struct:
Class Members
char * _filename
int data_version
char * name
char * plugin_name
state_data * state_data
struct np_struct

Definition at line 50 of file utils_base.h.

Collaboration diagram for np_struct:
Class Members
int argc
char ** argv
char * plugin_name
state_key * state

Define Documentation

#define INSIDE   1

Definition at line 18 of file utils_base.h.

#define np_extract_ntpvar (   l,
 
)    np_extract_value(l, n, ',')

Definition at line 94 of file utils_base.h.

#define NP_RANGE_UNPARSEABLE   1

Definition at line 72 of file utils_base.h.

#define NP_STATE_FORMAT_VERSION   1

Definition at line 33 of file utils_base.h.

#define NP_THRESHOLDS_CHARS   "0123456789.:@~"

Definition at line 65 of file utils_base.h.

#define NP_WARN_WITHIN_CRIT   2

Definition at line 73 of file utils_base.h.

#define OUTSIDE   0

Definition at line 17 of file utils_base.h.


Typedef Documentation

typedef struct np_struct nagios_plugin
typedef struct range_struct range
typedef struct state_data_struct state_data
typedef struct state_key_struct state_key
typedef struct thresholds_struct thresholds

Function Documentation

int _set_thresholds ( thresholds **  ,
char *  ,
char *   
)

Definition at line 153 of file utils_base.c.

{
       thresholds *temp_thresholds = NULL;

       if ((temp_thresholds = malloc(sizeof(thresholds))) == NULL)
              die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
                  strerror(errno));

       temp_thresholds->warning = NULL;
       temp_thresholds->critical = NULL;

       if (warn_string != NULL) {
              if ((temp_thresholds->warning = parse_range_string(warn_string)) == NULL) {
                     return NP_RANGE_UNPARSEABLE;
              }
       }
       if (critical_string != NULL) {
              if ((temp_thresholds->critical = parse_range_string(critical_string)) == NULL) {
                     return NP_RANGE_UNPARSEABLE;
              }
       }

       *my_thresholds = temp_thresholds;

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int check_range ( double  ,
range  
)

Definition at line 215 of file utils_base.c.

{
       int no = FALSE;
       int yes = TRUE;

       if (my_range->alert_on == INSIDE) {
              no = TRUE;
              yes = FALSE;
       }

       if (my_range->end_infinity == FALSE && my_range->start_infinity == FALSE) {
              if ((my_range->start <= value) && (value <= my_range->end)) {
                     return no;
              } else {
                     return yes;
              }
       } else if (my_range->start_infinity == FALSE && my_range->end_infinity == TRUE) {
              if (my_range->start <= value) {
                     return no;
              } else {
                     return yes;
              }
       } else if (my_range->start_infinity == TRUE && my_range->end_infinity == FALSE) {
              if (value <= my_range->end) {
                     return no;
              } else {
                     return yes;
              }
       } else {
              return no;
       }
}

Here is the caller graph for this function:

void die ( int  ,
const char *  ,
  ... 
)
void format ( printf  ,
,
 
)

Here is the caller graph for this function:

int get_status ( double  ,
thresholds  
)

Definition at line 250 of file utils_base.c.

{
       if (my_thresholds->critical != NULL) {
              if (check_range(value, my_thresholds->critical) == TRUE) {
                     return STATE_CRITICAL;
              }
       }
       if (my_thresholds->warning != NULL) {
              if (check_range(value, my_thresholds->warning) == TRUE) {
                     return STATE_WARNING;
              }
       }
       return STATE_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int np_check_if_root ( void  )

Definition at line 295 of file utils_base.c.

{ return (geteuid() == 0); }

Here is the caller graph for this function:

void np_cleanup ( )
void np_enable_state ( char *  ,
int   
)

Definition at line 425 of file utils_base.c.

                                                               {
       state_key *this_state = NULL;
       char *temp_filename = NULL;
       char *temp_keyname = NULL;
       char *p=NULL;

       if(this_nagios_plugin==NULL)
              die(STATE_UNKNOWN, _("This requires np_init to be called"));

       this_state = (state_key *) malloc(sizeof(state_key));
       if(this_state==NULL)
              die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
                  strerror(errno));

       if(keyname==NULL) {
              temp_keyname = _np_state_generate_key();
       } else {
              temp_keyname = strdup(keyname);
              if(temp_keyname==NULL)
                     die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
       }
       /* Die if invalid characters used for keyname */
       p = temp_keyname;
       while(*p!='\0') {
              if(! (isalnum(*p) || *p == '_')) {
                     die(STATE_UNKNOWN, _("Invalid character for keyname - only alphanumerics or '_'"));
              }
              p++;
       }
       this_state->name=temp_keyname;
       this_state->plugin_name=this_nagios_plugin->plugin_name;
       this_state->data_version=expected_data_version;
       this_state->state_data=NULL;

       /* Calculate filename */
       asprintf(&temp_filename, "%s/%s/%s", _np_state_calculate_location_prefix(), this_nagios_plugin->plugin_name, this_state->name);
       this_state->_filename=temp_filename;

       this_nagios_plugin->state = this_state;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* np_escaped_string ( const char *  )

Definition at line 265 of file utils_base.c.

                                             {
       char *data;
       int i, j=0;
       data = strdup(string);
       for (i=0; data[i]; i++) {
              if (data[i] == '\\') {
                     switch(data[++i]) {
                            case 'n':
                                   data[j++] = '\n';
                                   break;
                            case 'r':
                                   data[j++] = '\r';
                                   break;
                            case 't':
                                   data[j++] = '\t';
                                   break;
                            case '\\':
                                   data[j++] = '\\';
                                   break;
                            default:
                                   data[j++] = data[i];
                     }
              } else {
                     data[j++] = data[i];
              }
       }
       data[j] = '\0';
       return data;
}

Here is the caller graph for this function:

char* np_extract_value ( const char *  ,
const char *  ,
char   
)

Definition at line 316 of file utils_base.c.

                                                                        {
       char *tmp=NULL, *value=NULL;
       int i;

       while (1) {
              /* Strip any leading space */
              for (varlist; isspace(varlist[0]); varlist++);

              if (strncmp(name, varlist, strlen(name)) == 0) {
                     varlist += strlen(name);
                     /* strip trailing spaces */
                     for (varlist; isspace(varlist[0]); varlist++);

                     if (varlist[0] == '=') {
                            /* We matched the key, go past the = sign */
                            varlist++;
                            /* strip leading spaces */
                            for (varlist; isspace(varlist[0]); varlist++);

                            if (tmp = index(varlist, sep)) {
                                   /* Value is delimited by a comma */
                                   if (tmp-varlist == 0) continue;
                                   value = (char *)malloc(tmp-varlist+1);
                                   strncpy(value, varlist, tmp-varlist);
                                   value[tmp-varlist] = '\0';
                            } else {
                                   /* Value is delimited by a \0 */
                                   if (strlen(varlist) == 0) continue;
                                   value = (char *)malloc(strlen(varlist) + 1);
                                   strncpy(value, varlist, strlen(varlist));
                                   value[strlen(varlist)] = '\0';
                            }
                            break;
                     }
              }
              if (tmp = index(varlist, sep)) {
                     /* More keys, keep going... */
                     varlist = tmp + 1;
              } else {
                     /* We're done */
                     break;
              }
       }

       /* Clean-up trailing spaces/newlines */
       if (value) for (i=strlen(value)-1; isspace(value[i]); i--) value[i] = '\0';

       return value;
}
void np_init ( char *  ,
int  argc,
char **  argv 
)

Definition at line 36 of file utils_base.c.

                                                         {
       if (this_nagios_plugin==NULL) {
              this_nagios_plugin = malloc(sizeof(nagios_plugin));
              if (this_nagios_plugin==NULL) {
                     die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
                         strerror(errno));
              }
              this_nagios_plugin->plugin_name = strdup(plugin_name);
              if (this_nagios_plugin->plugin_name==NULL)
                     die(STATE_UNKNOWN, _("Cannot execute strdup: %s"), strerror(errno));
              this_nagios_plugin->argc = argc;
              this_nagios_plugin->argv = argv;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void np_set_args ( int  argc,
char **  argv 
)

Definition at line 51 of file utils_base.c.

                                          {
       if (this_nagios_plugin==NULL)
              die(STATE_UNKNOWN, _("This requires np_init to be called"));

       this_nagios_plugin->argc = argc;
       this_nagios_plugin->argv = argv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 473 of file utils_base.c.

                            {
       state_data *this_state_data=NULL;
       FILE *statefile;
       int rc = FALSE;

       if(this_nagios_plugin==NULL)
              die(STATE_UNKNOWN, _("This requires np_init to be called"));

       /* Open file. If this fails, no previous state found */
       statefile = fopen( this_nagios_plugin->state->_filename, "r" );
       if(statefile!=NULL) {

              this_state_data = (state_data *) malloc(sizeof(state_data));
              if(this_state_data==NULL)
                     die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
                         strerror(errno));

              this_state_data->data=NULL;
              this_nagios_plugin->state->state_data = this_state_data;

              rc = _np_state_read_file(statefile);

              fclose(statefile);
       }

       if(rc==FALSE) {
              _cleanup_state_data();
       }

       return this_nagios_plugin->state->state_data;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void np_state_write_string ( time_t  ,
char *   
)

Definition at line 581 of file utils_base.c.

                                                                {
       FILE *fp;
       char *temp_file=NULL;
       int fd=0, result=0;
       time_t current_time;
       char *directories=NULL;
       char *p=NULL;

       if(data_time==0)
              time(&current_time);
       else
              current_time=data_time;
       
       /* If file doesn't currently exist, create directories */
       if(access(this_nagios_plugin->state->_filename,F_OK)!=0) {
              asprintf(&directories, "%s", this_nagios_plugin->state->_filename);
              if(directories==NULL)
                     die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
                         strerror(errno));

              for(p=directories+1; *p; p++) {
                     if(*p=='/') {
                            *p='\0';
                            if((access(directories,F_OK)!=0) && (mkdir(directories, S_IRWXU)!=0)) {
                                   /* Can't free this! Otherwise error message is wrong! */
                                   /* np_free(directories); */ 
                                   die(STATE_UNKNOWN, _("Cannot create directory: %s"), directories);
                            }
                            *p='/';
                     }
              }
              np_free(directories);
       }

       asprintf(&temp_file,"%s.XXXXXX",this_nagios_plugin->state->_filename);
       if(temp_file==NULL)
              die(STATE_UNKNOWN, _("Cannot allocate memory: %s"),
                  strerror(errno));

       if((fd=mkstemp(temp_file))==-1) {
              np_free(temp_file);
              die(STATE_UNKNOWN, _("Cannot create temporary filename"));
       }

       fp=(FILE *)fdopen(fd,"w");
       if(fp==NULL) {
              close(fd);
              unlink(temp_file);
              np_free(temp_file);
              die(STATE_UNKNOWN, _("Unable to open temporary state file"));
       }
       
       fprintf(fp,"# NP State file\n");
       fprintf(fp,"%d\n",NP_STATE_FORMAT_VERSION);
       fprintf(fp,"%d\n",this_nagios_plugin->state->data_version);
       fprintf(fp,"%lu\n",current_time);
       fprintf(fp,"%s\n",data_string);
       
       fchmod(fd, S_IRUSR | S_IWUSR | S_IRGRP);
       
       fflush(fp);

       result=fclose(fp);

       fsync(fd);

       if(result!=0) {
              unlink(temp_file);
              np_free(temp_file);
              die(STATE_UNKNOWN, _("Error writing temp file"));
       }

       if(rename(temp_file, this_nagios_plugin->state->_filename)!=0) {
              unlink(temp_file);
              np_free(temp_file);
              die(STATE_UNKNOWN, _("Cannot rename state temp file"));
       }

       np_free(temp_file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int np_warn_if_not_root ( void  )

Definition at line 297 of file utils_base.c.

                              {
       int status = np_check_if_root();
       if(!status) {
              printf(_("Warning: "));
              printf(_("This plugin must be either run as root or setuid root.\n"));
              printf(_("To run as root, you can use a tool like sudo.\n"));
              printf(_("To set the setuid permissions, use the command:\n"));
              /* XXX could we use something like progname? */
              printf("\tchmod u+s yourpluginfile\n");
       }
       return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

range* parse_range_string ( char *  )

Definition at line 105 of file utils_base.c.

                                {
       range *temp_range;
       double start;
       double end;
       char *end_str;

       temp_range = (range *) malloc(sizeof(range));

       /* Set defaults */
       temp_range->start = 0;
       temp_range->start_infinity = FALSE;
       temp_range->end = 0;
       temp_range->end_infinity = TRUE;
       temp_range->alert_on = OUTSIDE;

       if (str[0] == '@') {
              temp_range->alert_on = INSIDE;
              str++;
       }

       end_str = index(str, ':');
       if (end_str != NULL) {
              if (str[0] == '~') {
                     temp_range->start_infinity = TRUE;
              } else {
                     start = strtod(str, NULL);  /* Will stop at the ':' */
                     set_range_start(temp_range, start);
              }
              end_str++;           /* Move past the ':' */
       } else {
              end_str = str;
       }
       end = strtod(end_str, NULL);
       if (strcmp(end_str, "") != 0) {
              set_range_end(temp_range, end);
       }

       if (temp_range->start_infinity == TRUE ||
              temp_range->end_infinity == TRUE ||
              temp_range->start <= temp_range->end) {
              return temp_range;
       }
       free(temp_range);
       return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_thresholds ( const char *  ,
thresholds  
)

Definition at line 194 of file utils_base.c.

                                                                            {
       printf("%s - ", threshold_name);
       if (! my_threshold) {
              printf("Threshold not set");
       } else {
              if (my_threshold->warning) {
                     printf("Warning: start=%g end=%g; ", my_threshold->warning->start, my_threshold->warning->end);
              } else {
                     printf("Warning not set; ");
              }
              if (my_threshold->critical) {
                     printf("Critical: start=%g end=%g", my_threshold->critical->start, my_threshold->critical->end);
              } else {
                     printf("Critical not set");
              }
       }
       printf("\n");
}

Here is the caller graph for this function:

void set_thresholds ( thresholds **  ,
char *  ,
char *   
)

Definition at line 181 of file utils_base.c.

{
       switch (_set_thresholds(my_thresholds, warn_string, critical_string)) {
       case 0:
              return;
       case NP_RANGE_UNPARSEABLE:
              die(STATE_UNKNOWN, _("Range format incorrect"));
       case NP_WARN_WITHIN_CRIT:
              die(STATE_UNKNOWN, _("Warning level is a subset of critical and will not be alerted"));
              break;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function: