/* handles host check results in an obsessive compulsive manner... */ int obsessive_compulsive_host_check_processor(host *hst) { char *raw_command = NULL; char *processed_command = NULL; int early_timeout = FALSE; double exectime = 0.0; int macro_options = STRIP_ILLEGAL_MACRO_CHARS | ESCAPE_MACRO_CHARS; icinga_macros mac; log_debug_info(DEBUGL_FUNCTIONS, 0, "obsessive_compulsive_host_check_processor()\n"); if (hst == NULL) return ERROR; /* bail out if we shouldn't be obsessing */ if (obsess_over_hosts == FALSE) return OK; if (hst->obsess_over_host == FALSE) return OK; /* if there is no valid command, exit */ if (ochp_command == NULL) return ERROR; /* update macros */ memset(&mac, 0, sizeof(mac)); grab_host_macros_r(&mac, hst); /* get the raw command line */ get_raw_command_line_r(&mac, ochp_command_ptr, ochp_command, &raw_command, macro_options); if (raw_command == NULL) { clear_volatile_macros_r(&mac); return ERROR; } log_debug_info(DEBUGL_CHECKS, 2, "Raw obsessive compulsive host processor command line: %s\n", raw_command); /* process any macros in the raw command line */ process_macros_r(&mac, raw_command, &processed_command, macro_options); if (processed_command == NULL) { clear_volatile_macros_r(&mac); return ERROR; } log_debug_info(DEBUGL_CHECKS, 2, "Processed obsessive compulsive host processor command line: %s\n", processed_command); /* run the command */ my_system_r(&mac, processed_command, ochp_timeout, &early_timeout, &exectime, NULL, 0); clear_volatile_macros_r(&mac); /* check to see if the command timed out */ if (early_timeout == TRUE) logit(NSLOG_RUNTIME_WARNING, TRUE, "Warning: OCHP command '%s' for host '%s' timed out after %d seconds\n", processed_command, hst->name, ochp_timeout); /* free memory */ my_free(raw_command); my_free(processed_command); return OK; }
/* handles service check results in an obsessive compulsive manner... */ int obsessive_compulsive_service_check_processor(service *svc) { char *raw_command = NULL; char *processed_command = NULL; int macro_options = STRIP_ILLEGAL_MACRO_CHARS | ESCAPE_MACRO_CHARS; nagios_macros mac; struct obsessive_compulsive_job *ocj; if (svc == NULL) return ERROR; /* bail out if we shouldn't be obsessing */ if (obsess_over_services == FALSE || svc->obsess == FALSE) return OK; /* if there is no valid command, exit */ if (ocsp_command == NULL) return ERROR; /* update service macros */ memset(&mac, 0, sizeof(mac)); grab_service_macros_r(&mac, svc); get_raw_command_line_r(&mac, ocsp_command_ptr, ocsp_command, &raw_command, macro_options); if (raw_command == NULL) { clear_volatile_macros_r(&mac); return ERROR; } log_debug_info(DEBUGL_CHECKS, 2, "Raw obsessive compulsive service processor command line: %s\n", raw_command); /* process any macros in the raw command line */ process_macros_r(&mac, raw_command, &processed_command, macro_options); nm_free(raw_command); if (processed_command == NULL) { clear_volatile_macros_r(&mac); return ERROR; } log_debug_info(DEBUGL_CHECKS, 2, "Processed obsessive compulsive service processor command line: %s\n", processed_command); /* run the command through a worker */ ocj = nm_calloc(1,sizeof(struct obsessive_compulsive_job)); ocj->hst = svc->host_ptr; ocj->svc = svc; if(ERROR == wproc_run_callback(processed_command, ocsp_timeout, obsessive_compulsive_job_handler, ocj, &mac)) { nm_log(NSLOG_RUNTIME_ERROR, "Unable to start OCSP job for service '%s on host '%s' to worker\n", svc->description, svc->host_ptr->name); free(ocj); } clear_volatile_macros_r(&mac); nm_free(processed_command); return OK; }
/* handles changes in the state of a service */ int handle_service_event(service *svc) { nagios_macros mac; if (svc == NULL) return ERROR; broker_statechange_data(NEBTYPE_STATECHANGE_END, NEBFLAG_NONE, NEBATTR_NONE, SERVICE_STATECHANGE, (void *)svc, svc->current_state, svc->state_type, svc->current_attempt, svc->max_attempts); /* bail out if we shouldn't be running event handlers */ if (enable_event_handlers == FALSE) return OK; if (svc->event_handler_enabled == FALSE) return OK; /* update service macros */ memset(&mac, 0, sizeof(mac)); grab_service_macros_r(&mac, svc); /* run the global service event handler */ run_global_service_event_handler(&mac, svc); /* run the event handler command if there is one */ if (svc->event_handler != NULL) run_service_event_handler(&mac, svc); clear_volatile_macros_r(&mac); return OK; }
/* updates service performance data */ int update_service_performance_data(service *svc) { nagios_macros mac; /* should we be processing performance data for anything? */ if (process_performance_data == FALSE) return OK; /* should we process performance data for this service? */ if (svc->process_performance_data == FALSE) return OK; /* * bail early if we've got nothing to do so we don't spend a lot * of time calculating macros that never get used * on distributed setups, empty perfdata results are required, so * only drop out if demanded via configs. */ if (service_perfdata_process_empty_results == FALSE) { if (!svc || !svc->perf_data || !*svc->perf_data) { return OK; } if ((!service_perfdata_file_template) && !service_perfdata_command) { return OK; } } /* * we know we've got some work to do, so grab the necessary * macros and get busy */ memset(&mac, 0, sizeof(mac)); grab_service_macros_r(&mac, svc); /* run the performance data command */ xpddefault_run_service_performance_data_command(&mac, svc); /* get rid of used memory we won't need anymore */ clear_argv_macros_r(&mac); /* update the performance data file */ xpddefault_update_service_performance_data_file(&mac, svc); /* now free() it all */ clear_volatile_macros_r(&mac); return OK; }
/* updates host performance data */ int update_host_performance_data(host *hst) { nagios_macros mac; /* should we be processing performance data for anything? */ if (process_performance_data == FALSE) return OK; /* should we process performance data for this host? */ if (hst->process_performance_data == FALSE) return OK; /* * bail early if we've got nothing to do so we don't spend a lot * of time calculating macros that never get used * on distributed setups, empty perfdata results are required, so * only drop out if demanded via configs. */ if (host_perfdata_process_empty_results == FALSE) { if (!hst || !hst->perf_data || !*hst->perf_data) { return OK; } if ((!host_perfdata_file_template) && !host_perfdata_command) { return OK; } } /* set up macros and get to work */ memset(&mac, 0, sizeof(mac)); grab_host_macros_r(&mac, hst); /* run the performance data command */ xpddefault_run_host_performance_data_command(&mac, hst); /* no more commands to run, so we won't need this any more */ clear_argv_macros_r(&mac); /* update the performance data file */ xpddefault_update_host_performance_data_file(&mac, hst); /* free() all */ clear_volatile_macros_r(&mac); return OK; }
/* handles changes in the state of a service */ int handle_service_event(service *svc) { host *temp_host = NULL; icinga_macros mac; log_debug_info(DEBUGL_FUNCTIONS, 0, "handle_service_event()\n"); if (svc == NULL) return ERROR; #ifdef USE_EVENT_BROKER /* send event data to broker */ broker_statechange_data(NEBTYPE_STATECHANGE_END, NEBFLAG_NONE, NEBATTR_NONE, SERVICE_STATECHANGE, (void *)svc, svc->current_state, svc->state_type, svc->current_attempt, svc->max_attempts, NULL); #endif /* bail out if we shouldn't be running event handlers */ if (enable_event_handlers == FALSE) return OK; if (svc->event_handler_enabled == FALSE) return OK; /* find the host */ if ((temp_host = (host *)svc->host_ptr) == NULL) return ERROR; /* update service macros */ memset(&mac, 0, sizeof(mac)); grab_host_macros_r(&mac, temp_host); grab_service_macros_r(&mac, svc); /* run the global service event handler */ run_global_service_event_handler(&mac, svc); /* run the event handler command if there is one */ if (svc->event_handler != NULL) run_service_event_handler(&mac, svc); clear_volatile_macros_r(&mac); /* check for external commands - the event handler may have given us some directives... */ check_for_external_commands(); return OK; }
/* free the memory allocated to the linked lists */ void free_memory(nagios_macros *mac) { int i; objectlist *entry, *next; destroy_objects_command(); destroy_objects_timeperiod(); destroy_objects_host(); destroy_objects_service(); destroy_objects_contact(); destroy_objects_contactgroup(); destroy_objects_hostgroup(); destroy_objects_servicegroup(); free_comment_data(); nm_free(global_host_event_handler); nm_free(global_service_event_handler); /* free obsessive compulsive commands */ nm_free(ocsp_command); nm_free(ochp_command); nm_free(object_cache_file); nm_free(object_precache_file); /* * free memory associated with macros. * It's ok to only free the volatile ones, as the non-volatile * are always free()'d before assignment if they're set. * Doing a full free of them here means we'll wipe the constant * macros when we get a reload or restart request through the * command pipe, or when we receive a SIGHUP. */ clear_volatile_macros_r(mac); free_macrox_names(); for (entry = objcfg_files; entry; entry = next) { next = entry->next; nm_free(entry->object_ptr); nm_free(entry); } objcfg_files = NULL; for (entry = objcfg_dirs; entry; entry = next) { next = entry->next; nm_free(entry->object_ptr); nm_free(entry); } objcfg_dirs = NULL; /* free illegal char strings */ nm_free(illegal_object_chars); nm_free(illegal_output_chars); /* free file/path variables */ nm_free(status_file); nm_free(debug_file); nm_free(log_file); mac->x[MACRO_LOGFILE] = NULL; /* assigned from 'log_file' */ nm_free(temp_file); mac->x[MACRO_TEMPFILE] = NULL; /* assigned from temp_file */ nm_free(temp_path); mac->x[MACRO_TEMPPATH] = NULL; /*assigned from temp_path */ nm_free(check_result_path); nm_free(command_file); nm_free(qh_socket_path); mac->x[MACRO_COMMANDFILE] = NULL; /* assigned from command_file */ nm_free(log_archive_path); for (i = 0; i < MAX_USER_MACROS; i++) { nm_free(macro_user[i]); } /* these have no other reference */ nm_free(mac->x[MACRO_ADMINEMAIL]); nm_free(mac->x[MACRO_ADMINPAGER]); nm_free(mac->x[MACRO_RESOURCEFILE]); nm_free(mac->x[MACRO_OBJECTCACHEFILE]); nm_free(mac->x[MACRO_MAINCONFIGFILE]); return; }