[prev in list] [next in list] [prev in thread] [next in thread]
List: nagios-devel
Subject: [Nagios-devel] Xml status cgi for nagios3
From: Matthias Haider <matthiashaider () mac ! com>
Date: 2008-03-21 18:36:37
Message-ID: 6D5FA88F-7307-419C-BC3B-6C552D413E58 () mac ! com
[Download RAW message or body]
Hi everybody,
I wrote a modified version of the nagios core cgi status.c to produce
XML output,
to feed this to Ajax websites like Google Maps, where status
informations get displayed.
The attached code (statusXML.patch) will, when used on a nagios3.0
source , create a new cgi,
called statusXML.c and change the corresponging entry in the Makefile...
I think it could be put into the nagios3 package, as it's a core cgi
that uses the same functions
as the other statusXYZ.c and nees to get compiled with the same
options anyhow.
Please test it, feedback is very welcome.
Attached are the source patch and an example xml output..
br,
Matthias
["statusXML.patch" (statusXML.patch)]
Index: cgi/Makefile.in
===================================================================
--- cgi/Makefile.in (revision 1)
+++ cgi/Makefile.in (revision 19)
@@ -39,7 +39,7 @@
LDFLAGS=@LDFLAGS@
LIBS=@LIBS@ @GLIB_LIBS@
-CGIS=avail.cgi cmd.cgi config.cgi extinfo.cgi history.cgi notifications.cgi \
outages.cgi showlog.cgi status.cgi statuswml.cgi summary.cgi tac.cgi $(CGIEXTRAS) \
+CGIS=avail.cgi cmd.cgi config.cgi extinfo.cgi history.cgi notifications.cgi \
outages.cgi showlog.cgi status.cgi statusXML.cgi statuswml.cgi summary.cgi tac.cgi \
$(CGIEXTRAS)
# External data I/O code and headers
XSDC=@XSDC@
@@ -157,6 +157,9 @@
status.cgi: status.c $(CGIDEPS) $(CDATADEPS)
$(CC) $(CFLAGS) $(LDFLAGS) -o $@ status.c $(CGILIBS) $(CDATALIBS) $(LIBS)
+statusXML.cgi: statusXML.c $(CGIDEPS) $(CDATADEPS)
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ statusXML.c $(CGILIBS) $(CDATALIBS) $(LIBS)
+
statuswml.cgi: statuswml.c $(CGIDEPS)
$(CC) $(CFLAGS) $(LDFLAGS) -o $@ statuswml.c $(CGILIBS) $(LIBS)
Index: cgi/statusXML.c
===================================================================
--- cgi/statusXML.c (revision 0)
+++ cgi/statusXML.c (revision 19)
@@ -0,0 +1,1750 @@
+/**************************************************************************
+ *
+ * STATUS.C - Nagios Status CGI
+ *
+ * Copyright (c) 1999-2008 Ethan Galstad (nagios@nagios.org)
+ * Changed to prodce XML output by Matthias Haider (matthiashaider@mac.com)
+ * Last Modified: 03-14-2008
+ *
+ * License:
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *************************************************************************/
+
+#include "../include/config.h"
+#include "../include/common.h"
+#include "../include/objects.h"
+#include "../include/comments.h"
+#include "../include/macros.h"
+#include "../include/statusdata.h"
+
+#include "../include/cgiutils.h"
+#include "../include/getcgi.h"
+#include "../include/cgiauth.h"
+
+extern int refresh_rate;
+extern time_t program_start;
+
+extern char main_config_file[MAX_FILENAME_LENGTH];
+extern char url_html_path[MAX_FILENAME_LENGTH];
+extern char url_docs_path[MAX_FILENAME_LENGTH];
+extern char url_images_path[MAX_FILENAME_LENGTH];
+extern char url_stylesheets_path[MAX_FILENAME_LENGTH];
+extern char url_logo_images_path[MAX_FILENAME_LENGTH];
+extern char url_media_path[MAX_FILENAME_LENGTH];
+extern char log_file[MAX_FILENAME_LENGTH];
+
+extern char *service_critical_sound;
+extern char *service_warning_sound;
+extern char *service_unknown_sound;
+extern char *host_down_sound;
+extern char *host_unreachable_sound;
+extern char *normal_sound;
+
+extern char *notes_url_target;
+extern char *action_url_target;
+
+extern int suppress_alert_window;
+
+extern int enable_splunk_integration;
+
+extern host *host_list;
+extern service *service_list;
+extern hostgroup *hostgroup_list;
+extern servicegroup *servicegroup_list;
+extern hoststatus *hoststatus_list;
+extern servicestatus *servicestatus_list;
+
+
+#define MAX_MESSAGE_BUFFER 4096
+
+#define DISPLAY_HOSTS 0
+#define DISPLAY_HOSTGROUPS 1
+#define DISPLAY_SERVICEGROUPS 2
+
+#define STYLE_OVERVIEW 0
+#define STYLE_DETAIL 1
+#define STYLE_SUMMARY 2
+#define STYLE_GRID 3
+#define STYLE_HOST_DETAIL 4
+
+/* HOSTSORT structure */
+typedef struct hostsort_struct{
+ hoststatus *hststatus;
+ struct hostsort_struct *next;
+ }hostsort;
+
+/* SERVICESORT structure */
+typedef struct servicesort_struct{
+ servicestatus *svcstatus;
+ struct servicesort_struct *next;
+ }servicesort;
+
+hostsort *hostsort_list=NULL;
+servicesort *servicesort_list=NULL;
+
+int sort_services(int,int); /* sorts services */
+int sort_hosts(int,int); /* sorts \
hosts */ +int compare_servicesort_entries(int,int,servicesort *,servicesort *); /* \
compares service sort entries */ +int compare_hostsort_entries(int,int,hostsort \
*,hostsort *); /* compares host sort entries */ +void \
free_servicesort_list(void); +void free_hostsort_list(void);
+
+void show_host_status_totals(void);
+void show_service_status_totals(void);
+void show_service_detail(void);
+void show_host_detail(void);
+void show_servicegroup_overviews(void);
+void show_servicegroup_overview(servicegroup *);
+void show_servicegroup_summaries(void);
+void show_servicegroup_summary(servicegroup *,int);
+void show_servicegroup_host_totals_summary(servicegroup *);
+void show_servicegroup_service_totals_summary(servicegroup *);
+void show_servicegroup_grids(void);
+void show_servicegroup_grid(servicegroup *);
+void show_hostgroup_overviews(void);
+void show_hostgroup_overview(hostgroup *);
+void show_servicegroup_hostgroup_member_overview(hoststatus *,int,void *);
+void show_servicegroup_hostgroup_member_service_status_totals(char *,void *);
+void show_hostgroup_summaries(void);
+void show_hostgroup_summary(hostgroup *,int);
+void show_hostgroup_host_totals_summary(hostgroup *);
+void show_hostgroup_service_totals_summary(hostgroup *);
+void show_hostgroup_grids(void);
+void show_hostgroup_grid(hostgroup *);
+
+void show_filters(void);
+
+int passes_host_properties_filter(hoststatus *);
+int passes_service_properties_filter(servicestatus *);
+
+void document_header(int);
+void document_footer(void);
+int process_cgivars(void);
+
+
+authdata current_authdata;
+time_t current_time;
+
+char alert_message[MAX_MESSAGE_BUFFER];
+char *host_name=NULL;
+char *hostgroup_name=NULL;
+char *servicegroup_name=NULL;
+char *service_filter=NULL;
+int host_alert=FALSE;
+int show_all_hosts=TRUE;
+int show_all_hostgroups=TRUE;
+int show_all_servicegroups=TRUE;
+int display_type=DISPLAY_HOSTS;
+int overview_columns=3;
+int max_grid_width=8;
+int group_style_type=STYLE_OVERVIEW;
+int navbar_search=FALSE;
+
+int service_status_types=SERVICE_PENDING|SERVICE_OK|SERVICE_UNKNOWN|SERVICE_WARNING|SERVICE_CRITICAL;
+int all_service_status_types=SERVICE_PENDING|SERVICE_OK|SERVICE_UNKNOWN|SERVICE_WARNING|SERVICE_CRITICAL;
+
+int host_status_types=HOST_PENDING|HOST_UP|HOST_DOWN|HOST_UNREACHABLE;
+int all_host_status_types=HOST_PENDING|HOST_UP|HOST_DOWN|HOST_UNREACHABLE;
+
+int all_service_problems=SERVICE_UNKNOWN|SERVICE_WARNING|SERVICE_CRITICAL;
+int all_host_problems=HOST_DOWN|HOST_UNREACHABLE;
+
+unsigned long host_properties=0L;
+unsigned long service_properties=0L;
+
+
+
+
+int sort_type=SORT_NONE;
+int sort_option=SORT_HOSTNAME;
+
+int problem_hosts_down=0;
+int problem_hosts_unreachable=0;
+int problem_services_critical=0;
+int problem_services_warning=0;
+int problem_services_unknown=0;
+
+int embedded=FALSE;
+int display_header=TRUE;
+
+
+
+int main(void){
+ int result=OK;
+ char *sound=NULL;
+ host *temp_host=NULL;
+ hostgroup *temp_hostgroup=NULL;
+ servicegroup *temp_servicegroup=NULL;
+
+ time(¤t_time);
+
+ /* get the arguments passed in the URL */
+ process_cgivars();
+
+ /* reset internal variables */
+ reset_cgi_vars();
+
+ /* read the CGI configuration file */
+ result=read_cgi_config_file(get_cgi_config_location());
+ if(result==ERROR){
+ document_header(FALSE);
+ printf("<ERROR><![CDATA[\n");
+ cgi_config_file_error(get_cgi_config_location());
+ printf("]]></ERROR>\n");
+ document_footer();
+ return ERROR;
+ }
+
+ /* read the main configuration file */
+ result=read_main_config_file(main_config_file);
+ if(result==ERROR){
+ document_header(FALSE);
+ printf("<ERROR><![CDATA[\n");
+ main_config_file_error(main_config_file);
+ printf("]]></ERROR>\n");
+ document_footer();
+ return ERROR;
+ }
+
+ /* read all object configuration data */
+ result=read_all_object_configuration_data(main_config_file,READ_ALL_OBJECT_DATA);
+ if(result==ERROR){
+ document_header(FALSE);
+ printf("<ERROR><![CDATA[\n");
+ object_data_error();
+ printf("]]></ERROR>\n");
+ document_footer();
+ return ERROR;
+ }
+
+ /* read all status data */
+ result=read_all_status_data(get_cgi_config_location(),READ_ALL_STATUS_DATA);
+ if(result==ERROR){
+ document_header(FALSE);
+ printf("<ERROR><![CDATA[\n");
+ status_data_error();
+ printf("]]></ERROR>\n");
+ document_footer();
+ free_memory();
+ return ERROR;
+ }
+
+ /* initialize macros */
+ init_macros();
+
+ document_header(TRUE);
+
+ /* get authentication information */
+ get_authentication_information(¤t_authdata);
+
+
+ /* bottom portion of screen - service or hostgroup detail */
+
+ show_service_detail();
+
+
+ document_footer();
+
+ /* free all allocated memory */
+ free_memory();
+ free_comment_data();
+
+ /* free memory allocated to the sort lists */
+ free_servicesort_list();
+ free_hostsort_list();
+
+ return OK;
+ }
+
+
+void document_header(int use_stylesheet){
+ char date_time[MAX_DATETIME_LENGTH];
+ time_t expire_time;
+
+ printf("Cache-Control: no-store\r\n");
+ printf("Pragma: no-cache\r\n");
+ //printf("Refresh: %d\r\n",refresh_rate);
+
+ get_time_string(¤t_time,date_time,(int)sizeof(date_time),HTTP_DATE_TIME);
+ printf("Last-Modified: %s\r\n",date_time);
+
+ expire_time=(time_t)0L;
+ get_time_string(&expire_time,date_time,(int)sizeof(date_time),HTTP_DATE_TIME);
+ printf("Expires: %s\r\n",date_time);
+
+ printf("Content-type: application/xml\r\n\r\n");
+
+ if(embedded==TRUE)
+ return;
+
+ printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+ printf("<ROOT>");
+
+ return;
+ }
+
+
+void document_footer(void){
+
+ if(embedded==TRUE)
+ return;
+
+ printf("</ROOT>");
+
+ return;
+ }
+
+
+int process_cgivars(void){
+ char **variables;
+ int error=FALSE;
+ int x;
+
+ variables=getcgivars();
+
+ for(x=0;variables[x]!=NULL;x++){
+
+ /* do some basic length checking on the variable identifier to prevent buffer \
overflows */ + if(strlen(variables[x])>=MAX_INPUT_BUFFER-1){
+ x++;
+ continue;
+ }
+
+ /* we found the navbar search argument */
+ else if(!strcmp(variables[x],"navbarsearch")){
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+ navbar_search=TRUE;
+ }
+
+ /* we found the hostgroup argument */
+ else if(!strcmp(variables[x],"hostgroup")){
+ display_type=DISPLAY_HOSTGROUPS;
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ hostgroup_name=(char *)strdup(variables[x]);
+ strip_html_brackets(hostgroup_name);
+
+ if(hostgroup_name!=NULL && !strcmp(hostgroup_name,"all"))
+ show_all_hostgroups=TRUE;
+ else
+ show_all_hostgroups=FALSE;
+ }
+
+ /* we found the servicegroup argument */
+ else if(!strcmp(variables[x],"servicegroup")){
+ display_type=DISPLAY_SERVICEGROUPS;
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ servicegroup_name=strdup(variables[x]);
+ strip_html_brackets(servicegroup_name);
+
+ if(servicegroup_name!=NULL && !strcmp(servicegroup_name,"all"))
+ show_all_servicegroups=TRUE;
+ else
+ show_all_servicegroups=FALSE;
+ }
+
+ /* we found the host argument */
+ else if(!strcmp(variables[x],"host")){
+ display_type=DISPLAY_HOSTS;
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ host_name=strdup(variables[x]);
+ strip_html_brackets(host_name);
+
+ if(host_name!=NULL && !strcmp(host_name,"all"))
+ show_all_hosts=TRUE;
+ else
+ show_all_hosts=FALSE;
+ }
+
+ /* we found the columns argument */
+ else if(!strcmp(variables[x],"columns")){
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ overview_columns=atoi(variables[x]);
+ if(overview_columns<=0)
+ overview_columns=1;
+ }
+
+ /* we found the service status type argument */
+ else if(!strcmp(variables[x],"servicestatustypes")){
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ service_status_types=atoi(variables[x]);
+ }
+
+ /* we found the host status type argument */
+ else if(!strcmp(variables[x],"hoststatustypes")){
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ host_status_types=atoi(variables[x]);
+ }
+
+ /* we found the service properties argument */
+ else if(!strcmp(variables[x],"serviceprops")){
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ service_properties=strtoul(variables[x],NULL,10);
+ }
+
+ /* we found the host properties argument */
+ else if(!strcmp(variables[x],"hostprops")){
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ host_properties=strtoul(variables[x],NULL,10);
+ }
+
+ /* we found the host or service group style argument */
+ else if(!strcmp(variables[x],"style")){
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ if(!strcmp(variables[x],"overview"))
+ group_style_type=STYLE_OVERVIEW;
+ else if(!strcmp(variables[x],"detail"))
+ group_style_type=STYLE_DETAIL;
+ else if(!strcmp(variables[x],"summary"))
+ group_style_type=STYLE_SUMMARY;
+ else if(!strcmp(variables[x],"grid"))
+ group_style_type=STYLE_GRID;
+ else if(!strcmp(variables[x],"hostdetail"))
+ group_style_type=STYLE_HOST_DETAIL;
+ else
+ group_style_type=STYLE_DETAIL;
+ }
+
+ /* we found the sort type argument */
+ else if(!strcmp(variables[x],"sorttype")){
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ sort_type=atoi(variables[x]);
+ }
+
+ /* we found the sort option argument */
+ else if(!strcmp(variables[x],"sortoption")){
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+
+ sort_option=atoi(variables[x]);
+ }
+
+ /* we found the embed option */
+ else if(!strcmp(variables[x],"embedded"))
+ embedded=TRUE;
+
+ /* we found the noheader option */
+ else if(!strcmp(variables[x],"noheader"))
+ display_header=FALSE;
+
+ /* servicefilter cgi var */
+ else if(!strcmp(variables[x],"servicefilter")){
+ x++;
+ if(variables[x]==NULL){
+ error=TRUE;
+ break;
+ }
+ service_filter=strdup(variables[x]);
+ strip_html_brackets(service_filter);
+ }
+ }
+
+ /* free memory allocated to the CGI variables */
+ free_cgivars(variables);
+
+ return error;
+ }
+
+
+
+/* display a detailed listing of the status of all services... */
+void show_service_detail(void){
+ regex_t preg;
+ time_t t;
+ char date_time[MAX_DATETIME_LENGTH];
+ char state_duration[48];
+ char status[MAX_INPUT_BUFFER];
+ char temp_buffer[MAX_INPUT_BUFFER];
+ char temp_url[MAX_INPUT_BUFFER];
+ char *processed_string=NULL;
+ char *status_class="";
+ char *status_bg_class="";
+ char *host_status_bg_class="";
+ char *last_host="";
+ int new_host=FALSE;
+ servicestatus *temp_status=NULL;
+ hostgroup *temp_hostgroup=NULL;
+ servicegroup *temp_servicegroup=NULL;
+ hoststatus *temp_hoststatus=NULL;
+ host *temp_host=NULL;
+ service *temp_service=NULL;
+ int odd=0;
+ int total_comments=0;
+ int user_has_seen_something=FALSE;
+ servicesort *temp_servicesort=NULL;
+ int use_sort=FALSE;
+ int result=OK;
+ int first_entry=TRUE;
+ int days;
+ int hours;
+ int minutes;
+ int seconds;
+ int duration_error=FALSE;
+ int total_entries=0;
+ int show_service=FALSE;
+ int is_first_displayed_host=TRUE;
+
+
+ /* sort the service list if necessary */
+ if(sort_type!=SORT_NONE){
+ result=sort_services(sort_type,sort_option);
+ if(result==ERROR)
+ use_sort=FALSE;
+ else
+ use_sort=TRUE;
+ }
+ else
+ use_sort=FALSE;
+
+
+ if(display_header==TRUE)
+ show_filters();
+
+
+ if(use_sort==TRUE){
+ printf("<SORT>Entries sorted by ");
+ if(sort_option==SORT_HOSTNAME)
+ printf("host name");
+ else if(sort_option==SORT_SERVICENAME)
+ printf("service name");
+ else if(sort_option==SORT_SERVICESTATUS)
+ printf("service status");
+ else if(sort_option==SORT_LASTCHECKTIME)
+ printf("last check time");
+ else if(sort_option==SORT_CURRENTATTEMPT)
+ printf("attempt number");
+ else if(sort_option==SORT_STATEDURATION)
+ printf("state duration");
+ printf("(%s)\n",(sort_type==SORT_ASCENDING)?"ascending":"descending");
+ printf("</SORT>\n");
+ }
+
+ if(service_filter!=NULL)
+ printf("<FILTER>Filtered By Services Matching \'%s\'</FILTER>\n",service_filter);
+
+
+
+ snprintf(temp_url,sizeof(temp_url)-1,"%s?",STATUS_CGI);
+ temp_url[sizeof(temp_url)-1]='\x0';
+ if(display_type==DISPLAY_HOSTS)
+ snprintf(temp_buffer,sizeof(temp_buffer)-1,"host=%s",host_name);
+ else if(display_type==DISPLAY_SERVICEGROUPS)
+ snprintf(temp_buffer,sizeof(temp_buffer)-1,"servicegroup=%s&style=detail",servicegroup_name);
+ else
+ snprintf(temp_buffer,sizeof(temp_buffer)-1,"hostgroup=%s&style=detail",hostgroup_name);
+ temp_buffer[sizeof(temp_buffer)-1]='\x0';
+ strncat(temp_url,temp_buffer,sizeof(temp_url)-strlen(temp_url)-1);
+ temp_url[sizeof(temp_url)-1]='\x0';
+ if(service_status_types!=all_service_status_types){
+ snprintf(temp_buffer,sizeof(temp_buffer)-1,"&servicestatustypes=%d",service_status_types);
+ temp_buffer[sizeof(temp_buffer)-1]='\x0';
+ strncat(temp_url,temp_buffer,sizeof(temp_url)-strlen(temp_url)-1);
+ temp_url[sizeof(temp_url)-1]='\x0';
+ }
+ if(host_status_types!=all_host_status_types){
+ snprintf(temp_buffer,sizeof(temp_buffer)-1,"&hoststatustypes=%d",host_status_types);
+ temp_buffer[sizeof(temp_buffer)-1]='\x0';
+ strncat(temp_url,temp_buffer,sizeof(temp_url)-strlen(temp_url)-1);
+ temp_url[sizeof(temp_url)-1]='\x0';
+ }
+ if(service_properties!=0){
+ snprintf(temp_buffer,sizeof(temp_buffer)-1,"&serviceprops=%lu",service_properties);
+ temp_buffer[sizeof(temp_buffer)-1]='\x0';
+ strncat(temp_url,temp_buffer,sizeof(temp_url)-strlen(temp_url)-1);
+ temp_url[sizeof(temp_url)-1]='\x0';
+ }
+ if(host_properties!=0){
+ snprintf(temp_buffer,sizeof(temp_buffer)-1,"&hostprops=%lu",host_properties);
+ temp_buffer[sizeof(temp_buffer)-1]='\x0';
+ strncat(temp_url,temp_buffer,sizeof(temp_url)-strlen(temp_url)-1);
+ temp_url[sizeof(temp_url)-1]='\x0';
+ }
+
+ /* the main list of services */
+
+
+ if(service_filter!=NULL)
+ regcomp(&preg,service_filter,0);
+
+ temp_hostgroup=find_hostgroup(hostgroup_name);
+ temp_servicegroup=find_servicegroup(servicegroup_name);
+
+ /* check all services... */
+ while(1){
+
+ /* get the next service to display */
+ if(use_sort==TRUE){
+ if(first_entry==TRUE)
+ temp_servicesort=servicesort_list;
+ else
+ temp_servicesort=temp_servicesort->next;
+ if(temp_servicesort==NULL)
+ break;
+ temp_status=temp_servicesort->svcstatus;
+ }
+ else{
+ if(first_entry==TRUE)
+ temp_status=servicestatus_list;
+ else
+ temp_status=temp_status->next;
+ }
+
+ if(temp_status==NULL)
+ break;
+
+ first_entry=FALSE;
+
+ /* find the service */
+ temp_service=find_service(temp_status->host_name,temp_status->description);
+
+ /* if we couldn't find the service, go to the next service */
+ if(temp_service==NULL)
+ continue;
+
+ /* find the host */
+ temp_host=find_host(temp_service->host_name);
+
+ /* make sure user has rights to see this... */
+ if(is_authorized_for_service(temp_service,¤t_authdata)==FALSE)
+ continue;
+
+ user_has_seen_something=TRUE;
+
+ /* get the host status information */
+ temp_hoststatus=find_hoststatus(temp_service->host_name);
+
+ /* see if we should display services for hosts with tis type of status */
+ if(!(host_status_types & temp_hoststatus->status))
+ continue;
+
+ /* see if we should display this type of service status */
+ if(!(service_status_types & temp_status->status))
+ continue;
+
+ /* check host properties filter */
+ if(passes_host_properties_filter(temp_hoststatus)==FALSE)
+ continue;
+
+ /* check service properties filter */
+ if(passes_service_properties_filter(temp_status)==FALSE)
+ continue;
+
+ /* servicefilter cgi var */
+ if(service_filter!=NULL)
+ if(regexec(&preg,temp_status->description,0,NULL,0))
+ continue;
+
+ show_service=FALSE;
+
+ if(display_type==DISPLAY_HOSTS){
+ if(show_all_hosts==TRUE)
+ show_service=TRUE;
+ else if(!strcmp(host_name,temp_status->host_name))
+ show_service=TRUE;
+ }
+
+ else if(display_type==DISPLAY_HOSTGROUPS){
+ if(show_all_hostgroups==TRUE)
+ show_service=TRUE;
+ else if(is_host_member_of_hostgroup(temp_hostgroup,temp_host)==TRUE)
+ show_service=TRUE;
+ }
+
+ else if(display_type==DISPLAY_SERVICEGROUPS){
+ if(show_all_servicegroups==TRUE)
+ show_service=TRUE;
+ else if(is_service_member_of_servicegroup(temp_servicegroup,temp_service)==TRUE)
+ show_service=TRUE;
+ }
+
+ /* if we are not at the first service and have new host, we need to close the tag \
of the last host*/ + if((show_service==TRUE)&&(strcmp(last_host,temp_status->host_name))&&(first_entry==FALSE)&&(is_first_displayed_host==FALSE)){
+ printf("</HOST>\n");
+ }
+
+ first_entry=FALSE;
+
+
+ if(show_service==TRUE){
+
+ if(strcmp(last_host,temp_status->host_name))
+ new_host=TRUE;
+ else
+ new_host=FALSE;
+
+ if(new_host==TRUE){
+ if(strcmp(last_host,"")){
+ /* we are at the first host*/
+ }
+ }
+
+ if(odd)
+ odd=0;
+ else
+ odd=1;
+
+ /* keep track of total number of services we're displaying */
+ total_entries++;
+
+ /* get the last service check time */
+ t=temp_status->last_check;
+ get_time_string(&t,date_time,(int)sizeof(date_time),SHORT_DATE_TIME);
+ if((unsigned long)temp_status->last_check==0L)
+ strcpy(date_time,"N/A");
+
+ if(temp_status->status==SERVICE_PENDING){
+ strncpy(status,"PENDING",sizeof(status));
+ status_class="PENDING";
+ status_bg_class=(odd)?"Even":"Odd";
+ }
+ else if(temp_status->status==SERVICE_OK){
+ strncpy(status,"OK",sizeof(status));
+ status_class="OK";
+ status_bg_class=(odd)?"Even":"Odd";
+ }
+ else if(temp_status->status==SERVICE_WARNING){
+ strncpy(status,"WARNING",sizeof(status));
+ status_class="WARNING";
+ if(temp_status->problem_has_been_acknowledged==TRUE)
+ status_bg_class="BGWARNINGACK";
+ else if(temp_status->scheduled_downtime_depth>0)
+ status_bg_class="BGWARNINGSCHED";
+ else
+ status_bg_class="BGWARNING";
+ }
+ else if(temp_status->status==SERVICE_UNKNOWN){
+ strncpy(status,"UNKNOWN",sizeof(status));
+ status_class="UNKNOWN";
+ if(temp_status->problem_has_been_acknowledged==TRUE)
+ status_bg_class="BGUNKNOWNACK";
+ else if(temp_status->scheduled_downtime_depth>0)
+ status_bg_class="BGUNKNOWNSCHED";
+ else
+ status_bg_class="BGUNKNOWN";
+ }
+ else if(temp_status->status==SERVICE_CRITICAL){
+ strncpy(status,"CRITICAL",sizeof(status));
+ status_class="CRITICAL";
+ if(temp_status->problem_has_been_acknowledged==TRUE)
+ status_bg_class="BGCRITICALACK";
+ else if(temp_status->scheduled_downtime_depth>0)
+ status_bg_class="BGCRITICALSCHED";
+ else
+ status_bg_class="BGCRITICAL";
+ }
+ status[sizeof(status)-1]='\x0';
+
+
+ /* host name column */
+ if(new_host==TRUE){
+
+ /* grab macros */
+ grab_host_macros(temp_host);
+
+ printf("<HOST NAME=\"%s\" ALIAS=\"%s\" IP_ADRESS=\"%s\" \
",temp_status->host_name,temp_host->alias,temp_host->address); +
+ is_first_displayed_host=FALSE;
+
+ /* first general information about the host*/
+ if(temp_hoststatus->status==HOST_DOWN){
+ printf(" STATUS=\"DOWN\" ");
+ }
+ else if(temp_hoststatus->status==HOST_UNREACHABLE){
+ printf(" STATUS=\"UNREACHABLE\" ");
+ }
+ else{
+ printf(" STATUS=\"OK\" ");
+ }
+
+ printf(" STATE_TYPE=\"%s\" \
",(temp_hoststatus->state_type==HARD_STATE)?"HARD":"SOFT"); +
+ total_comments=number_of_host_comments(temp_host->name);
+
+ if(temp_hoststatus->problem_has_been_acknowledged==TRUE)
+ printf(" ACKNOWLEDGED=\"TRUE\" ");
+ else
+ printf(" ACKNOWLEDGED=\"FALSE\" ");
+
+ if(total_comments>0)
+ printf(" COMMENTS=\"%d\" ",total_comments);
+ else
+ printf(" COMMENTS=\"0\" ");
+
+ if(temp_hoststatus->notifications_enabled==TRUE)
+ printf(" NOTIFICATIONS_ENABLED=\"TRUE\" ");
+ else
+ printf(" NOTIFICATIONS_ENABLED=\"FALSE\" ");
+
+ if(temp_hoststatus->checks_enabled==TRUE)
+ printf(" CHECKS_ENABLED=\"TRUE\" ");
+ else
+ printf(" CHECKS_ENABLED=\"FALSE\" ");
+
+ if(temp_hoststatus->is_flapping==TRUE)
+ printf(" IS_FLAPPING=\"TRUE\" ");
+ else
+ printf(" IS_FLAPPING=\"FALSE\" ");
+
+ if(temp_hoststatus->scheduled_downtime_depth>0)
+ printf(" SCHEDULED_DOWNTIME=\"TRUE\" ");
+ else
+ printf(" SCHEDULED_DOWNTIME=\"FALSE\" ");
+
+ /* close the <HOST> tag*/
+ printf(" >");
+
+
+ /* This data was in the ext_info object in nagios2, so we keep the xml structure \
for compatibility...*/ + printf("<EXTRA_INFO ");
+ if(temp_host->notes_url!=NULL){
+ process_macros(temp_host->notes_url,&processed_string,0);
+ printf(" NOTES_URL=\"$s\" ",processed_string);
+ free(processed_string);
+ }
+ if(temp_host->action_url!=NULL){
+ process_macros(temp_host->action_url,&processed_string,0);
+ printf(" ACTION_URL=\"$s\" ",processed_string);
+ free(processed_string);
+ }
+ if(temp_host->icon_image!=NULL){
+ process_macros(temp_host->icon_image,&processed_string,0);
+ printf(" IMG_URL=\"%s\" ",processed_string);
+ free(processed_string);
+ }
+
+ if(temp_host->x_2d){
+ printf(" X_2D_COORD=\"%i\"",temp_host->x_2d);
+ }
+ if(temp_host->x_2d){
+ printf(" Y_2D_COORD=\"%i\"",temp_host->y_2d);
+ }
+ if(temp_host->x_2d){
+ printf(" X_3D_COORD=\"%lf\"",temp_host->x_3d);
+ }
+ if(temp_host->x_2d){
+ printf(" Y_3D_COORD=\"%lf\"",temp_host->y_3d);
+ }
+ if(temp_host->x_2d){
+ printf(" Z_3D_COORD=\"%lf\"",temp_host->z_3d);;
+ }
+ printf("></EXTRA_INFO>\n");
+
+
+ }
+ else
+ printf("");
+
+ /* grab macros */
+ grab_service_macros(temp_service);
+
+ /* service name column */
+ printf("<SERVICE DESCRIPTION=\"%s\" ",temp_status->description);
+
+ printf(" PERFORMANCE_DATA=\"%s\" \
",(temp_status->perf_data==NULL)?"":temp_status->perf_data); +
+ printf(" STATE_TYPE=\"%s\" \
",(temp_status->state_type==HARD_STATE)?"HARD":"SOFT"); +
+ total_comments=number_of_service_comments(temp_service->host_name,temp_service->description);
+ if(total_comments>0)
+ printf(" COMMENTS=\"%d\" ",total_comments);
+ else
+ printf(" COMMENTS=\"0\" ");
+
+ if(temp_status->problem_has_been_acknowledged==TRUE)
+ printf(" ACKNOWLEDGED=\"TRUE\" ");
+ else
+ printf(" ACKNOWLEDGED=\"FALSE\" ");
+
+ if(temp_status->checks_enabled==FALSE)
+ printf(" ACTIVE_CHECKS_ENABLED=\"FALSE\" ");
+ else
+ printf(" ACTIVE_CHECKS_ENABLED=\"TRUE\" ");
+
+ if(temp_status->accept_passive_service_checks==FALSE)
+ printf(" PASSIVE_CHECKS_ENABLED=\"FALSE\" ");
+ else
+ printf(" PASSIVE_CHECKS_ENABLED=\"TRUE\" ");
+
+ if(temp_status->notifications_enabled==TRUE)
+ printf(" NOTIFICATIONS_ENABLED=\"TRUE\" ");
+ else
+ printf(" NOTIFICATIONS_ENABLED=\"FALSE\" ");
+
+ if(temp_status->is_flapping==TRUE)
+ printf(" IS_FLAPPING=\"TRUE\" ");
+ else
+ printf(" IS_FLAPPING=\"FALSE\" ");
+
+ if(temp_status->scheduled_downtime_depth>0)
+ printf(" SCHEDULED_DOWNTIME=\"TRUE\" ");
+ else
+ printf(" SCHEDULED_DOWNTIME=\"FALSE\" ");
+
+ /* state duration calculation... */
+ t=0;
+ duration_error=FALSE;
+ if(temp_status->last_state_change==(time_t)0){
+ if(program_start>current_time)
+ duration_error=TRUE;
+ else
+ t=current_time-program_start;
+ }
+ else{
+ if(temp_status->last_state_change>current_time)
+ duration_error=TRUE;
+ else
+ t=current_time-temp_status->last_state_change;
+ }
+ get_time_breakdown((unsigned long)t,&days,&hours,&minutes,&seconds);
+ if(duration_error==TRUE)
+ snprintf(state_duration,sizeof(state_duration)-1,"???");
+ else
+ snprintf(state_duration,sizeof(state_duration)-1,"%2dd %2dh %2dm \
%2ds%s",days,hours,minutes,seconds,(temp_status->last_state_change==(time_t)0)?"+":"");
+ state_duration[sizeof(state_duration)-1]='\x0';
+
+ /* the rest of the columns... */
+ printf(" STATUS=\"%s\" ",status);
+ printf(" LAST_CHECK=\"%s\" ",date_time);
+ printf(" DURATION=\"%s\" ",state_duration);
+ printf(" ATTEMPT=\"%d of %d\" \
",temp_status->current_attempt,temp_status->max_attempts); + printf(" \
OUTPUT=\"%s\"",(temp_status->plugin_output==NULL)?"":url_encode(temp_status->plugin_output));
+
+
+ /*Closing the SERVICE tag*/
+ printf(" >\n");
+
+ printf("<EXTRA_INFO ");
+
+ if(temp_service->notes_url!=NULL){
+ process_macros(temp_service->notes_url,&processed_string,0);
+ printf(" NOTES_URL=\"%s\" ",url_encode(processed_string));
+ free(processed_string);
+ }
+ if(temp_service->action_url!=NULL){
+ process_macros(temp_service->action_url,&processed_string,0);
+ printf(" ACTION_URL=\"%s\" ",url_encode(processed_string));
+ free(processed_string);
+ }
+ if(temp_service->icon_image!=NULL){
+ process_macros(temp_service->icon_image,&processed_string,0);
+ printf(" IMG_URL=\"%s\" ",url_encode(processed_string));
+ free(processed_string);
+ }
+
+ printf("></EXTRA_INFO>\n");
+
+ /*Closing the SERVICE tag*/
+ printf("</SERVICE>\n");
+
+ last_host=temp_status->host_name;
+
+ }
+
+ }
+
+
+ /* if user couldn't see anything, print out some helpful info... */
+ if(user_has_seen_something==FALSE){
+
+ if(servicestatus_list!=NULL){
+ printf("<ERROR>It appears as though you do not have permission to view \
information for any of the services you requested..\n"); + printf("If you believe \
this is an error, check the HTTP server authentication requirements for accessing \
this CGI\n"); + printf("and check the authorization options in your CGI \
configuration file.</ERROR>\n"); + }
+ else{
+ printf("<ERROR>There doesn't appear to be any service status information in the \
status log...\n"); + printf("Make sure that Nagios is running and that you have \
specified the location of you status log correctly in the configuration \
files.</ERROR>\n"); + }
+ }
+
+ else
+ if(is_first_displayed_host==FALSE){
+ printf("</HOST>");
+ }
+ printf("<TOTAL>%d Matching Service Entries Displayed</TOTAL>",total_entries);
+
+ return;
+ }
+
+
+
+/******************************************************************/
+/********** SERVICE SORTING & FILTERING FUNCTIONS ***************/
+/******************************************************************/
+
+
+/* sorts the service list */
+int sort_services(int s_type, int s_option){
+ servicesort *new_servicesort;
+ servicesort *last_servicesort;
+ servicesort *temp_servicesort;
+ servicestatus *temp_svcstatus;
+
+ if(s_type==SORT_NONE)
+ return ERROR;
+
+ if(servicestatus_list==NULL)
+ return ERROR;
+
+ /* sort all services status entries */
+ for(temp_svcstatus=servicestatus_list;temp_svcstatus!=NULL;temp_svcstatus=temp_svcstatus->next){
+
+ /* allocate memory for a new sort structure */
+ new_servicesort=(servicesort *)malloc(sizeof(servicesort));
+ if(new_servicesort==NULL)
+ return ERROR;
+
+ new_servicesort->svcstatus=temp_svcstatus;
+
+ last_servicesort=servicesort_list;
+ for(temp_servicesort=servicesort_list;temp_servicesort!=NULL;temp_servicesort=temp_servicesort->next){
+
+ if(compare_servicesort_entries(s_type,s_option,new_servicesort,temp_servicesort)==TRUE){
+ new_servicesort->next=temp_servicesort;
+ if(temp_servicesort==servicesort_list)
+ servicesort_list=new_servicesort;
+ else
+ last_servicesort->next=new_servicesort;
+ break;
+ }
+ else
+ last_servicesort=temp_servicesort;
+ }
+
+ if(servicesort_list==NULL){
+ new_servicesort->next=NULL;
+ servicesort_list=new_servicesort;
+ }
+ else if(temp_servicesort==NULL){
+ new_servicesort->next=NULL;
+ last_servicesort->next=new_servicesort;
+ }
+ }
+
+ return OK;
+ }
+
+
+int compare_servicesort_entries(int s_type, int s_option, servicesort \
*new_servicesort, servicesort *temp_servicesort){ + servicestatus *new_svcstatus;
+ servicestatus *temp_svcstatus;
+ time_t nt;
+ time_t tt;
+
+ new_svcstatus=new_servicesort->svcstatus;
+ temp_svcstatus=temp_servicesort->svcstatus;
+
+ if(s_type==SORT_ASCENDING){
+
+ if(s_option==SORT_LASTCHECKTIME){
+ if(new_svcstatus->last_check < temp_svcstatus->last_check)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_CURRENTATTEMPT){
+ if(new_svcstatus->current_attempt < temp_svcstatus->current_attempt)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_SERVICESTATUS){
+ if(new_svcstatus->status <= temp_svcstatus->status)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_HOSTNAME){
+ if(strcasecmp(new_svcstatus->host_name,temp_svcstatus->host_name)<0)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_SERVICENAME){
+ if(strcasecmp(new_svcstatus->description,temp_svcstatus->description)<0)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_STATEDURATION){
+ if(new_svcstatus->last_state_change==(time_t)0)
+ nt=(program_start>current_time)?0:(current_time-program_start);
+ else
+ nt=(new_svcstatus->last_state_change>current_time)?0:(current_time-new_svcstatus->last_state_change);
+ if(temp_svcstatus->last_state_change==(time_t)0)
+ tt=(program_start>current_time)?0:(current_time-program_start);
+ else
+ tt=(temp_svcstatus->last_state_change>current_time)?0:(current_time-temp_svcstatus->last_state_change);
+ if(nt<tt)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ }
+ else{
+ if(s_option==SORT_LASTCHECKTIME){
+ if(new_svcstatus->last_check > temp_svcstatus->last_check)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_CURRENTATTEMPT){
+ if(new_svcstatus->current_attempt > temp_svcstatus->current_attempt)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_SERVICESTATUS){
+ if(new_svcstatus->status > temp_svcstatus->status)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_HOSTNAME){
+ if(strcasecmp(new_svcstatus->host_name,temp_svcstatus->host_name)>0)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_SERVICENAME){
+ if(strcasecmp(new_svcstatus->description,temp_svcstatus->description)>0)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_STATEDURATION){
+ if(new_svcstatus->last_state_change==(time_t)0)
+ nt=(program_start>current_time)?0:(current_time-program_start);
+ else
+ nt=(new_svcstatus->last_state_change>current_time)?0:(current_time-new_svcstatus->last_state_change);
+ if(temp_svcstatus->last_state_change==(time_t)0)
+ tt=(program_start>current_time)?0:(current_time-program_start);
+ else
+ tt=(temp_svcstatus->last_state_change>current_time)?0:(current_time-temp_svcstatus->last_state_change);
+ if(nt>tt)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+ }
+
+
+
+/* sorts the host list */
+int sort_hosts(int s_type, int s_option){
+ hostsort *new_hostsort;
+ hostsort *last_hostsort;
+ hostsort *temp_hostsort;
+ hoststatus *temp_hststatus;
+
+ if(s_type==SORT_NONE)
+ return ERROR;
+
+ if(hoststatus_list==NULL)
+ return ERROR;
+
+ /* sort all hosts status entries */
+ for(temp_hststatus=hoststatus_list;temp_hststatus!=NULL;temp_hststatus=temp_hststatus->next){
+
+ /* allocate memory for a new sort structure */
+ new_hostsort=(hostsort *)malloc(sizeof(hostsort));
+ if(new_hostsort==NULL)
+ return ERROR;
+
+ new_hostsort->hststatus=temp_hststatus;
+
+ last_hostsort=hostsort_list;
+ for(temp_hostsort=hostsort_list;temp_hostsort!=NULL;temp_hostsort=temp_hostsort->next){
+
+ if(compare_hostsort_entries(s_type,s_option,new_hostsort,temp_hostsort)==TRUE){
+ new_hostsort->next=temp_hostsort;
+ if(temp_hostsort==hostsort_list)
+ hostsort_list=new_hostsort;
+ else
+ last_hostsort->next=new_hostsort;
+ break;
+ }
+ else
+ last_hostsort=temp_hostsort;
+ }
+
+ if(hostsort_list==NULL){
+ new_hostsort->next=NULL;
+ hostsort_list=new_hostsort;
+ }
+ else if(temp_hostsort==NULL){
+ new_hostsort->next=NULL;
+ last_hostsort->next=new_hostsort;
+ }
+ }
+
+ return OK;
+ }
+
+
+int compare_hostsort_entries(int s_type, int s_option, hostsort *new_hostsort, \
hostsort *temp_hostsort){ + hoststatus *new_hststatus;
+ hoststatus *temp_hststatus;
+ time_t nt;
+ time_t tt;
+
+ new_hststatus=new_hostsort->hststatus;
+ temp_hststatus=temp_hostsort->hststatus;
+
+ if(s_type==SORT_ASCENDING){
+
+ if(s_option==SORT_LASTCHECKTIME){
+ if(new_hststatus->last_check < temp_hststatus->last_check)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_HOSTSTATUS){
+ if(new_hststatus->status <= temp_hststatus->status)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_HOSTNAME){
+ if(strcasecmp(new_hststatus->host_name,temp_hststatus->host_name)<0)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_STATEDURATION){
+ if(new_hststatus->last_state_change==(time_t)0)
+ nt=(program_start>current_time)?0:(current_time-program_start);
+ else
+ nt=(new_hststatus->last_state_change>current_time)?0:(current_time-new_hststatus->last_state_change);
+ if(temp_hststatus->last_state_change==(time_t)0)
+ tt=(program_start>current_time)?0:(current_time-program_start);
+ else
+ tt=(temp_hststatus->last_state_change>current_time)?0:(current_time-temp_hststatus->last_state_change);
+ if(nt<tt)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ }
+ else{
+ if(s_option==SORT_LASTCHECKTIME){
+ if(new_hststatus->last_check > temp_hststatus->last_check)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_HOSTSTATUS){
+ if(new_hststatus->status > temp_hststatus->status)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_HOSTNAME){
+ if(strcasecmp(new_hststatus->host_name,temp_hststatus->host_name)>0)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ else if(s_option==SORT_STATEDURATION){
+ if(new_hststatus->last_state_change==(time_t)0)
+ nt=(program_start>current_time)?0:(current_time-program_start);
+ else
+ nt=(new_hststatus->last_state_change>current_time)?0:(current_time-new_hststatus->last_state_change);
+ if(temp_hststatus->last_state_change==(time_t)0)
+ tt=(program_start>current_time)?0:(current_time-program_start);
+ else
+ tt=(temp_hststatus->last_state_change>current_time)?0:(current_time-temp_hststatus->last_state_change);
+ if(nt>tt)
+ return TRUE;
+ else
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+ }
+
+
+
+/* free all memory allocated to the servicesort structures */
+void free_servicesort_list(void){
+ servicesort *this_servicesort;
+ servicesort *next_servicesort;
+
+ /* free memory for the servicesort list */
+ for(this_servicesort=servicesort_list;this_servicesort!=NULL;this_servicesort=next_servicesort){
+ next_servicesort=this_servicesort->next;
+ free(this_servicesort);
+ }
+
+ return;
+ }
+
+
+/* free all memory allocated to the hostsort structures */
+void free_hostsort_list(void){
+ hostsort *this_hostsort;
+ hostsort *next_hostsort;
+
+ /* free memory for the hostsort list */
+ for(this_hostsort=hostsort_list;this_hostsort!=NULL;this_hostsort=next_hostsort){
+ next_hostsort=this_hostsort->next;
+ free(this_hostsort);
+ }
+
+ return;
+ }
+
+
+
+/* check host properties filter */
+int passes_host_properties_filter(hoststatus *temp_hoststatus){
+
+ if((host_properties & HOST_SCHEDULED_DOWNTIME) && \
temp_hoststatus->scheduled_downtime_depth<=0) + return FALSE;
+
+ if((host_properties & HOST_NO_SCHEDULED_DOWNTIME) && \
temp_hoststatus->scheduled_downtime_depth>0) + return FALSE;
+
+ if((host_properties & HOST_STATE_ACKNOWLEDGED) && \
temp_hoststatus->problem_has_been_acknowledged==FALSE) + return FALSE;
+
+ if((host_properties & HOST_STATE_UNACKNOWLEDGED) && \
temp_hoststatus->problem_has_been_acknowledged==TRUE) + return FALSE;
+
+ if((host_properties & HOST_CHECKS_DISABLED) && \
temp_hoststatus->checks_enabled==TRUE) + return FALSE;
+
+ if((host_properties & HOST_CHECKS_ENABLED) && \
temp_hoststatus->checks_enabled==FALSE) + return FALSE;
+
+ if((host_properties & HOST_EVENT_HANDLER_DISABLED) && \
temp_hoststatus->event_handler_enabled==TRUE) + return FALSE;
+
+ if((host_properties & HOST_EVENT_HANDLER_ENABLED) && \
temp_hoststatus->event_handler_enabled==FALSE) + return FALSE;
+
+ if((host_properties & HOST_FLAP_DETECTION_DISABLED) && \
temp_hoststatus->flap_detection_enabled==TRUE) + return FALSE;
+
+ if((host_properties & HOST_FLAP_DETECTION_ENABLED) && \
temp_hoststatus->flap_detection_enabled==FALSE) + return FALSE;
+
+ if((host_properties & HOST_IS_FLAPPING) && temp_hoststatus->is_flapping==FALSE)
+ return FALSE;
+
+ if((host_properties & HOST_IS_NOT_FLAPPING) && temp_hoststatus->is_flapping==TRUE)
+ return FALSE;
+
+ if((host_properties & HOST_NOTIFICATIONS_DISABLED) && \
temp_hoststatus->notifications_enabled==TRUE) + return FALSE;
+
+ if((host_properties & HOST_NOTIFICATIONS_ENABLED) && \
temp_hoststatus->notifications_enabled==FALSE) + return FALSE;
+
+ if((host_properties & HOST_PASSIVE_CHECKS_DISABLED) && \
temp_hoststatus->accept_passive_host_checks==TRUE) + return FALSE;
+
+ if((host_properties & HOST_PASSIVE_CHECKS_ENABLED) && \
temp_hoststatus->accept_passive_host_checks==FALSE) + return FALSE;
+
+ if((host_properties & HOST_PASSIVE_CHECK) && \
temp_hoststatus->check_type==HOST_CHECK_ACTIVE) + return FALSE;
+
+ if((host_properties & HOST_ACTIVE_CHECK) && \
temp_hoststatus->check_type==HOST_CHECK_PASSIVE) + return FALSE;
+
+ if((host_properties & HOST_HARD_STATE) && temp_hoststatus->state_type==SOFT_STATE)
+ return FALSE;
+
+ if((host_properties & HOST_SOFT_STATE) && temp_hoststatus->state_type==HARD_STATE)
+ return FALSE;
+
+ return TRUE;
+ }
+
+
+
+/* check service properties filter */
+int passes_service_properties_filter(servicestatus *temp_servicestatus){
+
+ if((service_properties & SERVICE_SCHEDULED_DOWNTIME) && \
temp_servicestatus->scheduled_downtime_depth<=0) + return FALSE;
+
+ if((service_properties & SERVICE_NO_SCHEDULED_DOWNTIME) && \
temp_servicestatus->scheduled_downtime_depth>0) + return FALSE;
+
+ if((service_properties & SERVICE_STATE_ACKNOWLEDGED) && \
temp_servicestatus->problem_has_been_acknowledged==FALSE) + return FALSE;
+
+ if((service_properties & SERVICE_STATE_UNACKNOWLEDGED) && \
temp_servicestatus->problem_has_been_acknowledged==TRUE) + return FALSE;
+
+ if((service_properties & SERVICE_CHECKS_DISABLED) && \
temp_servicestatus->checks_enabled==TRUE) + return FALSE;
+
+ if((service_properties & SERVICE_CHECKS_ENABLED) && \
temp_servicestatus->checks_enabled==FALSE) + return FALSE;
+
+ if((service_properties & SERVICE_EVENT_HANDLER_DISABLED) && \
temp_servicestatus->event_handler_enabled==TRUE) + return FALSE;
+
+ if((service_properties & SERVICE_EVENT_HANDLER_ENABLED) && \
temp_servicestatus->event_handler_enabled==FALSE) + return FALSE;
+
+ if((service_properties & SERVICE_FLAP_DETECTION_DISABLED) && \
temp_servicestatus->flap_detection_enabled==TRUE) + return FALSE;
+
+ if((service_properties & SERVICE_FLAP_DETECTION_ENABLED) && \
temp_servicestatus->flap_detection_enabled==FALSE) + return FALSE;
+
+ if((service_properties & SERVICE_IS_FLAPPING) && \
temp_servicestatus->is_flapping==FALSE) + return FALSE;
+
+ if((service_properties & SERVICE_IS_NOT_FLAPPING) && \
temp_servicestatus->is_flapping==TRUE) + return FALSE;
+
+ if((service_properties & SERVICE_NOTIFICATIONS_DISABLED) && \
temp_servicestatus->notifications_enabled==TRUE) + return FALSE;
+
+ if((service_properties & SERVICE_NOTIFICATIONS_ENABLED) && \
temp_servicestatus->notifications_enabled==FALSE) + return FALSE;
+
+ if((service_properties & SERVICE_PASSIVE_CHECKS_DISABLED) && \
temp_servicestatus->accept_passive_service_checks==TRUE) + return FALSE;
+
+ if((service_properties & SERVICE_PASSIVE_CHECKS_ENABLED) && \
temp_servicestatus->accept_passive_service_checks==FALSE) + return FALSE;
+
+ if((service_properties & SERVICE_PASSIVE_CHECK) && \
temp_servicestatus->check_type==SERVICE_CHECK_ACTIVE) + return FALSE;
+
+ if((service_properties & SERVICE_ACTIVE_CHECK) && \
temp_servicestatus->check_type==SERVICE_CHECK_PASSIVE) + return FALSE;
+
+ if((service_properties & SERVICE_HARD_STATE) && \
temp_servicestatus->state_type==SOFT_STATE) + return FALSE;
+
+ if((service_properties & SERVICE_SOFT_STATE) && \
temp_servicestatus->state_type==HARD_STATE) + return FALSE;
+
+ return TRUE;
+ }
+
+
+
+/* shows service and host filters in use */
+void show_filters(void){
+ int found=0;
+
+ /* show filters box if necessary */
+ if(host_properties!=0L || service_properties!=0L || \
host_status_types!=all_host_status_types || \
service_status_types!=all_service_status_types){ +
+ printf("<FILTER ");
+ printf(" HOST_STATUS_TYPES=\"");
+ if(host_status_types==all_host_status_types)
+ printf("All");
+ else if(host_status_types==all_host_problems)
+ printf("All problems");
+ else{
+ found=0;
+ if(host_status_types & HOST_PENDING){
+ printf(" Pending");
+ found=1;
+ }
+ if(host_status_types & HOST_UP){
+ printf("%s Up",(found==1)?" |":"");
+ found=1;
+ }
+ if(host_status_types & HOST_DOWN){
+ printf("%s Down",(found==1)?" |":"");
+ found=1;
+ }
+ if(host_status_types & HOST_UNREACHABLE)
+ printf("%s Unreachable",(found==1)?" |":"");
+ }
+ printf("\" ");
+ printf(" HOST_PROPERTIES=\"");
+ if(host_properties==0)
+ printf("Any");
+ else{
+ found=0;
+ if(host_properties & HOST_SCHEDULED_DOWNTIME){
+ printf(" In Scheduled Downtime");
+ found=1;
+ }
+ if(host_properties & HOST_NO_SCHEDULED_DOWNTIME){
+ printf("%s Not In Scheduled Downtime",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_STATE_ACKNOWLEDGED){
+ printf("%s Has Been Acknowledged",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_STATE_UNACKNOWLEDGED){
+ printf("%s Has Not Been Acknowledged",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_CHECKS_DISABLED){
+ printf("%s Checks Disabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_CHECKS_ENABLED){
+ printf("%s Checks Enabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_EVENT_HANDLER_DISABLED){
+ printf("%s Event Handler Disabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_EVENT_HANDLER_ENABLED){
+ printf("%s Event Handler Enabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_FLAP_DETECTION_DISABLED){
+ printf("%s Flap Detection Disabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_FLAP_DETECTION_ENABLED){
+ printf("%s Flap Detection Enabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_IS_FLAPPING){
+ printf("%s Is Flapping",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_IS_NOT_FLAPPING){
+ printf("%s Is Not Flapping",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_NOTIFICATIONS_DISABLED){
+ printf("%s Notifications Disabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_NOTIFICATIONS_ENABLED){
+ printf("%s Notifications Enabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_PASSIVE_CHECKS_DISABLED){
+ printf("%s Passive Checks Disabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_PASSIVE_CHECKS_ENABLED){
+ printf("%s Passive Checks Enabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_PASSIVE_CHECK){
+ printf("%s Passive Checks",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_ACTIVE_CHECK){
+ printf("%s Active Checks",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_HARD_STATE){
+ printf("%s In Hard State",(found==1)?" &":"");
+ found=1;
+ }
+ if(host_properties & HOST_SOFT_STATE){
+ printf("%s In Soft State",(found==1)?" &":"");
+ found=1;
+ }
+ }
+ printf("\" ");
+
+
+ printf(" SERVICE_STATUS_TYPES=\"");
+ if(service_status_types==all_service_status_types)
+ printf("All");
+ else if(service_status_types==all_service_problems)
+ printf("All Problems");
+ else{
+ found=0;
+ if(service_status_types & SERVICE_PENDING){
+ printf(" Pending");
+ found=1;
+ }
+ if(service_status_types & SERVICE_OK){
+ printf("%s Ok",(found==1)?" |":"");
+ found=1;
+ }
+ if(service_status_types & SERVICE_UNKNOWN){
+ printf("%s Unknown",(found==1)?" |":"");
+ found=1;
+ }
+ if(service_status_types & SERVICE_WARNING){
+ printf("%s Warning",(found==1)?" |":"");
+ found=1;
+ }
+ if(service_status_types & SERVICE_CRITICAL){
+ printf("%s Critical",(found==1)?" |":"");
+ found=1;
+ }
+ }
+ printf("\" ");
+ printf("SERVICE_PROPERTIES=\"");
+ if(service_properties==0)
+ printf("Any");
+ else{
+ found=0;
+ if(service_properties & SERVICE_SCHEDULED_DOWNTIME){
+ printf(" In Scheduled Downtime");
+ found=1;
+ }
+ if(service_properties & SERVICE_NO_SCHEDULED_DOWNTIME){
+ printf("%s Not In Scheduled Downtime",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_STATE_ACKNOWLEDGED){
+ printf("%s Has Been Acknowledged",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_STATE_UNACKNOWLEDGED){
+ printf("%s Has Not Been Acknowledged",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_CHECKS_DISABLED){
+ printf("%s Active Checks Disabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_CHECKS_ENABLED){
+ printf("%s Active Checks Enabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_EVENT_HANDLER_DISABLED){
+ printf("%s Event Handler Disabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_EVENT_HANDLER_ENABLED){
+ printf("%s Event Handler Enabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_FLAP_DETECTION_DISABLED){
+ printf("%s Flap Detection Disabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_FLAP_DETECTION_ENABLED){
+ printf("%s Flap Detection Enabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_IS_FLAPPING){
+ printf("%s Is Flapping",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_IS_NOT_FLAPPING){
+ printf("%s Is Not Flapping",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_NOTIFICATIONS_DISABLED){
+ printf("%s Notifications Disabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_NOTIFICATIONS_ENABLED){
+ printf("%s Notifications Enabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_PASSIVE_CHECKS_DISABLED){
+ printf("%s Passive Checks Disabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_PASSIVE_CHECKS_ENABLED){
+ printf("%s Passive Checks Enabled",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_PASSIVE_CHECK){
+ printf("%s Passive Checks",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_ACTIVE_CHECK){
+ printf("%s Active Checks",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_HARD_STATE){
+ printf("%s In Hard State",(found==1)?" &":"");
+ found=1;
+ }
+ if(service_properties & SERVICE_SOFT_STATE){
+ printf("%s In Soft State",(found==1)?" &":"");
+ found=1;
+ }
+ }
+ printf("\" ");
+ /* close the <FILTER> tag*/
+ printf("/>\n");
+ }
+
+ return;
+ }
+
+
["statusXML-sampleoutput.xml" (statusXML-sampleoutput.xml)]
<?xml version="1.0" encoding="UTF-8"?>
<ROOT><FILTER HOST_STATUS_TYPES="All" HOST_PROPERTIES="Any" SERVICE_STATUS_TYPES=" \
Ok" SERVICE_PROPERTIES="Any"/> <SORT>Entries sorted by service status(descending)
</SORT>
<HOST NAME="localhost" ALIAS="localhost" IP_ADRESS="127.0.0.1" STATUS="OK" \
STATE_TYPE="HARD" ACKNOWLEDGED="FALSE" COMMENTS="0" NOTIFICATIONS_ENABLED="TRUE" \
CHECKS_ENABLED="TRUE" IS_FLAPPING="FALSE" SCHEDULED_DOWNTIME="FALSE"><EXTRA_INFO \
IMG_URL="base/debian.png" X_2D_COORD="-1" Y_2D_COORD="-1" X_3D_COORD="0.000000" \
Y_3D_COORD="0.000000" Z_3D_COORD="0.000000"/> <SERVICE DESCRIPTION="Current Load" \
PERFORMANCE_DATA="load1=0.090;5.000;10.000;0; load5=0.390;4.000;6.000;0; \
load15=0.610;3.000;4.000;0;" STATE_TYPE="HARD" COMMENTS="0" ACKNOWLEDGED="FALSE" \
ACTIVE_CHECKS_ENABLED="TRUE" PASSIVE_CHECKS_ENABLED="TRUE" \
NOTIFICATIONS_ENABLED="TRUE" IS_FLAPPING="FALSE" SCHEDULED_DOWNTIME="FALSE" \
STATUS="OK" LAST_CHECK="2008-03-21 19:23:05" DURATION=" 0d 0h 5m 47s" ATTEMPT="1 of \
4" OUTPUT="OK%20-%20load%20average%3A%200.09%2C%200.39%2C%200.61"> <EXTRA_INFO/>
</SERVICE>
<SERVICE DESCRIPTION="Current Users" PERFORMANCE_DATA="users=2;20;50;0" \
STATE_TYPE="HARD" COMMENTS="0" ACKNOWLEDGED="FALSE" ACTIVE_CHECKS_ENABLED="TRUE" \
PASSIVE_CHECKS_ENABLED="TRUE" NOTIFICATIONS_ENABLED="TRUE" IS_FLAPPING="FALSE" \
SCHEDULED_DOWNTIME="FALSE" STATUS="OK" LAST_CHECK="2008-03-21 19:23:43" DURATION=" 0d \
0h 5m 9s" ATTEMPT="1 of 4" \
OUTPUT="USERS%20OK%20-%202%20users%20currently%20logged%20in"> <EXTRA_INFO/>
</SERVICE>
<SERVICE DESCRIPTION="HTTP" PERFORMANCE_DATA="time=0.013798s;;;0.000000 \
size=549B;;;0" STATE_TYPE="HARD" COMMENTS="0" ACKNOWLEDGED="FALSE" \
ACTIVE_CHECKS_ENABLED="TRUE" PASSIVE_CHECKS_ENABLED="TRUE" \
NOTIFICATIONS_ENABLED="TRUE" IS_FLAPPING="FALSE" SCHEDULED_DOWNTIME="FALSE" \
STATUS="OK" LAST_CHECK="2008-03-21 19:19:58" DURATION=" 0d 0h 3m 54s" ATTEMPT="1 of \
4" OUTPUT="OK%20-%20HTTP%2F1.1%20302%20Found%20-%200.014%20second%20response%20time"> \
<EXTRA_INFO/> </SERVICE>
<SERVICE DESCRIPTION="OutputLenth" PERFORMANCE_DATA="" STATE_TYPE="HARD" COMMENTS="0" \
ACKNOWLEDGED="FALSE" ACTIVE_CHECKS_ENABLED="TRUE" PASSIVE_CHECKS_ENABLED="TRUE" \
NOTIFICATIONS_ENABLED="TRUE" IS_FLAPPING="FALSE" SCHEDULED_DOWNTIME="FALSE" \
STATUS="OK" LAST_CHECK="2008-03-21 19:20:35" DURATION=" 0d 0h 3m 17s" ATTEMPT="1 of \
4" OUTPUT="1%202%203%204%205%206%207%208%209%2010%2011%2012%2013%2014%2015%2016%2017%2 \
018%2019%2020%2021%2022%2023%2024%2025%2026%2027%2028%2029%2030%2031%2032%2033%2034%20 \
35%2036%2037%2038%2039%2040%2041%2042%2043%2044%2045%2046%2047%2048%2049%2050%2051%205 \
2%2053%2054%2055%2056%2057%2058%2059%2060%2061%2062%2063%2064%2065%2066%2067%2068%2069 \
%2070%2071%2072%2073%2074%2075%2076%2077%2078%2079%2080%2081%2082%2083%2084%2085%2086% \
2087%2088%2089%2090%2091%2092%2093%2094%2095%2096%2097%2098%2099%20100%20101%20102%201 \
03%20104%20105%20106%20107%20108%20109%20110%20111%20112%20113%20114%20115%20116%20117 \
%20118%20119%20120%20121%20122%20123%20124%20125%20126%20127%20128%20129%20130%20131%2 \
0132%20133%20134%20135%20136%20137%20138%20139%20140%20141%20142%20143%20144%20145%201 \
46%20147%20148%20149%20150%20151%20152%20153%20154%20155%20156%20157%20158%20159%20160 \
%20161%20162%20163%20164%20165%20166%20167%20168%20169%20170%20171%20172%20173%20174%2 \
0175%20176%20177%20178%20179%20180%20181%20182%20183%20184%20185%20186%20187%20188%20189">
<EXTRA_INFO/>
</SERVICE>
<SERVICE DESCRIPTION="PING" PERFORMANCE_DATA="" STATE_TYPE="HARD" COMMENTS="0" \
ACKNOWLEDGED="FALSE" ACTIVE_CHECKS_ENABLED="TRUE" PASSIVE_CHECKS_ENABLED="TRUE" \
NOTIFICATIONS_ENABLED="TRUE" IS_FLAPPING="FALSE" SCHEDULED_DOWNTIME="FALSE" \
STATUS="OK" LAST_CHECK="2008-03-21 19:21:13" DURATION=" 0d 0h 2m 39s" ATTEMPT="1 of \
4" OUTPUT="PING%20OK%20-%20Packet%20loss%20%3D%200%25%2C%20RTA%20%3D%200.06%20ms"> \
<EXTRA_INFO/> </SERVICE>
<SERVICE DESCRIPTION="SSH" PERFORMANCE_DATA="" STATE_TYPE="HARD" COMMENTS="0" \
ACKNOWLEDGED="FALSE" ACTIVE_CHECKS_ENABLED="TRUE" PASSIVE_CHECKS_ENABLED="TRUE" \
NOTIFICATIONS_ENABLED="TRUE" IS_FLAPPING="FALSE" SCHEDULED_DOWNTIME="FALSE" \
STATUS="OK" LAST_CHECK="2008-03-21 19:21:50" DURATION=" 0d 0h 2m 2s" ATTEMPT="1 of \
4" OUTPUT="SSH%20OK%20-%20OpenSSH_4.3p2%20Debian-9%20%28protocol%202.0%29"> \
<EXTRA_INFO/> </SERVICE>
<SERVICE DESCRIPTION="Total Processes" PERFORMANCE_DATA="" STATE_TYPE="HARD" \
COMMENTS="0" ACKNOWLEDGED="FALSE" ACTIVE_CHECKS_ENABLED="TRUE" \
PASSIVE_CHECKS_ENABLED="TRUE" NOTIFICATIONS_ENABLED="TRUE" IS_FLAPPING="FALSE" \
SCHEDULED_DOWNTIME="FALSE" STATUS="OK" LAST_CHECK="2008-03-21 19:22:29" DURATION=" 0d \
0h 1m 23s" ATTEMPT="1 of 4" OUTPUT="PROCS%20OK%3A%2053%20processes"> <EXTRA_INFO/>
</SERVICE>
</HOST><TOTAL>7 Matching Service Entries Displayed</TOTAL></ROOT>
-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Nagios-devel mailing list
Nagios-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/nagios-devel
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic