ettore.dreucci/mk_livestatus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
Phillip Smith
2021-08-24 17:55:37 +10:00
commit 69e42aac8d
387 changed files with 69168 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
nagios4/README Normal file
View File

@@ -0,0 +1 @@
These files are taken directly from Nagios 4.0.2.

156
nagios4/bitmap.h Normal file
View File

@@ -0,0 +1,156 @@
#ifndef LIBNAGIOS_bitmap_h__
#define LIBNAGIOS_bitmap_h__
/**
* @file bitmap.h
* @brief Bit map API
*
* The bitmap api is useful for running set operations on objects
* indexed by unsigned integers.
* @{
*/
struct bitmap;
typedef struct bitmap bitmap;
/**
* Resize a bitmap
* If the bitmap is made smaller, data will silently be lost.
*
* @param bm The bitmap to resize
* @param size The new desired size of the bitmap
* @return 0 on success, -1 on errors.
*/
extern int bitmap_resize(bitmap *bm, unsigned long size);
/**
* Create a bitmaptor of size 'size'
* @param size Desired storage capacity
* @return A bitmap pointer on success, NULL on errors
*/
extern bitmap *bitmap_create(unsigned long size);
/**
* Destroy a bitmaptor by freeing all the memory it uses
* @param bm The bitmaptor to destroy
*/
extern void bitmap_destroy(bitmap *bm);
/**
* Copy a bitmaptor
* @param bm The bitmaptor to copy
* @return Pointer to an identical bitmap on success, NULL on errors
*/
extern bitmap *bitmap_copy(const bitmap *bm);
/**
* Set a bit in the map
* @param bm The bitmaptor to operate on
* @param pos Position of the bit to set
* @return 0 on success, -1 on errors
*/
extern int bitmap_set(bitmap *bm, unsigned long pos);
/**
* Check if a particular bit is set in the map
* @param bm The bitmaptor to check
* @param pos Position of the bit to check
* @return 1 if set, otherwise 0
*/
extern int bitmap_isset(const bitmap *bm, unsigned long pos);
/**
* Unset a particular bit in the map
* @param bm The bitmaptor to operate on
* @param pos Position of the bit to unset
*/
extern int bitmap_unset(bitmap *bm, unsigned long pos);
/**
* Obtain cardinality (max number of elements) of the bitmaptor
* @param bm The bitmaptor to check
* @return The cardinality of the bitmaptor
*/
extern unsigned long bitmap_cardinality(const bitmap *bm);
#define bitmap_size bitmap_cardinality
/**
* Count set bits in map. Completed in O(n/8) time.
* @param bm The bitmaptor to count bits in
* @return The number of set bits
*/
extern unsigned long bitmap_count_set_bits(const bitmap *bm);
/**
* Count unset bits in map. Completed in O(n/8) time.
* @param bm The bitmaptor to count bits in
* @return The number of set bits
*/
extern unsigned long bitmap_count_unset_bits(const bitmap *bm);
/**
* Unset all bits in a bitmap
* @param bm The bitmap to clear
*/
extern void bitmap_clear(bitmap *bm);
/**
* Calculate intersection of two bitmaps
* The intersection is defined as all bits that are members of
* both A and B. It's equivalent to bitwise AND.
* This function completes in O(n/sizeof(long)) operations.
* @param a The first bitmaptor
* @param b The second bitmaptor
* @return NULL on errors; A newly created bitmaptor on success.
*/
extern bitmap *bitmap_intersect(const bitmap *a, const bitmap *b);
/**
* Calculate union of two bitmaps
* The union is defined as all bits that are members of
* A or B or both A and B. It's equivalent to bitwise OR.
* This function completes in O(n/sizeof(long)) operations.
* @param a The first bitmaptor
* @param b The second bitmaptor
* @return NULL on errors; A newly created bitmaptor on success.
*/
extern bitmap *bitmap_union(const bitmap *a, const bitmap *b);
/**
* Calculate union of two bitmaps and store result in one of them
* @param res The first bitmap
* @param addme The bitmap to unite to the first bitmap
* @return NULL on errors, res on success
*/
extern bitmap *bitmap_unite(bitmap *res, const bitmap *addme);
/**
* Calculate set difference between two bitmaps
* The set difference of A / B is defined as all members of A
* that isn't members of B. Note that parameter ordering matters
* for this function.
* This function completes in O(n/sizeof(long)) operations.
* @param a The first bitmaptor (numerator)
* @param b The first bitmaptor (denominator)
* @return NULL on errors; A newly created bitmaptor on success.
*/
extern bitmap *bitmap_diff(const bitmap *a, const bitmap *b);
/**
* Calculate symmetric difference between two bitmaps
* The symmetric difference between A and B is the set that
* contains all elements in either set but not in both.
* This function completes in O(n/sizeof(long)) operations.
* @param a The first bitmaptor
* @param b The second bitmaptor
*/
extern bitmap *bitmap_symdiff(const bitmap *a, const bitmap *b);
/**
* Compare two bitmaps for equality
* @param a The first bitmaptor
* @param b The other bitmaptor
* @return Similar to memcmp(), with tiebreaks determined by cardinality
*/
extern int bitmap_cmp(const bitmap *a, const bitmap *b);
/** @} */
#endif /* LIBNAGIOS_bitmap_h__ */

213
nagios4/broker.h Normal file
View File

@@ -0,0 +1,213 @@
/*****************************************************************************
*
* BROKER.H - Event broker includes for Nagios
*
*
* 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.
*
*****************************************************************************/
#ifndef _BROKER_H
#define _BROKER_H
#include "nagios.h"
/*************** EVENT BROKER OPTIONS *****************/
#define BROKER_NOTHING 0
#define BROKER_EVERYTHING 1048575
#define BROKER_PROGRAM_STATE 1 /* DONE */
#define BROKER_TIMED_EVENTS 2 /* DONE */
#define BROKER_SERVICE_CHECKS 4 /* DONE */
#define BROKER_HOST_CHECKS 8 /* DONE */
#define BROKER_EVENT_HANDLERS 16 /* DONE */
#define BROKER_LOGGED_DATA 32 /* DONE */
#define BROKER_NOTIFICATIONS 64 /* DONE */
#define BROKER_FLAPPING_DATA 128 /* DONE */
#define BROKER_COMMENT_DATA 256 /* DONE */
#define BROKER_DOWNTIME_DATA 512 /* DONE */
#define BROKER_SYSTEM_COMMANDS 1024 /* DONE */
#define BROKER_OCP_DATA_UNUSED 2048 /* reusable */
#define BROKER_STATUS_DATA 4096 /* DONE */
#define BROKER_ADAPTIVE_DATA 8192 /* DONE */
#define BROKER_EXTERNALCOMMAND_DATA 16384 /* DONE */
#define BROKER_RETENTION_DATA 32768 /* DONE */
#define BROKER_ACKNOWLEDGEMENT_DATA 65536
#define BROKER_STATECHANGE_DATA 131072
#define BROKER_RESERVED18 262144
#define BROKER_RESERVED19 524288
/****** EVENT TYPES ************************/
#define NEBTYPE_NONE 0
#define NEBTYPE_HELLO 1
#define NEBTYPE_GOODBYE 2
#define NEBTYPE_INFO 3
#define NEBTYPE_PROCESS_START 100
#define NEBTYPE_PROCESS_DAEMONIZE 101
#define NEBTYPE_PROCESS_RESTART 102
#define NEBTYPE_PROCESS_SHUTDOWN 103
#define NEBTYPE_PROCESS_PRELAUNCH 104 /* before objects are read or verified */
#define NEBTYPE_PROCESS_EVENTLOOPSTART 105
#define NEBTYPE_PROCESS_EVENTLOOPEND 106
#define NEBTYPE_TIMEDEVENT_ADD 200
#define NEBTYPE_TIMEDEVENT_REMOVE 201
#define NEBTYPE_TIMEDEVENT_EXECUTE 202
#define NEBTYPE_TIMEDEVENT_DELAY 203 /* NOT IMPLEMENTED */
#define NEBTYPE_TIMEDEVENT_SKIP 204 /* NOT IMPLEMENTED */
#define NEBTYPE_TIMEDEVENT_SLEEP 205
#define NEBTYPE_LOG_DATA 300
#define NEBTYPE_LOG_ROTATION 301
#define NEBTYPE_SYSTEM_COMMAND_START 400
#define NEBTYPE_SYSTEM_COMMAND_END 401
#define NEBTYPE_EVENTHANDLER_START 500
#define NEBTYPE_EVENTHANDLER_END 501
#define NEBTYPE_NOTIFICATION_START 600
#define NEBTYPE_NOTIFICATION_END 601
#define NEBTYPE_CONTACTNOTIFICATION_START 602
#define NEBTYPE_CONTACTNOTIFICATION_END 603
#define NEBTYPE_CONTACTNOTIFICATIONMETHOD_START 604
#define NEBTYPE_CONTACTNOTIFICATIONMETHOD_END 605
#define NEBTYPE_SERVICECHECK_INITIATE 700
#define NEBTYPE_SERVICECHECK_PROCESSED 701
#define NEBTYPE_SERVICECHECK_RAW_START 702 /* NOT IMPLEMENTED */
#define NEBTYPE_SERVICECHECK_RAW_END 703 /* NOT IMPLEMENTED */
#define NEBTYPE_SERVICECHECK_ASYNC_PRECHECK 704
#define NEBTYPE_HOSTCHECK_INITIATE 800 /* a check of the route to the host has been initiated */
#define NEBTYPE_HOSTCHECK_PROCESSED 801 /* the processed/final result of a host check */
#define NEBTYPE_HOSTCHECK_RAW_START 802 /* the start of a "raw" host check */
#define NEBTYPE_HOSTCHECK_RAW_END 803 /* a finished "raw" host check */
#define NEBTYPE_HOSTCHECK_ASYNC_PRECHECK 804
#define NEBTYPE_HOSTCHECK_SYNC_PRECHECK 805
#define NEBTYPE_COMMENT_ADD 900
#define NEBTYPE_COMMENT_DELETE 901
#define NEBTYPE_COMMENT_LOAD 902
#define NEBTYPE_FLAPPING_START 1000
#define NEBTYPE_FLAPPING_STOP 1001
#define NEBTYPE_DOWNTIME_ADD 1100
#define NEBTYPE_DOWNTIME_DELETE 1101
#define NEBTYPE_DOWNTIME_LOAD 1102
#define NEBTYPE_DOWNTIME_START 1103
#define NEBTYPE_DOWNTIME_STOP 1104
#define NEBTYPE_PROGRAMSTATUS_UPDATE 1200
#define NEBTYPE_HOSTSTATUS_UPDATE 1201
#define NEBTYPE_SERVICESTATUS_UPDATE 1202
#define NEBTYPE_CONTACTSTATUS_UPDATE 1203
#define NEBTYPE_ADAPTIVEPROGRAM_UPDATE 1300
#define NEBTYPE_ADAPTIVEHOST_UPDATE 1301
#define NEBTYPE_ADAPTIVESERVICE_UPDATE 1302
#define NEBTYPE_ADAPTIVECONTACT_UPDATE 1303
#define NEBTYPE_EXTERNALCOMMAND_START 1400
#define NEBTYPE_EXTERNALCOMMAND_END 1401
#define NEBTYPE_AGGREGATEDSTATUS_STARTDUMP 1500
#define NEBTYPE_AGGREGATEDSTATUS_ENDDUMP 1501
#define NEBTYPE_RETENTIONDATA_STARTLOAD 1600
#define NEBTYPE_RETENTIONDATA_ENDLOAD 1601
#define NEBTYPE_RETENTIONDATA_STARTSAVE 1602
#define NEBTYPE_RETENTIONDATA_ENDSAVE 1603
#define NEBTYPE_ACKNOWLEDGEMENT_ADD 1700
#define NEBTYPE_ACKNOWLEDGEMENT_REMOVE 1701 /* NOT IMPLEMENTED */
#define NEBTYPE_ACKNOWLEDGEMENT_LOAD 1702 /* NOT IMPLEMENTED */
#define NEBTYPE_STATECHANGE_START 1800 /* NOT IMPLEMENTED */
#define NEBTYPE_STATECHANGE_END 1801
/****** EVENT FLAGS ************************/
#define NEBFLAG_NONE 0
#define NEBFLAG_PROCESS_INITIATED 1 /* event was initiated by Nagios process */
#define NEBFLAG_USER_INITIATED 2 /* event was initiated by a user request */
#define NEBFLAG_MODULE_INITIATED 3 /* event was initiated by an event broker module */
/****** EVENT ATTRIBUTES *******************/
#define NEBATTR_NONE 0
#define NEBATTR_SHUTDOWN_NORMAL 1
#define NEBATTR_SHUTDOWN_ABNORMAL 2
#define NEBATTR_RESTART_NORMAL 4
#define NEBATTR_RESTART_ABNORMAL 8
#define NEBATTR_FLAPPING_STOP_NORMAL 1
#define NEBATTR_FLAPPING_STOP_DISABLED 2 /* flapping stopped because flap detection was disabled */
#define NEBATTR_DOWNTIME_STOP_NORMAL 1
#define NEBATTR_DOWNTIME_STOP_CANCELLED 2
/****** EVENT BROKER FUNCTIONS *************/
#ifdef USE_EVENT_BROKER
NAGIOS_BEGIN_DECL
struct timeval get_broker_timestamp(struct timeval *);
void broker_program_state(int, int, int, struct timeval *);
void broker_timed_event(int, int, int, timed_event *, struct timeval *);
void broker_log_data(int, int, int, char *, unsigned long, time_t, struct timeval *);
int broker_event_handler(int, int, int, int, void *, int, int, struct timeval, struct timeval, double, int, int, int, char *, char *, char *, struct timeval *);
void broker_system_command(int, int, int, struct timeval, struct timeval, double, int, int, int, char *, char *, struct timeval *);
int broker_host_check(int, int, int, host *, int, int, int, struct timeval, struct timeval, char *, double, double, int, int, int, char *, char *, char *, char *, struct timeval *, check_result *);
int broker_service_check(int, int, int, service *, int, struct timeval, struct timeval, char *, double, double, int, int, int, char *, struct timeval *, check_result *);
void broker_comment_data(int, int, int, int, int, char *, char *, time_t, char *, char *, int, int, int, time_t, unsigned long, struct timeval *);
void broker_downtime_data(int, int, int, int, char *, char *, time_t, char *, char *, time_t, time_t, int, unsigned long, unsigned long, unsigned long, struct timeval *);
void broker_flapping_data(int, int, int, int, void *, double, double, double, struct timeval *);
void broker_program_status(int, int, int, struct timeval *);
void broker_host_status(int, int, int, host *, struct timeval *);
void broker_service_status(int, int, int, service *, struct timeval *);
void broker_contact_status(int, int, int, contact *, struct timeval *);
int broker_notification_data(int, int, int, int, int, struct timeval, struct timeval, void *, char *, char *, int, int, struct timeval *);
int broker_contact_notification_data(int, int, int, int, int, struct timeval, struct timeval, void *, contact *, char *, char *, int, struct timeval *);
int broker_contact_notification_method_data(int, int, int, int, int, struct timeval, struct timeval, void *, contact *, char *, char *, char *, int, struct timeval *);
void broker_adaptive_program_data(int, int, int, int, unsigned long, unsigned long, unsigned long, unsigned long, struct timeval *);
void broker_adaptive_host_data(int, int, int, host *, int, unsigned long, unsigned long, struct timeval *);
void broker_adaptive_service_data(int, int, int, service *, int, unsigned long, unsigned long, struct timeval *);
void broker_adaptive_contact_data(int, int, int, contact *, int, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long, struct timeval *);
void broker_external_command(int, int, int, int, time_t, char *, char *, struct timeval *);
void broker_aggregated_status_data(int, int, int, struct timeval *);
void broker_retention_data(int, int, int, struct timeval *);
void broker_acknowledgement_data(int, int, int, int, void *, char *, char *, int, int, int, struct timeval *);
void broker_statechange_data(int, int, int, int, void *, int, int, int, int, struct timeval *);
NAGIOS_END_DECL
#endif
#endif

70
nagios4/cgiauth.h Normal file
View File

@@ -0,0 +1,70 @@
/*****************************************************************************
*
* CGIAUTH.H - Authorization utilities header file
*
*
* 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.
*
*****************************************************************************/
#ifndef _AUTH_H
#define _AUTH_H
#include "common.h"
#include "objects.h"
NAGIOS_BEGIN_DECL
typedef struct authdata_struct {
char *username;
int authorized_for_all_hosts;
int authorized_for_all_host_commands;
int authorized_for_all_services;
int authorized_for_all_service_commands;
int authorized_for_system_information;
int authorized_for_system_commands;
int authorized_for_configuration_information;
int authorized_for_read_only;
int authenticated;
} authdata;
int get_authentication_information(authdata *); /* gets current authentication information */
int is_authorized_for_host(host *, authdata *);
int is_authorized_for_service(service *, authdata *);
int is_authorized_for_all_hosts(authdata *);
int is_authorized_for_all_services(authdata *);
int is_authorized_for_system_information(authdata *);
int is_authorized_for_system_commands(authdata *);
int is_authorized_for_host_commands(host *, authdata *);
int is_authorized_for_service_commands(service *, authdata *);
int is_authorized_for_hostgroup(hostgroup *, authdata *);
int is_authorized_for_servicegroup(servicegroup *, authdata *);
int is_authorized_for_hostgroup_commands(hostgroup *, authdata *);
int is_authorized_for_servicegroup_commands(servicegroup *, authdata *);
int is_authorized_for_configuration_information(authdata *);
int is_authorized_for_read_only(authdata *);
NAGIOS_END_DECL
#endif

479
nagios4/cgiutils.h Normal file
View File

@@ -0,0 +1,479 @@
/************************************************************************
*
* CGIUTILS.H - Header file for common CGI functions
*
* 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.
************************************************************************/
#ifndef _CGIUTILS_H
#define _CGIUTILS_H
#include "lib/libnagios.h"
#include "logging.h"
#include "objects.h"
#include "cgiauth.h"
NAGIOS_BEGIN_DECL
/**************************** CGI REFRESH RATE ******************************/
#define DEFAULT_REFRESH_RATE 60 /* 60 second refresh rate for CGIs */
/******************************* CGI NAMES **********************************/
#define STATUS_CGI "status.cgi"
#define STATUSMAP_CGI "statusmap.cgi"
#define STATUSWORLD_CGI "statuswrl.cgi"
#define COMMAND_CGI "cmd.cgi"
#define EXTINFO_CGI "extinfo.cgi"
#define SHOWLOG_CGI "showlog.cgi"
#define NOTIFICATIONS_CGI "notifications.cgi"
#define HISTORY_CGI "history.cgi"
#define CONFIG_CGI "config.cgi"
#define OUTAGES_CGI "outages.cgi"
#define TRENDS_CGI "trends.cgi"
#define AVAIL_CGI "avail.cgi"
#define TAC_CGI "tac.cgi"
#define STATUSWML_CGI "statuswml.cgi"
#define TRACEROUTE_CGI "traceroute.cgi"
#define HISTOGRAM_CGI "histogram.cgi"
#define CHECKSANITY_CGI "checksanity.cgi"
#define MINISTATUS_CGI "ministatus.cgi"
#define SUMMARY_CGI "summary.cgi"
/**************************** STYLE SHEET NAMES ******************************/
#define COMMON_CSS "common.css"
#define SHOWLOG_CSS "showlog.css"
#define STATUS_CSS "status.css"
#define STATUSMAP_CSS "statusmap.css"
#define COMMAND_CSS "cmd.css"
#define EXTINFO_CSS "extinfo.css"
#define NOTIFICATIONS_CSS "notifications.css"
#define HISTORY_CSS "history.css"
#define CONFIG_CSS "config.css"
#define OUTAGES_CSS "outages.css"
#define TRENDS_CSS "trends.css"
#define AVAIL_CSS "avail.css"
#define TAC_CSS "tac.css"
#define HISTOGRAM_CSS "histogram.css"
#define CHECKSANITY_CSS "checksanity.css"
#define MINISTATUS_CSS "ministatus.css"
#define SUMMARY_CSS "summary.css"
/********************************* JAVASCRIPT INCLUDES **********************/
#define JQUERY_JS "jquery-1.7.1.min.js"
/********************************* ICONS ************************************/
#define STATUS_ICON_WIDTH 20
#define STATUS_ICON_HEIGHT 20
#define INFO_ICON "info.png"
#define INFO_ICON_ALT "Informational Message"
#define START_ICON "start.gif"
#define START_ICON_ALT "Program Start"
#define STOP_ICON "stop.gif"
#define STOP_ICON_ALT "Program End"
#define RESTART_ICON "restart.gif"
#define RESTART_ICON_ALT "Program Restart"
#define OK_ICON "recovery.png"
#define OK_ICON_ALT "Service Ok"
#define CRITICAL_ICON "critical.png"
#define CRITICAL_ICON_ALT "Service Critical"
#define WARNING_ICON "warning.png"
#define WARNING_ICON_ALT "Service Warning"
#define UNKNOWN_ICON "unknown.png"
#define UNKNOWN_ICON_ALT "Service Unknown"
#define NOTIFICATION_ICON "notify.gif"
#define NOTIFICATION_ICON_ALT "Service Notification"
#define LOG_ROTATION_ICON "logrotate.png"
#define LOG_ROTATION_ICON_ALT "Log Rotation"
#define EXTERNAL_COMMAND_ICON "command.png"
#define EXTERNAL_COMMAND_ICON_ALT "External Command"
#define STATUS_DETAIL_ICON "status2.gif"
#define STATUS_OVERVIEW_ICON "status.gif"
#define STATUSMAP_ICON "status3.gif"
#define STATUSWORLD_ICON "status4.gif"
#define EXTINFO_ICON "extinfo.gif"
#define HISTORY_ICON "history.gif"
#define CONTACTGROUP_ICON "contactgroup.gif"
#define TRENDS_ICON "trends.gif"
#define DISABLED_ICON "disabled.gif"
#define ENABLED_ICON "enabled.gif"
#define PASSIVE_ONLY_ICON "passiveonly.gif"
#define NOTIFICATIONS_DISABLED_ICON "ndisabled.gif"
#define ACKNOWLEDGEMENT_ICON "ack.gif"
#define REMOVE_ACKNOWLEDGEMENT_ICON "noack.gif"
#define COMMENT_ICON "comment.gif"
#define DELETE_ICON "delete.gif"
#define DELAY_ICON "delay.gif"
#define DOWNTIME_ICON "downtime.gif"
#define PASSIVE_ICON "passiveonly.gif"
#define RIGHT_ARROW_ICON "right.gif"
#define LEFT_ARROW_ICON "left.gif"
#define UP_ARROW_ICON "up.gif"
#define DOWN_ARROW_ICON "down.gif"
#define FLAPPING_ICON "flapping.gif"
#define SCHEDULED_DOWNTIME_ICON "downtime.gif"
#define EMPTY_ICON "empty.gif"
#define ACTIVE_ICON "active.gif"
#define ACTIVE_ICON_ALT "Active Mode"
#define STANDBY_ICON "standby.gif"
#define STANDBY_ICON_ALT "Standby Mode"
#define HOST_DOWN_ICON "critical.png"
#define HOST_DOWN_ICON_ALT "Host Down"
#define HOST_UNREACHABLE_ICON "critical.png"
#define HOST_UNREACHABLE_ICON_ALT "Host Unreachable"
#define HOST_UP_ICON "recovery.png"
#define HOST_UP_ICON_ALT "Host Up"
#define HOST_NOTIFICATION_ICON "notify.gif"
#define HOST_NOTIFICATION_ICON_ALT "Host Notification"
#define SERVICE_EVENT_ICON "serviceevent.gif"
#define SERVICE_EVENT_ICON_ALT "Service Event Handler"
#define HOST_EVENT_ICON "hostevent.gif"
#define HOST_EVENT_ICON_ALT "Host Event Handler"
#define THERM_OK_IMAGE "thermok.png"
#define THERM_WARNING_IMAGE "thermwarn.png"
#define THERM_CRITICAL_IMAGE "thermcrit.png"
#define CONFIGURATION_ICON "config.gif"
#define NOTES_ICON "notes.gif"
#define ACTION_ICON "action.gif"
#define DETAIL_ICON "detail.gif"
#define PARENT_TRAVERSAL_ICON "parentup.gif"
#define TAC_DISABLED_ICON "tacdisabled.png"
#define TAC_ENABLED_ICON "tacenabled.png"
#define ZOOM1_ICON "zoom1.gif"
#define ZOOM2_ICON "zoom2.gif"
#define CONTEXT_HELP_ICON1 "contexthelp1.gif"
#define CONTEXT_HELP_ICON2 "contexthelp2.gif"
#define SPLUNK_SMALL_WHITE_ICON "splunk1.gif"
#define SPLUNK_SMALL_BLACK_ICON "splunk2.gif"
#define FIRST_PAGE_ICON "b_first2.png"
#define LAST_PAGE_ICON "b_last2.png"
#define NEXT_PAGE_ICON "b_next2.png"
#define PREVIOUS_PAGE_ICON "b_prev2.png"
/********************* EXTENDED INFO CGI DISPLAY TYPES *********************/
#define DISPLAY_PROCESS_INFO 0
#define DISPLAY_HOST_INFO 1
#define DISPLAY_SERVICE_INFO 2
#define DISPLAY_COMMENTS 3
#define DISPLAY_PERFORMANCE 4
#define DISPLAY_HOSTGROUP_INFO 5
#define DISPLAY_DOWNTIME 6
#define DISPLAY_SCHEDULING_QUEUE 7
#define DISPLAY_SERVICEGROUP_INFO 8
/************************ COMMAND CGI COMMAND MODES *************************/
#define CMDMODE_NONE 0
#define CMDMODE_REQUEST 1
#define CMDMODE_COMMIT 2
/******************** HOST AND SERVICE NOTIFICATION TYPES ******************/
#define NOTIFICATION_ALL 0 /* all service and host notifications */
#define NOTIFICATION_SERVICE_ALL 1 /* all types of service notifications */
#define NOTIFICATION_HOST_ALL 2 /* all types of host notifications */
#define NOTIFICATION_SERVICE_WARNING 4
#define NOTIFICATION_SERVICE_UNKNOWN 8
#define NOTIFICATION_SERVICE_CRITICAL 16
#define NOTIFICATION_SERVICE_RECOVERY 32
#define NOTIFICATION_HOST_DOWN 64
#define NOTIFICATION_HOST_UNREACHABLE 128
#define NOTIFICATION_HOST_RECOVERY 256
#define NOTIFICATION_SERVICE_ACK 512
#define NOTIFICATION_HOST_ACK 1024
#define NOTIFICATION_SERVICE_FLAP 2048
#define NOTIFICATION_HOST_FLAP 4096
#define NOTIFICATION_SERVICE_CUSTOM 8192
#define NOTIFICATION_HOST_CUSTOM 16384
/********************** HOST AND SERVICE ALERT TYPES **********************/
#define HISTORY_ALL 0 /* all service and host alert */
#define HISTORY_SERVICE_ALL 1 /* all types of service alerts */
#define HISTORY_HOST_ALL 2 /* all types of host alerts */
#define HISTORY_SERVICE_WARNING 4
#define HISTORY_SERVICE_UNKNOWN 8
#define HISTORY_SERVICE_CRITICAL 16
#define HISTORY_SERVICE_RECOVERY 32
#define HISTORY_HOST_DOWN 64
#define HISTORY_HOST_UNREACHABLE 128
#define HISTORY_HOST_RECOVERY 256
/****************************** SORT TYPES *******************************/
#define SORT_NONE 0
#define SORT_ASCENDING 1
#define SORT_DESCENDING 2
/***************************** SORT OPTIONS ******************************/
#define SORT_NOTHING 0
#define SORT_HOSTNAME 1
#define SORT_SERVICENAME 2
#define SORT_SERVICESTATUS 3
#define SORT_LASTCHECKTIME 4
#define SORT_CURRENTATTEMPT 5
#define SORT_STATEDURATION 6
#define SORT_NEXTCHECKTIME 7
#define SORT_HOSTSTATUS 8
#define SORT_HOSTURGENCY 9
/****************** HOST AND SERVICE FILTER PROPERTIES *******************/
#define HOST_SCHEDULED_DOWNTIME 1
#define HOST_NO_SCHEDULED_DOWNTIME 2
#define HOST_STATE_ACKNOWLEDGED 4
#define HOST_STATE_UNACKNOWLEDGED 8
#define HOST_CHECKS_DISABLED 16
#define HOST_CHECKS_ENABLED 32
#define HOST_EVENT_HANDLER_DISABLED 64
#define HOST_EVENT_HANDLER_ENABLED 128
#define HOST_FLAP_DETECTION_DISABLED 256
#define HOST_FLAP_DETECTION_ENABLED 512
#define HOST_IS_FLAPPING 1024
#define HOST_IS_NOT_FLAPPING 2048
#define HOST_NOTIFICATIONS_DISABLED 4096
#define HOST_NOTIFICATIONS_ENABLED 8192
#define HOST_PASSIVE_CHECKS_DISABLED 16384
#define HOST_PASSIVE_CHECKS_ENABLED 32768
#define HOST_PASSIVE_CHECK 65536
#define HOST_ACTIVE_CHECK 131072
#define HOST_HARD_STATE 262144
#define HOST_SOFT_STATE 524288
#define SERVICE_SCHEDULED_DOWNTIME 1
#define SERVICE_NO_SCHEDULED_DOWNTIME 2
#define SERVICE_STATE_ACKNOWLEDGED 4
#define SERVICE_STATE_UNACKNOWLEDGED 8
#define SERVICE_CHECKS_DISABLED 16
#define SERVICE_CHECKS_ENABLED 32
#define SERVICE_EVENT_HANDLER_DISABLED 64
#define SERVICE_EVENT_HANDLER_ENABLED 128
#define SERVICE_FLAP_DETECTION_ENABLED 256
#define SERVICE_FLAP_DETECTION_DISABLED 512
#define SERVICE_IS_FLAPPING 1024
#define SERVICE_IS_NOT_FLAPPING 2048
#define SERVICE_NOTIFICATIONS_DISABLED 4096
#define SERVICE_NOTIFICATIONS_ENABLED 8192
#define SERVICE_PASSIVE_CHECKS_DISABLED 16384
#define SERVICE_PASSIVE_CHECKS_ENABLED 32768
#define SERVICE_PASSIVE_CHECK 65536
#define SERVICE_ACTIVE_CHECK 131072
#define SERVICE_HARD_STATE 262144
#define SERVICE_SOFT_STATE 524288
/****************************** SSI TYPES ********************************/
#define SSI_HEADER 0
#define SSI_FOOTER 1
/************************ CONTEXT-SENSITIVE HELP *************************/
#define CONTEXTHELP_STATUS_DETAIL "A1"
#define CONTEXTHELP_STATUS_HGOVERVIEW "A2"
#define CONTEXTHELP_STATUS_HGSUMMARY "A3"
#define CONTEXTHELP_STATUS_HGGRID "A4"
#define CONTEXTHELP_STATUS_SVCPROBLEMS "A5"
#define CONTEXTHELP_STATUS_HOST_DETAIL "A6"
#define CONTEXTHELP_STATUS_HOSTPROBLEMS "A7"
#define CONTEXTHELP_STATUS_SGOVERVIEW "A8"
#define CONTEXTHELP_STATUS_SGSUMMARY "A9"
#define CONTEXTHELP_STATUS_SGGRID "A10"
#define CONTEXTHELP_TAC "B1"
#define CONTEXTHELP_MAP "C1"
#define CONTEXTHELP_LOG "D1"
#define CONTEXTHELP_HISTORY "E1"
#define CONTEXTHELP_NOTIFICATIONS "F1"
#define CONTEXTHELP_TRENDS_MENU1 "G1"
#define CONTEXTHELP_TRENDS_MENU2 "G2"
#define CONTEXTHELP_TRENDS_MENU3 "G3"
#define CONTEXTHELP_TRENDS_MENU4 "G4"
#define CONTEXTHELP_TRENDS_HOST "G5"
#define CONTEXTHELP_TRENDS_SERVICE "G6"
#define CONTEXTHELP_AVAIL_MENU1 "H1"
#define CONTEXTHELP_AVAIL_MENU2 "H2"
#define CONTEXTHELP_AVAIL_MENU3 "H3"
#define CONTEXTHELP_AVAIL_MENU4 "H4"
#define CONTEXTHELP_AVAIL_MENU5 "H5"
#define CONTEXTHELP_AVAIL_HOSTGROUP "H6"
#define CONTEXTHELP_AVAIL_HOST "H7"
#define CONTEXTHELP_AVAIL_SERVICE "H8"
#define CONTEXTHELP_AVAIL_SERVICEGROUP "H9"
#define CONTEXTHELP_EXT_HOST "I1"
#define CONTEXTHELP_EXT_SERVICE "I2"
#define CONTEXTHELP_EXT_HOSTGROUP "I3"
#define CONTEXTHELP_EXT_PROCESS "I4"
#define CONTEXTHELP_EXT_PERFORMANCE "I5"
#define CONTEXTHELP_EXT_COMMENTS "I6"
#define CONTEXTHELP_EXT_DOWNTIME "I7"
#define CONTEXTHELP_EXT_QUEUE "I8"
#define CONTEXTHELP_EXT_SERVICEGROUP "I9"
#define CONTEXTHELP_CMD_INPUT "J1"
#define CONTEXTHELP_CMD_COMMIT "J2"
#define CONTEXTHELP_OUTAGES "K1"
#define CONTEXTHELP_CONFIG_MENU "L1"
#define CONTEXTHELP_CONFIG_HOSTS "L2"
#define CONTEXTHELP_CONFIG_HOSTDEPENDENCIES "L3"
#define CONTEXTHELP_CONFIG_HOSTESCALATIONS "L4"
#define CONTEXTHELP_CONFIG_HOSTGROUPS "L5"
#define CONTEXTHELP_CONFIG_HOSTGROUPESCALATIONS "L6"
#define CONTEXTHELP_CONFIG_SERVICES "L7"
#define CONTEXTHELP_CONFIG_SERVICEDEPENDENCIES "L8"
#define CONTEXTHELP_CONFIG_SERVICEESCALATIONS "L9"
#define CONTEXTHELP_CONFIG_CONTACTS "L10"
#define CONTEXTHELP_CONFIG_CONTACTGROUPS "L11"
#define CONTEXTHELP_CONFIG_TIMEPERIODS "L12"
#define CONTEXTHELP_CONFIG_COMMANDS "L13"
#define CONTEXTHELP_CONFIG_HOSTEXTINFO "L14"
#define CONTEXTHELP_CONFIG_SERVICEEXTINFO "L15"
#define CONTEXTHELP_CONFIG_SERVICEGROUPS "L16"
#define CONTEXTHELP_HISTOGRAM_MENU1 "M1"
#define CONTEXTHELP_HISTOGRAM_MENU2 "M2"
#define CONTEXTHELP_HISTOGRAM_MENU3 "M3"
#define CONTEXTHELP_HISTOGRAM_MENU4 "M4"
#define CONTEXTHELP_HISTOGRAM_HOST "M5"
#define CONTEXTHELP_HISTOGRAM_SERVICE "M6"
#define CONTEXTHELP_SUMMARY_MENU "N1"
#define CONTEXTHELP_SUMMARY_RECENT_ALERTS "N2"
#define CONTEXTHELP_SUMMARY_ALERT_TOTALS "N3"
#define CONTEXTHELP_SUMMARY_HOSTGROUP_ALERT_TOTALS "N4"
#define CONTEXTHELP_SUMMARY_HOST_ALERT_TOTALS "N5"
#define CONTEXTHELP_SUMMARY_SERVICE_ALERT_TOTALS "N6"
#define CONTEXTHELP_SUMMARY_ALERT_PRODUCERS "N7"
#define CONTEXTHELP_SUMMARY_SERVICEGROUP_ALERT_TOTALS "N8"
/************************** LIFO RETURN CODES ****************************/
#define LIFO_OK 0
#define LIFO_ERROR_MEMORY 1
#define LIFO_ERROR_FILE 2
#define LIFO_ERROR_DATA 3
/*************************** DATA STRUCTURES *****************************/
/* LIFO data structure */
typedef struct lifo_struct {
char *data;
struct lifo_struct *next;
} lifo;
/******************************** FUNCTIONS *******************************/
void reset_cgi_vars(void);
void cgi_init(void (*doc_header)(int), void (*doc_footer)(void), int object_options, int status_options);
void free_memory(void);
const char *get_cgi_config_location(void); /* gets location of the CGI config file to read */
const char *get_cmd_file_location(void); /* gets location of external command file to write to */
int read_cgi_config_file(const char *);
int read_main_config_file(const char *);
int read_all_object_configuration_data(const char *, int);
int read_all_status_data(const char *, int);
char *unescape_newlines(char *);
void sanitize_plugin_output(char *); /* strips HTML and bad characters from plugin output */
void strip_html_brackets(char *); /* strips > and < from string */
void get_time_string(time_t *, char *, int, int); /* gets a date/time string */
void get_interval_time_string(double, char *, int); /* gets a time string for an interval of time */
const char *url_encode(const char *); /* encodes a string in proper URL format */
char *html_encode(char *, int); /* encodes a string in HTML format (for what the user sees) */
char *escape_string(const char *); /* escape string for html form usage */
void get_log_archive_to_use(int, char *, int); /* determines the name of the log archive to use */
void determine_log_rotation_times(int);
int determine_archive_to_use_from_time(time_t);
void print_extra_hostgroup_url(char *, char *);
void print_extra_servicegroup_url(char *, char *);
void display_info_table(const char *, int, authdata *);
void display_nav_table(char *, int);
void display_splunk_host_url(host *);
void display_splunk_service_url(service *);
void display_splunk_generic_url(char *, int);
void strip_splunk_query_terms(char *);
void include_ssi_files(const char *, int); /* include user-defined SSI footers/headers */
void include_ssi_file(const char *); /* include user-defined SSI footer/header */
void cgi_config_file_error(const char *);
void main_config_file_error(const char *);
void object_data_error(void);
void status_data_error(void);
void display_context_help(const char *); /* displays context-sensitive help window */
int read_file_into_lifo(char *); /* LIFO functions */
void free_lifo_memory(void);
int push_lifo(char *);
char *pop_lifo(void);
NAGIOS_END_DECL
#endif

118
nagios4/comments.h Normal file
View File

@@ -0,0 +1,118 @@
/*****************************************************************************
*
* COMMENTS.H - Header file for comment functions
*
*
* 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.
*
*****************************************************************************/
#ifndef _COMMENTS_H
#define _COMMENTS_H
#include "common.h"
#include "objects.h"
/**************************** COMMENT SOURCES ******************************/
#define COMMENTSOURCE_INTERNAL 0
#define COMMENTSOURCE_EXTERNAL 1
/***************************** COMMENT TYPES *******************************/
#define HOST_COMMENT 1
#define SERVICE_COMMENT 2
/****************************** ENTRY TYPES ********************************/
#define USER_COMMENT 1
#define DOWNTIME_COMMENT 2
#define FLAPPING_COMMENT 3
#define ACKNOWLEDGEMENT_COMMENT 4
/*************************** CHAINED HASH LIMITS ***************************/
#define COMMENT_HASHSLOTS 1024
/**************************** DATA STRUCTURES ******************************/
NAGIOS_BEGIN_DECL
/* COMMENT structure */
typedef struct comment {
int comment_type;
int entry_type;
unsigned long comment_id;
int source;
int persistent;
time_t entry_time;
int expires;
time_t expire_time;
char *host_name;
char *service_description;
char *author;
char *comment_data;
struct comment *next;
struct comment *nexthash;
} comment;
extern struct comment *comment_list;
#ifndef NSCGI
int initialize_comment_data(void); /* initializes comment data */
int add_new_comment(int, int, char *, char *, time_t, char *, char *, int, int, int, time_t, unsigned long *); /* adds a new host or service comment */
int add_new_host_comment(int, char *, time_t, char *, char *, int, int, int, time_t, unsigned long *); /* adds a new host comment */
int add_new_service_comment(int, char *, char *, time_t, char *, char *, int, int, int, time_t, unsigned long *); /* adds a new service comment */
int delete_comment(int, unsigned long); /* deletes a host or service comment */
int delete_host_comment(unsigned long); /* deletes a host comment */
int delete_service_comment(unsigned long); /* deletes a service comment */
int delete_all_comments(int, char *, char *); /* deletes all comments for a particular host or service */
int delete_all_host_comments(char *); /* deletes all comments for a specific host */
int delete_host_acknowledgement_comments(struct host *); /* deletes all non-persistent ack comments for a specific host */
int delete_all_service_comments(char *, char *); /* deletes all comments for a specific service */
int delete_service_acknowledgement_comments(struct service *); /* deletes all non-persistent ack comments for a specific service */
int check_for_expired_comment(unsigned long); /* expires a comment */
#endif
struct comment *find_comment(unsigned long, int); /* finds a specific comment */
struct comment *find_service_comment(unsigned long); /* finds a specific service comment */
struct comment *find_host_comment(unsigned long); /* finds a specific host comment */
struct comment *get_first_comment_by_host(char *);
struct comment *get_next_comment_by_host(char *, struct comment *);
int number_of_host_comments(char *); /* returns the number of comments associated with a particular host */
int number_of_service_comments(char *, char *); /* returns the number of comments associated with a particular service */
int add_comment(int, int, char *, char *, time_t, char *, char *, unsigned long, int, int, time_t, int); /* adds a comment (host or service) */
int sort_comments(void);
int add_host_comment(int, char *, time_t, char *, char *, unsigned long, int, int, time_t, int); /* adds a host comment */
int add_service_comment(int, char *, char *, time_t, char *, char *, unsigned long, int, int, time_t, int); /* adds a service comment */
int add_comment_to_hashlist(struct comment *);
void free_comment_data(void); /* frees memory allocated to the comment list */
NAGIOS_BEGIN_DECL
#endif

531
nagios4/common.h Normal file
View File

@@ -0,0 +1,531 @@
/************************************************************************
*
* Nagios Common Header File
* Written By: Ethan Galstad (egalstad@nagios.org)
*
* 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.
************************************************************************/
#ifndef INCLUDE_COMMON_H
#define INCLUDE_COMMON_H
#include "shared.h"
#define PROGRAM_VERSION "4.0.2"
#define PROGRAM_MODIFICATION_DATE "11-25-2013"
NAGIOS_BEGIN_DECL
/*************************************************************/
/************** SHARED GLOBAL VARIABLES **********************/
/*************************************************************/
extern int date_format;
extern int interval_length;
extern char *illegal_output_chars;
extern char illegal_output_char_map[256];
extern int log_rotation_method;
extern int check_external_commands;
/* set this if you're going to add a ton of comments at once */
extern int defer_comment_sorting;
extern unsigned long next_downtime_id;
extern char *object_cache_file;
extern char *status_file;
extern time_t program_start;
extern int nagios_pid;
extern int daemon_mode;
extern time_t last_log_rotation;
extern int process_performance_data;
extern int enable_flap_detection;
extern int enable_notifications;
extern int execute_service_checks;
extern int accept_passive_service_checks;
extern int execute_host_checks;
extern int accept_passive_host_checks;
extern int enable_event_handlers;
extern int obsess_over_services;
extern int obsess_over_hosts;
extern int enable_timing_point;
extern char *config_file_dir;
#ifdef HAVE_TZNAME
#ifdef CYGWIN
extern char *_tzname[2] __declspec(dllimport);
#else
extern char *tzname[2];
#endif
#endif
NAGIOS_END_DECL
/* Experimental performance tweaks - use with caution */
#undef USE_MEMORY_PERFORMANCE_TWEAKS
/****************** OBJECT STATES ********************/
#define STATE_OK 0
#define STATE_WARNING 1
#define STATE_CRITICAL 2
#define STATE_UNKNOWN 3
#define STATE_UP 0
#define STATE_DOWN 1
#define STATE_UNREACHABLE 2
/* for legacy reasons */
#define HOST_UP STATE_UP
#define HOST_DOWN STATE_DOWN
#define HOST_UNREACHABLE STATE_UNREACHABLE
/***************************** COMMANDS *********************************/
#define CMD_NONE 0
#define CMD_ADD_HOST_COMMENT 1
#define CMD_DEL_HOST_COMMENT 2
#define CMD_ADD_SVC_COMMENT 3
#define CMD_DEL_SVC_COMMENT 4
#define CMD_ENABLE_SVC_CHECK 5
#define CMD_DISABLE_SVC_CHECK 6
#define CMD_SCHEDULE_SVC_CHECK 7
#define CMD_DELAY_SVC_NOTIFICATION 9
#define CMD_DELAY_HOST_NOTIFICATION 10
#define CMD_DISABLE_NOTIFICATIONS 11
#define CMD_ENABLE_NOTIFICATIONS 12
#define CMD_RESTART_PROCESS 13
#define CMD_SHUTDOWN_PROCESS 14
#define CMD_ENABLE_HOST_SVC_CHECKS 15
#define CMD_DISABLE_HOST_SVC_CHECKS 16
#define CMD_SCHEDULE_HOST_SVC_CHECKS 17
#define CMD_DELAY_HOST_SVC_NOTIFICATIONS 19 /* currently unimplemented */
#define CMD_DEL_ALL_HOST_COMMENTS 20
#define CMD_DEL_ALL_SVC_COMMENTS 21
#define CMD_ENABLE_SVC_NOTIFICATIONS 22
#define CMD_DISABLE_SVC_NOTIFICATIONS 23
#define CMD_ENABLE_HOST_NOTIFICATIONS 24
#define CMD_DISABLE_HOST_NOTIFICATIONS 25
#define CMD_ENABLE_ALL_NOTIFICATIONS_BEYOND_HOST 26
#define CMD_DISABLE_ALL_NOTIFICATIONS_BEYOND_HOST 27
#define CMD_ENABLE_HOST_SVC_NOTIFICATIONS 28
#define CMD_DISABLE_HOST_SVC_NOTIFICATIONS 29
#define CMD_PROCESS_SERVICE_CHECK_RESULT 30
#define CMD_SAVE_STATE_INFORMATION 31
#define CMD_READ_STATE_INFORMATION 32
#define CMD_ACKNOWLEDGE_HOST_PROBLEM 33
#define CMD_ACKNOWLEDGE_SVC_PROBLEM 34
#define CMD_START_EXECUTING_SVC_CHECKS 35
#define CMD_STOP_EXECUTING_SVC_CHECKS 36
#define CMD_START_ACCEPTING_PASSIVE_SVC_CHECKS 37
#define CMD_STOP_ACCEPTING_PASSIVE_SVC_CHECKS 38
#define CMD_ENABLE_PASSIVE_SVC_CHECKS 39
#define CMD_DISABLE_PASSIVE_SVC_CHECKS 40
#define CMD_ENABLE_EVENT_HANDLERS 41
#define CMD_DISABLE_EVENT_HANDLERS 42
#define CMD_ENABLE_HOST_EVENT_HANDLER 43
#define CMD_DISABLE_HOST_EVENT_HANDLER 44
#define CMD_ENABLE_SVC_EVENT_HANDLER 45
#define CMD_DISABLE_SVC_EVENT_HANDLER 46
#define CMD_ENABLE_HOST_CHECK 47
#define CMD_DISABLE_HOST_CHECK 48
#define CMD_START_OBSESSING_OVER_SVC_CHECKS 49
#define CMD_STOP_OBSESSING_OVER_SVC_CHECKS 50
#define CMD_REMOVE_HOST_ACKNOWLEDGEMENT 51
#define CMD_REMOVE_SVC_ACKNOWLEDGEMENT 52
#define CMD_SCHEDULE_FORCED_HOST_SVC_CHECKS 53
#define CMD_SCHEDULE_FORCED_SVC_CHECK 54
#define CMD_SCHEDULE_HOST_DOWNTIME 55
#define CMD_SCHEDULE_SVC_DOWNTIME 56
#define CMD_ENABLE_HOST_FLAP_DETECTION 57
#define CMD_DISABLE_HOST_FLAP_DETECTION 58
#define CMD_ENABLE_SVC_FLAP_DETECTION 59
#define CMD_DISABLE_SVC_FLAP_DETECTION 60
#define CMD_ENABLE_FLAP_DETECTION 61
#define CMD_DISABLE_FLAP_DETECTION 62
#define CMD_ENABLE_HOSTGROUP_SVC_NOTIFICATIONS 63
#define CMD_DISABLE_HOSTGROUP_SVC_NOTIFICATIONS 64
#define CMD_ENABLE_HOSTGROUP_HOST_NOTIFICATIONS 65
#define CMD_DISABLE_HOSTGROUP_HOST_NOTIFICATIONS 66
#define CMD_ENABLE_HOSTGROUP_SVC_CHECKS 67
#define CMD_DISABLE_HOSTGROUP_SVC_CHECKS 68
/* commands 69-77 are unimplemented */
#define CMD_UNIMPLEMENTED_69 69
#define CMD_UNIMPLEMENTED_70 70
#define CMD_UNIMPLEMENTED_71 71
#define CMD_UNIMPLEMENTED_72 72
#define CMD_UNIMPLEMENTED_73 73
#define CMD_UNIMPLEMENTED_74 74
#define CMD_UNIMPLEMENTED_75 75
#define CMD_UNIMPLEMENTED_76 76
#define CMD_UNIMPLEMENTED_77 77
#define CMD_DEL_HOST_DOWNTIME 78
#define CMD_DEL_SVC_DOWNTIME 79
#define CMD_ENABLE_PERFORMANCE_DATA 82
#define CMD_DISABLE_PERFORMANCE_DATA 83
#define CMD_SCHEDULE_HOSTGROUP_HOST_DOWNTIME 84
#define CMD_SCHEDULE_HOSTGROUP_SVC_DOWNTIME 85
#define CMD_SCHEDULE_HOST_SVC_DOWNTIME 86
/* new commands in Nagios 2.x found below... */
#define CMD_PROCESS_HOST_CHECK_RESULT 87
#define CMD_START_EXECUTING_HOST_CHECKS 88
#define CMD_STOP_EXECUTING_HOST_CHECKS 89
#define CMD_START_ACCEPTING_PASSIVE_HOST_CHECKS 90
#define CMD_STOP_ACCEPTING_PASSIVE_HOST_CHECKS 91
#define CMD_ENABLE_PASSIVE_HOST_CHECKS 92
#define CMD_DISABLE_PASSIVE_HOST_CHECKS 93
#define CMD_START_OBSESSING_OVER_HOST_CHECKS 94
#define CMD_STOP_OBSESSING_OVER_HOST_CHECKS 95
#define CMD_SCHEDULE_HOST_CHECK 96
#define CMD_SCHEDULE_FORCED_HOST_CHECK 98
#define CMD_START_OBSESSING_OVER_SVC 99
#define CMD_STOP_OBSESSING_OVER_SVC 100
#define CMD_START_OBSESSING_OVER_HOST 101
#define CMD_STOP_OBSESSING_OVER_HOST 102
#define CMD_ENABLE_HOSTGROUP_HOST_CHECKS 103
#define CMD_DISABLE_HOSTGROUP_HOST_CHECKS 104
#define CMD_ENABLE_HOSTGROUP_PASSIVE_SVC_CHECKS 105
#define CMD_DISABLE_HOSTGROUP_PASSIVE_SVC_CHECKS 106
#define CMD_ENABLE_HOSTGROUP_PASSIVE_HOST_CHECKS 107
#define CMD_DISABLE_HOSTGROUP_PASSIVE_HOST_CHECKS 108
#define CMD_ENABLE_SERVICEGROUP_SVC_NOTIFICATIONS 109
#define CMD_DISABLE_SERVICEGROUP_SVC_NOTIFICATIONS 110
#define CMD_ENABLE_SERVICEGROUP_HOST_NOTIFICATIONS 111
#define CMD_DISABLE_SERVICEGROUP_HOST_NOTIFICATIONS 112
#define CMD_ENABLE_SERVICEGROUP_SVC_CHECKS 113
#define CMD_DISABLE_SERVICEGROUP_SVC_CHECKS 114
#define CMD_ENABLE_SERVICEGROUP_HOST_CHECKS 115
#define CMD_DISABLE_SERVICEGROUP_HOST_CHECKS 116
#define CMD_ENABLE_SERVICEGROUP_PASSIVE_SVC_CHECKS 117
#define CMD_DISABLE_SERVICEGROUP_PASSIVE_SVC_CHECKS 118
#define CMD_ENABLE_SERVICEGROUP_PASSIVE_HOST_CHECKS 119
#define CMD_DISABLE_SERVICEGROUP_PASSIVE_HOST_CHECKS 120
#define CMD_SCHEDULE_SERVICEGROUP_HOST_DOWNTIME 121
#define CMD_SCHEDULE_SERVICEGROUP_SVC_DOWNTIME 122
#define CMD_CHANGE_GLOBAL_HOST_EVENT_HANDLER 123
#define CMD_CHANGE_GLOBAL_SVC_EVENT_HANDLER 124
#define CMD_CHANGE_HOST_EVENT_HANDLER 125
#define CMD_CHANGE_SVC_EVENT_HANDLER 126
#define CMD_CHANGE_HOST_CHECK_COMMAND 127
#define CMD_CHANGE_SVC_CHECK_COMMAND 128
#define CMD_CHANGE_NORMAL_HOST_CHECK_INTERVAL 129
#define CMD_CHANGE_NORMAL_SVC_CHECK_INTERVAL 130
#define CMD_CHANGE_RETRY_SVC_CHECK_INTERVAL 131
#define CMD_CHANGE_MAX_HOST_CHECK_ATTEMPTS 132
#define CMD_CHANGE_MAX_SVC_CHECK_ATTEMPTS 133
#define CMD_SCHEDULE_AND_PROPAGATE_TRIGGERED_HOST_DOWNTIME 134
#define CMD_ENABLE_HOST_AND_CHILD_NOTIFICATIONS 135
#define CMD_DISABLE_HOST_AND_CHILD_NOTIFICATIONS 136
#define CMD_SCHEDULE_AND_PROPAGATE_HOST_DOWNTIME 137
#define CMD_ENABLE_SERVICE_FRESHNESS_CHECKS 138
#define CMD_DISABLE_SERVICE_FRESHNESS_CHECKS 139
#define CMD_ENABLE_HOST_FRESHNESS_CHECKS 140
#define CMD_DISABLE_HOST_FRESHNESS_CHECKS 141
#define CMD_SET_HOST_NOTIFICATION_NUMBER 142
#define CMD_SET_SVC_NOTIFICATION_NUMBER 143
/* new commands in Nagios 3.x found below... */
#define CMD_CHANGE_HOST_CHECK_TIMEPERIOD 144
#define CMD_CHANGE_SVC_CHECK_TIMEPERIOD 145
#define CMD_PROCESS_FILE 146
#define CMD_CHANGE_CUSTOM_HOST_VAR 147
#define CMD_CHANGE_CUSTOM_SVC_VAR 148
#define CMD_CHANGE_CUSTOM_CONTACT_VAR 149
#define CMD_ENABLE_CONTACT_HOST_NOTIFICATIONS 150
#define CMD_DISABLE_CONTACT_HOST_NOTIFICATIONS 151
#define CMD_ENABLE_CONTACT_SVC_NOTIFICATIONS 152
#define CMD_DISABLE_CONTACT_SVC_NOTIFICATIONS 153
#define CMD_ENABLE_CONTACTGROUP_HOST_NOTIFICATIONS 154
#define CMD_DISABLE_CONTACTGROUP_HOST_NOTIFICATIONS 155
#define CMD_ENABLE_CONTACTGROUP_SVC_NOTIFICATIONS 156
#define CMD_DISABLE_CONTACTGROUP_SVC_NOTIFICATIONS 157
#define CMD_CHANGE_RETRY_HOST_CHECK_INTERVAL 158
#define CMD_SEND_CUSTOM_HOST_NOTIFICATION 159
#define CMD_SEND_CUSTOM_SVC_NOTIFICATION 160
#define CMD_CHANGE_HOST_NOTIFICATION_TIMEPERIOD 161
#define CMD_CHANGE_SVC_NOTIFICATION_TIMEPERIOD 162
#define CMD_CHANGE_CONTACT_HOST_NOTIFICATION_TIMEPERIOD 163
#define CMD_CHANGE_CONTACT_SVC_NOTIFICATION_TIMEPERIOD 164
#define CMD_CHANGE_HOST_MODATTR 165
#define CMD_CHANGE_SVC_MODATTR 166
#define CMD_CHANGE_CONTACT_MODATTR 167
#define CMD_CHANGE_CONTACT_MODHATTR 168
#define CMD_CHANGE_CONTACT_MODSATTR 169
#define CMD_DEL_DOWNTIME_BY_HOST_NAME 170
#define CMD_DEL_DOWNTIME_BY_HOSTGROUP_NAME 171
#define CMD_DEL_DOWNTIME_BY_START_TIME_COMMENT 172
/* custom command introduced in Nagios 3.x */
#define CMD_CUSTOM_COMMAND 999
/**************************** COMMAND ERRORS *****************************/
#define CMD_ERROR_OK 0 /* No errors encountered */
#define CMD_ERROR_UNKNOWN_COMMAND 1 /* Unknown/unsupported command */
#define CMD_ERROR_MALFORMED_COMMAND 2 /* Command malformed/missing timestamp? */
#define CMD_ERROR_INTERNAL_ERROR 3 /* Internal error */
#define CMD_ERROR_FAILURE 4 /* Command routine failed */
extern const char *cmd_error_strerror(int error_code);
/**************************** CHECK TYPES ********************************/
#define CHECK_TYPE_ACTIVE 0
#define CHECK_TYPE_PASSIVE 1
#define CHECK_TYPE_PARENT 2 /* (active) check for the benefit of dependent objects */
#define CHECK_TYPE_FILE 3 /* from spool files (yuck) */
#define CHECK_TYPE_OTHER 4 /* for modules to use */
/************* LEGACY (deprecated) CHECK TYPES ***************************/
#define SERVICE_CHECK_ACTIVE CHECK_TYPE_ACTIVE
#define SERVICE_CHECK_PASSIVE CHECK_TYPE_PASSIVE
#define HOST_CHECK_ACTIVE CHECK_TYPE_ACTIVE
#define HOST_CHECK_PASSIVE CHECK_TYPE_PASSIVE
/************************ SERVICE STATE TYPES ****************************/
#define SOFT_STATE 0
#define HARD_STATE 1
/************************* SCHEDULED DOWNTIME TYPES **********************/
#define SERVICE_DOWNTIME 1 /* service downtime */
#define HOST_DOWNTIME 2 /* host downtime */
#define ANY_DOWNTIME 3 /* host or service downtime */
/************************** NOTIFICATION OPTIONS *************************/
#define NOTIFICATION_OPTION_NONE 0
#define NOTIFICATION_OPTION_BROADCAST 1
#define NOTIFICATION_OPTION_FORCED 2
#define NOTIFICATION_OPTION_INCREMENT 4
/************************** ACKNOWLEDGEMENT TYPES ************************/
#define HOST_ACKNOWLEDGEMENT 0
#define SERVICE_ACKNOWLEDGEMENT 1
#define ACKNOWLEDGEMENT_NONE 0
#define ACKNOWLEDGEMENT_NORMAL 1
#define ACKNOWLEDGEMENT_STICKY 2
/**************************** DEPENDENCY TYPES ***************************/
#define NOTIFICATION_DEPENDENCY 1
#define EXECUTION_DEPENDENCY 2
/********************** HOST/SERVICE CHECK OPTIONS ***********************/
#define CHECK_OPTION_NONE 0 /* no check options */
#define CHECK_OPTION_FORCE_EXECUTION 1 /* force execution of a check (ignores disabled services/hosts, invalid timeperiods) */
#define CHECK_OPTION_FRESHNESS_CHECK 2 /* this is a freshness check */
#define CHECK_OPTION_ORPHAN_CHECK 4 /* this is an orphan check */
#define CHECK_OPTION_DEPENDENCY_CHECK 8 /* dependency check. different scheduling rules apply */
/**************************** PROGRAM MODES ******************************/
#define STANDBY_MODE 0
#define ACTIVE_MODE 1
/************************** LOG ROTATION MODES ***************************/
#define LOG_ROTATION_NONE 0
#define LOG_ROTATION_HOURLY 1
#define LOG_ROTATION_DAILY 2
#define LOG_ROTATION_WEEKLY 3
#define LOG_ROTATION_MONTHLY 4
/***************************** LOG VERSIONS ******************************/
#define LOG_VERSION_1 "1.0"
#define LOG_VERSION_2 "2.0"
/*************************** CHECK STATISTICS ****************************/
#define ACTIVE_SCHEDULED_SERVICE_CHECK_STATS 0
#define ACTIVE_ONDEMAND_SERVICE_CHECK_STATS 1
#define PASSIVE_SERVICE_CHECK_STATS 2
#define ACTIVE_SCHEDULED_HOST_CHECK_STATS 3
#define ACTIVE_ONDEMAND_HOST_CHECK_STATS 4
#define PASSIVE_HOST_CHECK_STATS 5
#define ACTIVE_CACHED_HOST_CHECK_STATS 6
#define ACTIVE_CACHED_SERVICE_CHECK_STATS 7
#define EXTERNAL_COMMAND_STATS 8
#define PARALLEL_HOST_CHECK_STATS 9
#define SERIAL_HOST_CHECK_STATS 10
#define MAX_CHECK_STATS_TYPES 11
/****************** HOST CONFIG FILE READING OPTIONS ********************/
#define READ_HOSTS 1
#define READ_HOSTGROUPS 2
#define READ_CONTACTS 4
#define READ_CONTACTGROUPS 8
#define READ_SERVICES 16
#define READ_COMMANDS 32
#define READ_TIMEPERIODS 64
#define READ_SERVICEESCALATIONS 128
#define READ_HOSTGROUPESCALATIONS 256 /* no longer implemented */
#define READ_SERVICEDEPENDENCIES 512
#define READ_HOSTDEPENDENCIES 1024
#define READ_HOSTESCALATIONS 2048
#define READ_HOSTEXTINFO 4096
#define READ_SERVICEEXTINFO 8192
#define READ_SERVICEGROUPS 16384
#define READ_ALL_OBJECT_DATA READ_HOSTS | READ_HOSTGROUPS | READ_CONTACTS | READ_CONTACTGROUPS | READ_SERVICES | READ_COMMANDS | READ_TIMEPERIODS | READ_SERVICEESCALATIONS | READ_SERVICEDEPENDENCIES | READ_HOSTDEPENDENCIES | READ_HOSTESCALATIONS | READ_HOSTEXTINFO | READ_SERVICEEXTINFO | READ_SERVICEGROUPS
/************************** DATE/TIME TYPES *****************************/
#define LONG_DATE_TIME 0
#define SHORT_DATE_TIME 1
#define SHORT_DATE 2
#define SHORT_TIME 3
#define HTTP_DATE_TIME 4 /* time formatted for use in HTTP headers */
/**************************** DATE FORMATS ******************************/
#define DATE_FORMAT_US 0 /* U.S. (MM-DD-YYYY HH:MM:SS) */
#define DATE_FORMAT_EURO 1 /* European (DD-MM-YYYY HH:MM:SS) */
#define DATE_FORMAT_ISO8601 2 /* ISO8601 (YYYY-MM-DD HH:MM:SS) */
#define DATE_FORMAT_STRICT_ISO8601 3 /* ISO8601 (YYYY-MM-DDTHH:MM:SS) */
/************************** MISC DEFINITIONS ****************************/
#define MAX_FILENAME_LENGTH 256 /* max length of path/filename that Nagios will process */
#define MAX_INPUT_BUFFER 1024 /* size in bytes of max. input buffer (for reading files, misc stuff) */
#define MAX_COMMAND_BUFFER 8192 /* max length of raw or processed command line */
#define MAX_EXTERNAL_COMMAND_LENGTH 8192 /* max length of an external command */
#define MAX_DATETIME_LENGTH 48
/************************* MODIFIED ATTRIBUTES **************************/
#define MODATTR_NONE 0
#define MODATTR_NOTIFICATIONS_ENABLED 1
#define MODATTR_ACTIVE_CHECKS_ENABLED 2
#define MODATTR_PASSIVE_CHECKS_ENABLED 4
#define MODATTR_EVENT_HANDLER_ENABLED 8
#define MODATTR_FLAP_DETECTION_ENABLED 16
#define MODATTR_FAILURE_PREDICTION_ENABLED 32
#define MODATTR_PERFORMANCE_DATA_ENABLED 64
#define MODATTR_OBSESSIVE_HANDLER_ENABLED 128
#define MODATTR_EVENT_HANDLER_COMMAND 256
#define MODATTR_CHECK_COMMAND 512
#define MODATTR_NORMAL_CHECK_INTERVAL 1024
#define MODATTR_RETRY_CHECK_INTERVAL 2048
#define MODATTR_MAX_CHECK_ATTEMPTS 4096
#define MODATTR_FRESHNESS_CHECKS_ENABLED 8192
#define MODATTR_CHECK_TIMEPERIOD 16384
#define MODATTR_CUSTOM_VARIABLE 32768
#define MODATTR_NOTIFICATION_TIMEPERIOD 65536
#endif /* INCLUDE_COMMON_H */

344
nagios4/config.h Normal file
View File

@@ -0,0 +1,344 @@
/* include/config.h. Generated from config.h.in by configure. */
/************************************************************************
*
* Nagios Config Header File
* Written By: Ethan Galstad (egalstad@nagios.org)
*
* 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.
************************************************************************/
/***** NAGIOS STUFF *****/
#define DEFAULT_NAGIOS_USER "nagios"
#define DEFAULT_NAGIOS_GROUP "nagios"
/* stop gcc from bitching about implicit asprintf declarations */
#define _GNU_SOURCE 1
/* Event broker integration */
#define USE_EVENT_BROKER /**/
/* commands used by CGIs */
#define TRACEROUTE_COMMAND "/usr/sbin/traceroute"
/* #undef PING_COMMAND */
/* #undef PING_PACKETS_FIRST */
/* Debugging options */
/* function entry and exit */
/* #undef DEBUG0 */
/* general info messages */
/* #undef DEBUG1 */
/* warning messages */
/* #undef DEBUG2 */
/* service and host checks, other events */
/* #undef DEBUG3 */
/* service and host notifications */
/* #undef DEBUG4 */
/* SQL queries (defunct) */
/* #undef DEBUG5 */
/* I/O implementations */
/* #undef USE_XSDDEFAULT */
/* #undef USE_XCDDEFAULT */
/* #undef USE_XRDDEFAULT */
/* #undef USE_XODTEMPLATE */
/* #undef USE_XPDDEFAULT */
/* #undef USE_XDDDEFAULT */
/***** CGI COMPILE OPTIONS *****/
/* should we compile and use the statusmap CGI? */
/* #undef USE_STATUSMAP */
/* should we compile and use the statuswrl CGI? */
#define USE_STATUSWRL /**/
/* should we compile and use the trends CGI? */
/* #undef USE_TRENDS */
/* should we compile and use the histogram CGI? */
/* #undef USE_HISTOGRAM */
/***** FUNCTION DEFINITIONS *****/
#define HAVE_SETENV 1
#define HAVE_UNSETENV 1
/* #undef HAVE_SOCKET */
#define HAVE_STRDUP 1
#define HAVE_STRSTR 1
#define HAVE_STRTOUL 1
#define HAVE_INITGROUPS 1
/* #undef HAVE_GETLOADAVG */
/* #undef HAVE_GDIMAGECREATETRUECOLOR */
/***** ASPRINTF() AND FRIENDS *****/
/* #undef HAVE_VSNPRINTF */
/* #undef HAVE_SNPRINTF */
/* #undef HAVE_ASPRINTF */
/* #undef HAVE_VASPRINTF */
#define HAVE_C99_VSNPRINTF 1
#define HAVE_VA_COPY 1
/* #undef HAVE___VA_COPY */
/***** MISC DEFINITIONS *****/
#define USE_NANOSLEEP /**/
#define STDC_HEADERS 1
#define HAVE_TM_ZONE 1
/* #undef HAVE_TZNAME */
/* #undef USE_PROC */
#define SOCKET_SIZE_TYPE size_t
#define GETGROUPS_T gid_t
#define RETSIGTYPE void
/***** HEADER FILES *****/
#include <stdio.h>
#include <stdlib.h>
/* needed for the time_t structures we use later... */
/* this include must come before sys/resource.h or we can have problems on some OSes */
#define TIME_WITH_SYS_TIME 1
#define HAVE_SYS_TIME_H 1
#if TIME_WITH_SYS_TIME
#include <sys/time.h>
#include <time.h>
#else
#if HAVE_SYS_TIME_H
#include <sys/time.h>
#else
#include <time.h>
#endif
#endif
#define HAVE_SYS_RESOURCE_H 1
#ifdef HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
#endif
#define HAVE_LIMITS_H 1
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#define HAVE_PWD_H 1
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#define HAVE_GRP_H 1
#ifdef HAVE_GRP_H
#include <grp.h>
#endif
#define HAVE_STRINGS_H 1
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif
#define HAVE_STRING_H 1
#ifdef HAVE_STRINGS_H
#include <string.h>
#endif
#define HAVE_UNISTD_H 1
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#define HAVE_SYSLOG_H 1
#ifdef HAVE_SYSLOG_H
#include <syslog.h>
#endif
#define HAVE_SIGNAL_H 1
#ifdef HAVE_SIGNAL_H
#include <signal.h>
#endif
#define HAVE_SYS_STAT_H 1
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#define HAVE_SYS_MMAN_H 1
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#define HAVE_FCNTL_H 1
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#define HAVE_STDARG_H 1
#ifdef HAVE_STDARG_H
#include <stdarg.h>
#endif
#define HAVE_SYS_TYPES_H 1
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#define HAVE_SYS_WAIT_H 1
#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#define HAVE_ERRNO_H 1
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#define HAVE_SYS_TIMEB_H 1
#if HAVE_SYS_TIMEB_H
#include <sys/timeb.h>
#endif
#define HAVE_SYS_IPC_H 1
#ifdef HAVE_SYS_IPC_H
#include <sys/ipc.h>
#endif
#define HAVE_SYS_MSG_H 1
#ifdef HAVE_SYS_MSG_H
#include <sys/msg.h>
#endif
#define HAVE_MATH_H 1
#ifdef HAVE_MATH_H
#include <math.h>
#endif
#define HAVE_CTYPE_H 1
#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif
#define HAVE_DIRENT_H 1
#ifdef HAVE_DIRENT_H
#include <dirent.h>
#endif
#define HAVE_REGEX_H 1
#ifdef HAVE_REGEX_H
#include <regex.h>
#define HAVE_SYS_SOCKET_H 1
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
/* #undef HAVE_SOCKET */
#ifdef HAVE_SOCKET_H
#include <socket.h>
#endif
#define HAVE_NETINET_IN_H 1
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#define HAVE_ARPA_INET_H 1
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#define HAVE_NETDB_H 1
#ifdef HAVE_NETDB_H
#include <netdb.h>
#endif
#define HAVE_LIBGEN_H 1
#ifdef HAVE_LIBGEN_H
#include <libgen.h>
#endif
#define HAVE_SYS_UN_H 1
#ifdef HAVE_SYS_UN_H
#include <sys/un.h>
#endif
#define HAVE_SYS_POLL_H 1
#ifdef HAVE_SYS_POLL_H
#include <sys/poll.h>
#endif
#define HAVE_GETOPT_H 1
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#endif
/* #undef HAVE_LINUX_MODULE_H */
#ifdef HAVE_LINUX_MODULE_H
#include <linux/module.h>
#endif
#define HAVE_LOCALE_H 1
#ifdef HAVE_LOCALE_H
#include <locale.h>
#endif
#define HAVE_WCHAR_H 1
#ifdef HAVE_WCHAR_H
#include <wchar.h>
#endif
/* configure script should allow user to override ltdl choice, but this will do for now... */
/* #undef USE_LTDL */
/* #undef HAVE_LTDL_H */
#ifdef HAVE_LTDL_H
#define USE_LTDL
#endif
#ifdef USE_LTDL
#include <ltdl.h>
#else
#define HAVE_DLFCN_H /**/
#ifdef HAVE_DLFCN_H
#include <dlfcn.h>
#endif
#endif
/* moved to end to prevent AIX compiler warnings */
#ifndef RTLD_GLOBAL
#define RTLD_GLOBAL 0
#endif
#ifndef RTLD_NOW
#define RTLD_NOW 0
#endif
/***** MARO DEFINITIONS *****/
/* this needs to come after all system include files, so we don't accidentally attempt to redefine it */
#ifndef WEXITSTATUS
# define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
#endif
#ifndef WIFEXITED
# define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
#endif
#endif

94
nagios4/defaults.h Normal file
View File

@@ -0,0 +1,94 @@
#ifndef INCLUDE_defaults_h__
#define INCLUDE_defaults_h__
/******************* DEFAULT VALUES *******************/
#define DEFAULT_LOG_LEVEL 1 /* log all events to main log file */
#define DEFAULT_USE_SYSLOG 1 /* log events to syslog? 1=yes, 0=no */
#define DEFAULT_SYSLOG_LEVEL 2 /* log only severe events to syslog */
#define DEFAULT_NOTIFICATION_LOGGING 1 /* log notification events? 1=yes, 0=no */
#define DEFAULT_INTER_CHECK_DELAY 5.0 /* seconds between initial service check scheduling */
#define DEFAULT_INTERLEAVE_FACTOR 1 /* default interleave to use when scheduling checks */
#define DEFAULT_RETRY_INTERVAL 30 /* services are retried in 30 seconds if they're not OK */
#define DEFAULT_CHECK_REAPER_INTERVAL 10 /* interval in seconds to reap host and service check results */
#define DEFAULT_MAX_REAPER_TIME 30 /* maximum number of seconds to spend reaping service checks before we break out for a while */
#define DEFAULT_MAX_CHECK_RESULT_AGE 3600 /* maximum number of seconds that a check result file is considered to be valid */
#define DEFAULT_MAX_PARALLEL_SERVICE_CHECKS 0 /* maximum number of service checks we can have running at any given time (0=unlimited) */
#define DEFAULT_RETENTION_UPDATE_INTERVAL 60 /* minutes between auto-save of retention data */
#define DEFAULT_RETENTION_SCHEDULING_HORIZON 900 /* max seconds between program restarts that we will preserve scheduling information */
#define DEFAULT_STATUS_UPDATE_INTERVAL 60 /* seconds between aggregated status data updates */
#define DEFAULT_FRESHNESS_CHECK_INTERVAL 60 /* seconds between service result freshness checks */
#define DEFAULT_AUTO_RESCHEDULING_INTERVAL 30 /* seconds between host and service check rescheduling events */
#define DEFAULT_AUTO_RESCHEDULING_WINDOW 180 /* window of time (in seconds) for which we should reschedule host and service checks */
#define DEFAULT_ORPHAN_CHECK_INTERVAL 60 /* seconds between checks for orphaned hosts and services */
#define DEFAULT_INTERVAL_LENGTH 60 /* seconds per interval unit for check scheduling */
#define DEFAULT_NOTIFICATION_TIMEOUT 30 /* max time in seconds to wait for notification commands to complete */
#define DEFAULT_EVENT_HANDLER_TIMEOUT 30 /* max time in seconds to wait for event handler commands to complete */
#define DEFAULT_HOST_CHECK_TIMEOUT 30 /* max time in seconds to wait for host check commands to complete */
#define DEFAULT_SERVICE_CHECK_TIMEOUT 60 /* max time in seconds to wait for service check commands to complete */
#define DEFAULT_OCSP_TIMEOUT 15 /* max time in seconds to wait for obsessive compulsive processing commands to complete */
#define DEFAULT_OCHP_TIMEOUT 15 /* max time in seconds to wait for obsessive compulsive processing commands to complete */
#define DEFAULT_PERFDATA_TIMEOUT 5 /* max time in seconds to wait for performance data commands to complete */
#define DEFAULT_TIME_CHANGE_THRESHOLD 900 /* compensate for time changes of more than 15 minutes */
#define DEFAULT_LOG_HOST_RETRIES 0 /* don't log host retries */
#define DEFAULT_LOG_SERVICE_RETRIES 0 /* don't log service retries */
#define DEFAULT_LOG_EVENT_HANDLERS 1 /* log event handlers */
#define DEFAULT_LOG_INITIAL_STATES 0 /* don't log initial service and host states */
#define DEFAULT_LOG_CURRENT_STATES 1 /* log current service and host states after rotating log */
#define DEFAULT_LOG_EXTERNAL_COMMANDS 1 /* log external commands */
#define DEFAULT_LOG_PASSIVE_CHECKS 1 /* log passive service checks */
#define DEFAULT_DEBUG_LEVEL 0 /* don't log any debugging information */
#define DEFAULT_DEBUG_VERBOSITY 1
#define DEFAULT_MAX_DEBUG_FILE_SIZE 1000000 /* max size of debug log */
#define DEFAULT_AGGRESSIVE_HOST_CHECKING 0 /* don't use "aggressive" host checking */
#define DEFAULT_CHECK_EXTERNAL_COMMANDS 1 /* check for external commands */
#define DEFAULT_CHECK_ORPHANED_SERVICES 1 /* check for orphaned services */
#define DEFAULT_CHECK_ORPHANED_HOSTS 1 /* check for orphaned hosts */
#define DEFAULT_ENABLE_FLAP_DETECTION 0 /* don't enable flap detection */
#define DEFAULT_PROCESS_PERFORMANCE_DATA 0 /* don't process performance data */
#define DEFAULT_CHECK_SERVICE_FRESHNESS 1 /* check service result freshness */
#define DEFAULT_CHECK_HOST_FRESHNESS 0 /* don't check host result freshness */
#define DEFAULT_AUTO_RESCHEDULE_CHECKS 0 /* don't auto-reschedule host and service checks */
#define DEFAULT_TRANSLATE_PASSIVE_HOST_CHECKS 0 /* should we translate DOWN/UNREACHABLE passive host checks? */
#define DEFAULT_PASSIVE_HOST_CHECKS_SOFT 0 /* passive host checks are treated as HARD by default */
#define DEFAULT_LOW_SERVICE_FLAP_THRESHOLD 20.0 /* low threshold for detection of service flapping */
#define DEFAULT_HIGH_SERVICE_FLAP_THRESHOLD 30.0 /* high threshold for detection of service flapping */
#define DEFAULT_LOW_HOST_FLAP_THRESHOLD 20.0 /* low threshold for detection of host flapping */
#define DEFAULT_HIGH_HOST_FLAP_THRESHOLD 30.0 /* high threshold for detection of host flapping */
#define DEFAULT_HOST_CHECK_SPREAD 30 /* max minutes to schedule all initial host checks */
#define DEFAULT_SERVICE_CHECK_SPREAD 30 /* max minutes to schedule all initial service checks */
#define DEFAULT_CACHED_HOST_CHECK_HORIZON 15 /* max age in seconds that cached host checks can be used */
#define DEFAULT_CACHED_SERVICE_CHECK_HORIZON 15 /* max age in seconds that cached service checks can be used */
#define DEFAULT_ENABLE_PREDICTIVE_HOST_DEPENDENCY_CHECKS 1 /* should we use predictive host dependency checks? */
#define DEFAULT_ENABLE_PREDICTIVE_SERVICE_DEPENDENCY_CHECKS 1 /* should we use predictive service dependency checks? */
#define DEFAULT_USE_LARGE_INSTALLATION_TWEAKS 0 /* don't use tweaks for large Nagios installations */
#define DEFAULT_ADDITIONAL_FRESHNESS_LATENCY 15 /* seconds to be added to freshness thresholds when automatically calculated by Nagios */
#define DEFAULT_CHECK_FOR_UPDATES 1 /* should we check for new Nagios releases? */
#define DEFAULT_BARE_UPDATE_CHECK 0 /* report current version and new installs */
#define MINIMUM_UPDATE_CHECK_INTERVAL 60*60*22 /* 22 hours minimum between checks - please be kind to our servers! */
#define BASE_UPDATE_CHECK_INTERVAL 60*60*22 /* 22 hours base interval */
#define UPDATE_CHECK_INTERVAL_WOBBLE 60*60*4 /* 4 hour wobble on top of base interval */
#define BASE_UPDATE_CHECK_RETRY_INTERVAL 60*60*1 /* 1 hour base retry interval */
#define UPDATE_CHECK_RETRY_INTERVAL_WOBBLE 60*60*3 /* 3 hour wobble on top of base retry interval */
#define DEFAULT_ALLOW_EMPTY_HOSTGROUP_ASSIGNMENT 2 /* Allow assigning to empty hostgroups by default, but warn about it */
#define DEFAULT_HOST_PERFDATA_FILE_TEMPLATE "[HOSTPERFDATA]\t$TIMET$\t$HOSTNAME$\t$HOSTEXECUTIONTIME$\t$HOSTOUTPUT$\t$HOSTPERFDATA$"
#define DEFAULT_SERVICE_PERFDATA_FILE_TEMPLATE "[SERVICEPERFDATA]\t$TIMET$\t$HOSTNAME$\t$SERVICEDESC$\t$SERVICEEXECUTIONTIME$\t$SERVICELATENCY$\t$SERVICEOUTPUT$\t$SERVICEPERFDATA$"
#define DEFAULT_HOST_PERFDATA_PROCESS_EMPTY_RESULTS 1
#define DEFAULT_SERVICE_PERFDATA_PROCESS_EMPTY_RESULTS 1
#endif /* INCLUDE_defaults_h__ */

134
nagios4/dkhash.h Normal file
View File

@@ -0,0 +1,134 @@
#ifndef LIBNAGIOS_dkhash_h__
#define LIBNAGIOS_dkhash_h__
#include <errno.h>
/**
* @file dkhash.h
* @brief Dual-key hash functions for Nagios
*
* Having a dual-key hash function is pretty unusual, but since so
* much data in Nagios pertains to services (which are uniquely
* identified based on both host_name and service_description), it
* makes sense here.
*
* @{
*/
/** return flags usable from the callback function of dkhash_walk_data() */
#define DKHASH_WALK_REMOVE 1 /**< Remove the most recently visited object */
#define DKHASH_WALK_STOP 2 /**< Cause walking to stop */
/** return values for dkhash_insert() */
#define DKHASH_OK 0 /**< Success */
#define DKHASH_EDUPE (-EPERM) /**< duplicate insert attempted */
#define DKHASH_EPERM (-EPERM) /**< duplicate insert attempted */
#define DKHASH_EINVAL (-EINVAL) /**< Invalid parameters passed */
#define DKHASH_ENOMEM (-ENOMEM) /**< Memory allocation failed */
struct dkhash_table;
/** opaque type */
typedef struct dkhash_table dkhash_table;
/**
* Create a dual-keyed hash-table of the given size
* Note that it's generally useful to make the table 25-30% larger
* than the number of items you intend to store, and also note that
* the 'size' arguments gets rounded up to the nearest power of 2.
* @param size The desired size of the hash-table.
*/
extern dkhash_table *dkhash_create(unsigned int size);
/**
* Destroy a dual-keyed hash table
* @param t The table to destroy
* @return 0 on success, -1 on errors
*/
extern int dkhash_destroy(dkhash_table *t);
/**
* Fetch the data associated with a particular key
* @param t The table to get the data from
* @param k1 The first key
* @param k2 The second key
* @return The data on success, NULL on errors or if data isn't found
*/
extern void *dkhash_get(dkhash_table *t, const char *k1, const char *k2);
/**
* Insert a new entry into the hash table
* @param t The hash table
* @param k1 The first key
* @param k2 The second key (may be null)
* @param data The data to insert
* @return 0 on success, < 0 on errors
*/
extern int dkhash_insert(dkhash_table *t, const char *k1, const char *k2, void *data);
/**
* Remove data from the hash table
* Note that this does not free() the pointer to the data stored in the
* table. It just destroys containers for that data in the hash table.
* @param t The hash table
* @param k1 The first key
* @param k2 The second key
* @return The removed data on success, or NULL on errors
*/
extern void *dkhash_remove(dkhash_table *t, const char *k1, const char *k2);
/**
* Call a function once for each item in the hash-table
* The callback function can return DKHASH_WALK_{REMOVE,STOP} or any
* OR'ed combination thereof to control the walking procedure, and
* should return 0 on the normal case.
* @param t The hash table
* @param walker The callback function to send the data to
*/
extern void dkhash_walk_data(dkhash_table *t, int (*walker)(void *data));
/**
* Get number of collisions in hash table
* Many collisions is a sign of a too small hash table or
* poor hash-function.
* @param t The hash table to report on
* @return The total number of collisions (not duplicates) from inserts
*/
extern unsigned int dkhash_collisions(dkhash_table *t);
/**
* Get number of items in the hash table
* @param t The hash table
* @return Number of items currently in the hash-table
*/
extern unsigned int dkhash_num_entries(dkhash_table *t);
/**
* Get max number of items stored in the hash table
* @param t The hash table
* @return Max number of items stored in hash-table
*/
extern unsigned int dkhash_num_entries_max(dkhash_table *t);
/**
* Get number of entries added to hash table
* Note that some of them may have been removed.
* @param t The hash table
* @return The number of items added to the table
*/
extern unsigned int dkhash_num_entries_added(dkhash_table *t);
/**
* Get number of removed items from hash table
* @param t The hash table
* @return Number of items removed from hash table
*/
extern unsigned int dkhash_num_entries_removed(dkhash_table *t);
/**
* Get actual table size (in number of buckets)
* @param t The hash table
* @return Number of bucket-slots in hash table
*/
extern unsigned int dkhash_table_size(dkhash_table *t);
/** @} */
#endif /* LIBNAGIOS_dkhash_h__ */

112
nagios4/downtime.h Normal file
View File

@@ -0,0 +1,112 @@
/*****************************************************************************
*
* DOWNTIME.H - Header file for scheduled downtime functions
*
*
* 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.
*
*****************************************************************************/
#ifndef _DOWNTIME_H
#define _DOWNTIME_H
#include "common.h"
#include "objects.h"
#ifndef NSCGI
#include "nagios.h"
#endif
NAGIOS_BEGIN_DECL
/* SCHEDULED_DOWNTIME_ENTRY structure */
typedef struct scheduled_downtime {
int type;
char *host_name;
char *service_description;
time_t entry_time;
time_t start_time;
time_t flex_downtime_start; /* Time the flexible downtime started */
time_t end_time;
int fixed;
unsigned long triggered_by;
unsigned long duration;
unsigned long downtime_id;
int is_in_effect;
int start_notification_sent;
char *author;
char *comment;
#ifndef NSCGI
unsigned long comment_id;
int start_flex_downtime;
int incremented_pending_downtime;
#endif
struct scheduled_downtime *next;
#ifndef NSCGI
struct timed_event *start_event, *stop_event;
#endif
struct scheduled_downtime *prev;
} scheduled_downtime;
extern struct scheduled_downtime *scheduled_downtime_list;
int initialize_downtime_data(void); /* initializes scheduled downtime data */
int cleanup_downtime_data(void); /* cleans up scheduled downtime data */
#ifndef NSCGI
int add_new_downtime(int, char *, char *, time_t, char *, char *, time_t, time_t, int, unsigned long, unsigned long, unsigned long *, int, int);
int add_new_host_downtime(char *, time_t, char *, char *, time_t, time_t, int, unsigned long, unsigned long, unsigned long *, int, int);
int add_new_service_downtime(char *, char *, time_t, char *, char *, time_t, time_t, int, unsigned long, unsigned long, unsigned long *, int, int);
int delete_host_downtime(unsigned long);
int delete_service_downtime(unsigned long);
int delete_downtime(int, unsigned long);
int schedule_downtime(int, char *, char *, time_t, char *, char *, time_t, time_t, int, unsigned long, unsigned long, unsigned long *);
int unschedule_downtime(int, unsigned long);
int register_downtime(int, unsigned long);
int handle_scheduled_downtime(struct scheduled_downtime *);
int handle_scheduled_downtime_by_id(unsigned long);
int check_pending_flex_host_downtime(struct host *);
int check_pending_flex_service_downtime(struct service *);
int check_for_expired_downtime(void);
#endif
int add_host_downtime(char *, time_t, char *, char *, time_t, time_t, time_t, int, unsigned long, unsigned long, unsigned long, int, int);
int add_service_downtime(char *, char *, time_t, char *, char *, time_t, time_t, time_t, int, unsigned long, unsigned long, unsigned long, int, int);
/* If you are going to be adding a lot of downtime in sequence, set
defer_downtime_sorting to 1 before you start and then call
sort_downtime afterwards. Things will go MUCH faster. */
extern int defer_downtime_sorting;
int add_downtime(int, char *, char *, time_t, char *, char *, time_t, time_t, time_t, int, unsigned long, unsigned long, unsigned long, int, int);
int sort_downtime(void);
struct scheduled_downtime *find_downtime(int, unsigned long);
struct scheduled_downtime *find_host_downtime(unsigned long);
struct scheduled_downtime *find_service_downtime(unsigned long);
void free_downtime_data(void); /* frees memory allocated to scheduled downtime list */
int delete_downtime_by_hostname_service_description_start_time_comment(char *, char *, time_t, char *);
NAGIOS_END_DECL
#endif

73
nagios4/fanout.h Normal file
View File

@@ -0,0 +1,73 @@
#ifndef LIBNAGIOS_fanout_h__
#define LIBNAGIOS_fanout_h__
#include "lnag-utils.h"
/**
* @file fanout.h
* @brief Simple fanout table implementation
*
* Fanouts are useful to hold short-lived integer-indexed data where
* the keyspan between smallest and largest key can be too large and
* change too often for it to be practical to maintain a growing array.
* If you think of it as a hash-table optimized for unsigned longs you've
* got the right idea.
*
* @{
*/
NAGIOS_BEGIN_DECL
/** Primary (opaque) type for this api */
typedef struct fanout_table fanout_table;
/**
* Create a fanout table
* @param[in] size The size of the table. Preferrably a power of 2
* @return Pointer to a newly created table
*/
extern fanout_table *fanout_create(unsigned long size);
/**
* Destroy a fanout table, with optional destructor.
* This function will iterate over all the entries in the fanout
* table and remove them, one by one. If 'destructor' is not NULL,
* it will be called on each and every object in the table. Note that
* 'free' is a valid destructor.
*
* @param[in] t The fanout table to destroy
* @param[in] destructor Function to call on data pointers in table
*/
extern void fanout_destroy(fanout_table *t, void (*destructor)(void *));
/**
* Return a pointer from the fanout table t
*
* @param[in] t table to fetch from
* @param[in] key key to fetch
* @return NULL on errors; Pointer to data on success
*/
extern void *fanout_get(fanout_table *t, unsigned long key);
/**
* Add an entry to the fanout table.
* Note that we don't check if the key is unique. If it isn't,
* fanout_remove() will remove the latest added first.
*
* @param[in] t fanout table to add to
* @param[in] key Key for this entry
* @param[in] data Data to add. Must not be NULL
* @return 0 on success, -1 on errors
*/
extern int fanout_add(fanout_table *t, unsigned long key, void *data);
/**
* Remove an entry from the fanout table and return its data.
*
* @param[in] t fanout table to look in
* @param[key] The key whose data we should locate
* @return Pointer to the data stored on success; NULL on errors
*/
extern void *fanout_remove(fanout_table *t, unsigned long key);
NAGIOS_END_DECL
/** @} */
#endif

175
nagios4/iobroker.h Normal file
View File

@@ -0,0 +1,175 @@
/* lib/iobroker.h. Generated from iobroker.h.in by configure. */
#ifndef LIBNAGIOS_iobroker_h__
#define LIBNAGIOS_iobroker_h__
/**
* @file iobroker.h
* @brief I/O broker library function declarations
*
* The I/O broker library handles multiplexing between hundreds or
* thousands of sockets with a few simple calls. It's designed to
* be as lightweight as possible so as to not cause memory bloat,
* and is therefore highly suitable for use by processes that are
* fork()-intensive.
*
* @{
*/
#define IOBROKER_USES_EPOLL 1
/* #undef IOBROKER_USES_POLL */
/* #undef IOBROKER_USES_SELECT */
#if (_POSIX_C_SOURCE - 0) >= 200112L
#include <poll.h>
# define IOBROKER_POLLIN POLLIN
# define IOBROKER_POLLPRI POLLPRI
# define IOBROKER_POLLOUT POLLOUT
# define IOBROKER_POLLERR POLLERR
# define IOBROKER_POLLHUP POLLHUP
# define IOBROKER_POLLNVAL POLLNVAL
#else
# define IOBROKER_POLLIN 0x001 /* there is data to read */
# define IOBROKER_POLLPRI 0x002 /* there is urgent data to read */
# define IOBROKER_POLLOUT 0x004 /* writing now will not block */
# define IOBROKER_POLLERR 0x008 /* error condition */
# define IOBROKER_POLLHUP 0x010 /* hung up */
# define IOBROKER_POLLNVAL 0x020 /* invalid polling request */
#endif
/** return codes */
#define IOBROKER_SUCCESS 0
#define IOBROKER_ENOSET (-1)
#define IOBROKER_ENOINIT (-2)
#define IOBROKER_ELIB (-3)
#define IOBROKER_EALREADY (-EALREADY)
#define IOBROKER_EINVAL (-EINVAL)
/** Flags for iobroker_destroy() */
#define IOBROKER_CLOSE_SOCKETS 1
/* Opaque type. Callers needn't worry about this */
struct iobroker_set;
typedef struct iobroker_set iobroker_set;
/**
* Get a string describing the error in the last iobroker call.
* The returned string must not be free()'d.
* @param error The error code
* @return A string describing the meaning of the error code
*/
extern const char *iobroker_strerror(int error);
/**
* Create a new socket set
* @return An iobroker_set on success. NULL on errors.
*/
extern iobroker_set *iobroker_create(void);
/**
* Published utility function used to determine the max number of
* file descriptors this process can keep open at any one time.
* @return Max number of filedescriptors we can keep open
*/
extern int iobroker_max_usable_fds(void);
/**
* Register a socket for input polling with the broker.
*
* @param iobs The socket set to add the socket to.
* @param sd The socket descriptor to add
* @param arg Argument passed to input handler on available input
* @param handler The callback function to call when input is available
*
* @return 0 on succes. < 0 on errors.
*/
extern int iobroker_register(iobroker_set *iobs, int sd, void *arg, int (*handler)(int, int, void *));
/**
* Register a socket for output polling with the broker
* @note There's no guarantee that *ALL* data is writable just
* because the socket won't block you completely.
*
* @param iobs The socket set to add the socket to.
* @param sd The socket descriptor to add
* @param arg Argument passed to output handler on ready-to-write
* @param handler The function to call when output won't block
*
* @return 0 on success. < 0 on errors
*/
extern int iobroker_register_out(iobroker_set *iobs, int sd, void *arg, int (*handler)(int, int, void *));
/**
* Check if a particular filedescriptor is registered with the iobroker set
* @param[in] iobs The iobroker set the filedescriptor should be member of
* @param[in] fd The filedescriptor to check for
* @return 1 if the filedescriptor is registered and 0 otherwise
*/
extern int iobroker_is_registered(iobroker_set *iobs, int fd);
/**
* Getter function for number of file descriptors registered in
* the set specified.
* @param iobs The io broker set to query
* @return Number of file descriptors registered in the set
*/
extern int iobroker_get_num_fds(iobroker_set *iobs);
/**
* Getter function for the maximum amount of file descriptors this
* set can handle.
* @param iobs The io broker set to query
* @return Max file descriptor capacity for the set
*/
extern int iobroker_get_max_fds(iobroker_set *iobs);
/**
* Unregister a socket for input polling with the broker.
*
* @param iobs The socket set to remove the socket from
* @param sd The socket descriptor to remove
* @return 0 on succes. < 0 on errors.
*/
extern int iobroker_unregister(iobroker_set *iobs, int sd);
/**
* Deregister a socket for input polling with the broker
* (this is identical to iobroker_unregister())
* @param iobs The socket set to remove the socket from
* @param sd The socket descriptor to remove
* @return 0 on success. < 0 on errors.
*/
extern int iobroker_deregister(iobroker_set *iobs, int sd);
/**
* Unregister and close(2) a socket registered for input with the
* broker. This is a convenience function which exists only to avoid
* doing multiple calls when read() returns 0, as closed sockets must
* always be removed from the socket set to avoid consuming tons of
* cpu power from iterating "too fast" over the file descriptors.
*
* @param iobs The socket set to remove the socket from
* @param sd The socket descriptor to remove and close
* @return 0 on success. < 0 on errors
*/
extern int iobroker_close(iobroker_set *iobs, int sd);
/**
* Destroy a socket set as created by iobroker_create
* @param iobs The socket set to destroy
* @param flags If set, close(2) all registered sockets
*/
extern void iobroker_destroy(iobroker_set *iobs, int flags);
/**
* Wait for input on any of the registered sockets.
* @param iobs The socket set to wait for.
* @param timeout Timeout in milliseconds. -1 is "wait indefinitely"
* @return -1 on errors, or number of filedescriptors with input
*/
extern int iobroker_poll(iobroker_set *iobs, int timeout);
#endif /* INCLUDE_iobroker_h__ */
/** @} */

181
nagios4/iocache.h Normal file
View File

@@ -0,0 +1,181 @@
#ifndef LIBNAGIOS_iocache_h__
#define LIBNAGIOS_iocache_h__
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
/**
* @file iocache.h
* @brief I/O cache function declarations
*
* The I/O cache library is useful for reading large chunks of data
* from sockets and utilizing parts of that data based on either
* size or a magic delimiter.
*
* @{
*/
/** opaque type for iocache operations */
struct iocache;
typedef struct iocache iocache;
/**
* Destroys an iocache object, freeing all memory allocated to it.
* @param ioc The iocache object to destroy
*/
extern void iocache_destroy(iocache *ioc);
/**
* Resets an iocache struct, discarding all data in it without free()'ing
* any memory.
*
* @param[in] ioc The iocache struct to reset
*/
extern void iocache_reset(iocache *ioc);
/**
* Resizes the buffer in an io cache
* @param ioc The io cache to resize
* @param new_size The new size of the io cache
* @return 0 on success, -1 on errors
*/
extern int iocache_resize(iocache *ioc, unsigned long new_size);
/**
* Grows an iocache object
* This uses iocache_resize() internally
* @param[in] ioc The iocache to grow
* @param[in] increment How much to increase it
* @return 0 on success, -1 on errors
*/
extern int iocache_grow(iocache *ioc, unsigned long increment);
/**
* Returns the total size of the io cache
* @param[in] ioc The iocache to inspect
* @return The size of the io cache. If ioc is null, 0 is returned
*/
extern unsigned long iocache_size(iocache *ioc);
/**
* Returns remaining read capacity of the io cache
* @param ioc The io cache to operate on
* @return The number of bytes available to read
*/
extern unsigned long iocache_capacity(iocache *ioc);
/**
* Return the amount of unread but stored data in the io cache
* @param ioc The io cache to operate on
* @return Number of bytes available to read
*/
extern unsigned long iocache_available(iocache *ioc);
/**
* Use a chunk of data from iocache based on size. The caller
* must take care not to write beyond the end of the requested
* buffer, or Bad Things(tm) will happen.
*
* @param ioc The io cache we should use data from
* @param size The size of the data we want returned
* @return NULL on errors (insufficient data, fe). pointer on success
*/
extern char *iocache_use_size(iocache *ioc, unsigned long size);
/**
* Use a chunk of data from iocache based on delimiter. The
* caller must take care not to write beyond the end of the
* requested buffer, if any is returned, or Bad Things(tm) will
* happen.
*
* @param ioc The io cache to use data from
* @param delim The delimiter
* @param delim_len Length of the delimiter
* @param size Length of the returned buffer
* @return NULL on errors (delimiter not found, insufficient data). pointer on success
*/
extern char *iocache_use_delim(iocache *ioc, const char *delim, size_t delim_len, unsigned long *size);
/**
* Forget that a specified number of bytes have been used.
* @param ioc The io cache that you want to un-use data in
* @param size The number of bytes you want to forget you've seen
* @return -1 if there was an error, 0 otherwise.
*/
extern int iocache_unuse_size(iocache *ioc, unsigned long size);
/**
* Creates the iocache object, initializing it with the given size
* @param size Initial size of the iocache buffer
* @return Pointer to a valid iocache object
*/
extern iocache *iocache_create(unsigned long size);
/**
* Read data into the iocache buffer
* @param ioc The io cache we should read into
* @param fd The filedescriptor we should read from
* @return The number of bytes read on success. < 0 on errors
*/
extern int iocache_read(iocache *ioc, int fd);
/**
* Add data to the iocache buffer
* The data is copied, so it can safely be taken from the stack in a
* function that returns before the data is used.
* If the io cache is too small to hold the data, -1 will be returned.
*
* @param[in] ioc The io cache to add to
* @param[in] buf Pointer to the data we should add
* @param[in] len Length (in bytes) of data pointed to by buf
* @return iocache_available(ioc) on success, -1 on errors
*/
extern int iocache_add(iocache *ioc, char *buf, unsigned int len);
/**
* Like sendto(), but sends all cached data prior to the requested
*
* @param[in] ioc The iocache to send, or cache data in
* @param[in] fd The file descriptor to send to
* @param[in] buf Pointer to the data to send
* @param[in] len Length (in bytes) of data to send
* @param[in] flags Flags passed to sendto(2)
* @param[in] dest_addr Destination address
* @param[in] addrlen size (in bytes) of dest_addr
* @return bytes sent on success, -ERRNO on errors
*/
extern int iocache_sendto(iocache *ioc, int fd, char *buf, unsigned int len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
/**
* Like send(2), but sends all cached data prior to the requested
* This function uses iocache_sendto() internally, but can only be
* used on connected sockets or open()'ed files.
*
* @param[in] ioc The iocache to send, or cache data in
* @param[in] fd The file descriptor to send to
* @param[in] buf Pointer to the data to send
* @param[in] len Length (in bytes) of data to send
* @param[in] flags Flags passed to sendto(2)
* @return bytes sent on success, -ERRNO on errors
*/
static inline int iocache_send(iocache *ioc, int fd, char *buf, unsigned int len, int flags)
{
return iocache_sendto(ioc, fd, buf, len, flags, NULL, 0);
}
/**
* Like write(2), but sends all cached data prior to the requested
* This function uses iocache_send() internally.
*
* @param[in] ioc The iocache to send, or cache data in
* @param[in] fd The file descriptor to send to
* @param[in] buf Pointer to the data to send
* @param[in] len Length (in bytes) of data to send
* @return bytes sent on success, -ERRNO on errors
*/
static inline int iocache_write(iocache *ioc, int fd, char *buf, unsigned int len)
{
return iocache_send(ioc, fd, buf, len, 0);
}
#endif /* INCLUDE_iocache_h__ */
/** @} */

207
nagios4/kvvec.h Normal file
View File

@@ -0,0 +1,207 @@
#ifndef LIBNAGIOS_kvvec_h__
#define LIBNAGIOS_kvvec_h__
/**
* @file kvvec.h
* @brief Key/value vector library function and type declarations
*
* The kvvec library is nifty as either a configuration meta-format
* or for IPC purposes. Take a look at the buf2kvvec() and kvvec2buf()
* pair of functions for the latter.
* @{
*/
/**
* key/value pair
* One of the two major components of the kvvec api
*/
struct key_value {
char *key; /**< The key */
char *value; /**< The value */
int key_len; /**< Length of key */
int value_len; /**< Length of value */
};
/**
* key/value vector buffer. Actually just a buffer, but one that gets
* used as return value and internal tracker for kvvec2buf()
*/
struct kvvec_buf {
char *buf; /**< The buffer */
unsigned long buflen; /**< Length of buffer */
unsigned long bufsize; /**< Size of buffer (includes overalloc) */
};
/**
* key/value vector struct
* This is the main component of the kvvec library
* @note This should be made opaque, with a kvvec_foreach() using a
* callback to iterate over key/value pairs.
*/
struct kvvec {
struct key_value *kv; /**< The key/value array */
int kv_alloc; /**< Allocated size of key/value array */
int kv_pairs; /**< Number of key/value pairs */
int kvv_sorted; /**< Determines if this kvvec has been sorted */
};
/** Portable initializer for stack-allocated key/value vectors */
#define KVVEC_INITIALIZER { NULL, 0, 0, 0 }
/** Parameters for kvvec_destroy() */
#define KVVEC_FREE_KEYS 1 /**< Free keys when destroying a kv vector */
#define KVVEC_FREE_VALUES 2 /**< Free values when destroying a kv vector */
/** Free both keys and values when destroying a kv vector */
#define KVVEC_FREE_ALL (KVVEC_FREE_KEYS | KVVEC_FREE_VALUES)
#define KVVEC_ASSIGN 0 /**< Assign from buf in buf2kvvec_prealloc() */
#define KVVEC_COPY 1 /**< Copy from buf in buf2kvvec_prealloc() */
#define KVVEC_APPEND 2 /**< Don't reset kvvec in buf2kvvec_prealloc() */
/**
* Initialize a previously allocated key/value vector
*
* @param kvv The key/value vector to initialize
* @param hint Number of key/value pairs we expect to store
* @return Pointer to a struct kvvec, properly initialized
*/
extern struct kvvec *kvvec_init(struct kvvec *kvv, int hint);
/**
* Create a key/value vector
*
* @param hint Number of key/value pairs we expect to store
* @return Pointer to a struct kvvec, properly initialized
*/
extern struct kvvec *kvvec_create(int hint);
/**
* Resize a key/value vector
* Used by kvvec_grow(). If size is smaller than the current number of
* used key/value slots, -1 is returned.
*
* @param[in] kvv The key/value vector to resize
* @param[in] size The size to grow to
* @return 0 on success, < 0 on errors
*/
extern int kvvec_resize(struct kvvec *kvv, int size);
/**
* Grow a key/value vector.
* Used internally as needed by the kvvec api. If 'hint' is zero, the
* key/value capacity is increased by a third of the current capacity
* plus a small constant number. This uses kvvec_resize() internally.
*
* @param kvv The key/value vector to grow
* @param hint The amount of key/value slots we should grow by
* @return 0 on success, < 0 on errors
*/
extern int kvvec_grow(struct kvvec *kvv, int hint);
/**
* Return remaining storage capacity of key/value vector
* @param[in] kvv The key/value vector to check
* @return Number of key/value pairs that can be stored without growing
*/
extern unsigned int kvvec_capacity(struct kvvec *kvv);
/**
* Sort a key/value vector alphabetically by key name
* @param kvv The key/value vector to sort
* @return 0
*/
extern int kvvec_sort(struct kvvec *kvv);
/**
* Add a key/value pair to an existing key/value vector, with
* lengths of strings already calculated
* @param kvv The key/value vector to add this key/value pair to
* @param key The key
* @param keylen Length of the key
* @param value The value
* @param valuelen Length of the value
* @return 0 on success, < 0 on errors
*/
extern int kvvec_addkv_wlen(struct kvvec *kvv, const char *key, int keylen, const char *value, int valuelen);
/**
* Shortcut to kvvec_addkv_wlen() when lengths aren't known
* @param kvv The key/value vector to add this key/value pair to
* @param key The key
* @param value The value
* @return 0 on success, < 0 on errors
*/
#define kvvec_addkv(kvv, key, value) kvvec_addkv_wlen(kvv, key, 0, value, 0)
/**
* Walk each key/value pair in a key/value vector, sending them
* as arguments to a callback function. The callback function has
* no control over the iteration process and must not delete or
* modify the key/value vector it's operating on.
* @param kvv The key/value vector to walk
* @param arg Extra argument to the callback function
* @param callback Callback function
* @return 0 on success, < 0 on errors
*/
extern int kvvec_foreach(struct kvvec *kvv, void *arg, int (*callback)(struct key_value *, void *));
/**
* Destroy a key/value vector
* @param kvv The key/value vector to destroy
* @param flags or'ed combination of KVVEC_FREE_{KEYS,VALUES}, or KVVEC_FREE_ALL
* @return 0 on success, < 0 on errors
*/
extern int kvvec_destroy(struct kvvec *kvv, int flags);
/**
* Free key/value pairs associated with a key/value vector
* @param kvv The key/value vector to operate on
* @param flags flags or'ed combination of KVVEC_FREE_{KEYS,VALUES}, or KVVEC_FREE_ALL
*/
void kvvec_free_kvpairs(struct kvvec *kvv, int flags);
/**
* Create a linear buffer of all the key/value pairs and
* return it as a kvvec_buf. The caller must free() all
* pointers in the returned kvvec_buf
* (FIXME: add kvvec_buf_destroy(), or move this and its counterpart
* out of the kvvec api into a separate one)
*
* @param kvv The key/value vector to convert
* @param kv_sep Character separating keys and their values
* @param pair_sep Character separating key/value pairs
* @param overalloc Integer determining how much extra data we should
* allocate. The overallocated memory is filled with
* nul bytes.
* @return A pointer to a newly created kvvec_buf structure
*/
extern struct kvvec_buf *kvvec2buf(struct kvvec *kvv, char kv_sep, char pair_sep, int overalloc);
/**
* Create a key/value vector from a pre-parsed buffer. Immensely
* useful for ipc in combination with kvvec2buf().
*
* @param str The buffer to convert to a key/value vector
* @param len Length of buffer to convert
* @param kvsep Character separating key and value
* @param pair_sep Character separating key/value pairs
* @param flags bitmask. See KVVEC_{ASSIGN,COPY,APPEND} for values
* @return The created key/value vector
*/
extern struct kvvec *buf2kvvec(char *str, unsigned int len, const char kvsep, const char pair_sep, int flags);
/**
* Parse a buffer into the pre-allocated key/value vector. Immensely
* useful for ipc in combination with kvvec2buf().
*
* @param kvv A pre-allocated key/value vector to populate
* @param str The buffer to convert to a key/value vector
* @param len Length of buffer to convert
* @param kvsep Character separating key and value
* @param pair_sep Character separating key/value pairs
* @param flags bitmask. See KVVEC_{ASSIGN,COPY,APPEND} for values
* @return The number of pairs in the created key/value vector
*/
extern int buf2kvvec_prealloc(struct kvvec *kvv, char *str, unsigned int len, const char kvsep, const char pair_sep, int flags);
/** @} */
#endif /* INCLUDE_kvvec_h__ */

25
nagios4/libnagios.h Normal file
View File

@@ -0,0 +1,25 @@
#ifndef LIBNAGIOS_libnagios_h__
#define LIBNAGIOS_libnagios_h__
/**
* @file libnagios.h
*
* @brief Include this for all public parts of libnagios to be accessible
*/
#include "lnag-utils.h"
#include "fanout.h"
#include "nsutils.h"
#include "pqueue.h"
#include "squeue.h"
#include "kvvec.h"
#include "iobroker.h"
#include "iocache.h"
#include "runcmd.h"
#include "bitmap.h"
#include "dkhash.h"
#include "worker.h"
#include "skiplist.h"
#include "nsock.h"
#include "nspath.h"
#include "snprintf.h"
#endif /* LIB_libnagios_h__ */

111
nagios4/lnag-utils.h Normal file
View File

@@ -0,0 +1,111 @@
#ifndef LIBNAGIOS_lnag_utils_h__
#define LIBNAGIOS_lnag_utils_h__
#include <unistd.h> /* for sysconf() */
#include <stdlib.h> /* for rand() */
/**
* @file lnag-utils.h
* @brief libnagios helper and compatibility macros that lack a "real" home.
*
* This is the home of random macros that must be present for compilation
* to succeed but are missing on some platforms.
*
* @{
*/
#define NAGIOS_MKVERSION(a, b, c) \
(((a) * 10000) + ((b) * 100) + (c))
#ifdef __cplusplus
/** C++ compatibility macro that avoids confusing indentation programs */
# define NAGIOS_BEGIN_DECL extern "C" {
/**
* Use at end of header file declarations to obtain C++ compatibility
* ... without confusing indentation programs
*/
# define NAGIOS_END_DECL }
#else
/** C++ compatibility macro that avoids confusing indentation programs */
# define NAGIOS_BEGIN_DECL /* nothing */
/** C++ compatibility macro that avoid confusing indentation programs */
# define NAGIOS_END_DECL /* more of nothing */
#endif
#ifndef NODOXY /* doxy comments are useless here */
# ifndef __GNUC__
# define GCC_VERSION 0
# define __attribute__(x) /* nothing */
# else
# ifdef __GNUC_PATCHLEVEL__
# define GCC_VERSION NAGIOS_MKVERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
# else
# define GCC_VERSION NAGIOS_MKVERSION(__GNUC__, __GNUC_MINOR__, 0)
# endif /* __GNUC_PATCHLEVEL__ */
# endif /* __GNUC__ */
#endif /* NODOXY */
#if GCC_VERSION >= NAGIOS_MKVERSION(4, 5, 0)
# define NAGIOS_DEPRECATED(version, hint) \
__attribute__((deprecated("This function will be removed in Nagios v" #version ". Please use " #hint " instead")))
#else
/** Macro for alerting module authors to function deprecation */
# define NAGIOS_DEPRECATED(version, hint) \
__attribute__((deprecated))
#endif
/*
* These macros are widely used throughout Nagios
*/
#define OK 0 /**< Indicates successful function call in Nagios */
#define ERROR -2 /**< Non-successful function call in Nagios */
#ifdef FALSE
#undef FALSE
#endif
#define FALSE 0 /**< Not true */
#ifdef TRUE
#undef TRUE
#endif
#define TRUE (!FALSE) /**< Not false */
/** Useful macro to safely avoid double-free memory corruption */
#define my_free(ptr) do { if(ptr) { free(ptr); ptr = NULL; } } while(0)
#ifndef ARRAY_SIZE
/** Useful for iterating over all elements in a static array */
# define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
#endif
#ifndef veclen
/** useful for iterating over all elements in a static array */
# define veclen ARRAY_SIZE
#endif
#ifndef offsetof
/** standard offsetof macro */
# define offsetof(t, f) ((unsigned long)&((t *)0)->f)
#endif
/** character map initialization for .bss-allocated char maps */
#define CHAR_MAP_INIT(k) { \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, k, \
}
/** @} */
#endif

41
nagios4/locations.h Normal file
View File

@@ -0,0 +1,41 @@
/************************************************************************
*
* Nagios Locations Header File
* Written By: Ethan Galstad (egalstad@nagios.org)
*
* 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.
************************************************************************/
#define DEFAULT_TEMP_FILE "/usr/local/nagios/var/tempfile"
#define DEFAULT_TEMP_PATH "/tmp"
#define DEFAULT_CHECK_RESULT_PATH "/usr/local/nagios/var/spool/checkresults"
#define DEFAULT_STATUS_FILE "/usr/local/nagios/var/status.dat"
#define DEFAULT_LOG_FILE "/usr/local/nagios/var/nagios.log"
#define DEFAULT_LOG_ARCHIVE_PATH "/usr/local/nagios/var/archives/"
#define DEFAULT_DEBUG_FILE "/usr/local/nagios/var/nagios.debug"
#define DEFAULT_COMMENT_FILE "/usr/local/nagios/var/comments.dat"
#define DEFAULT_DOWNTIME_FILE "/usr/local/nagios/var/downtime.dat"
#define DEFAULT_RETENTION_FILE "/usr/local/nagios/var/retention.dat"
#define DEFAULT_COMMAND_FILE "/usr/local/nagios/var/rw/nagios.cmd"
#define DEFAULT_QUERY_SOCKET "/usr/local/nagios/var/rw/nagios.qh"
#define DEFAULT_CONFIG_FILE "/usr/local/nagios/etc/nagios.cfg"
#define DEFAULT_PHYSICAL_HTML_PATH "/usr/local/nagios/share"
#define DEFAULT_URL_HTML_PATH "/nagios"
#define DEFAULT_PHYSICAL_CGIBIN_PATH "/usr/local/nagios/sbin"
#define DEFAULT_URL_CGIBIN_PATH "/nagios/cgi-bin"
#define DEFAULT_CGI_CONFIG_FILE "/usr/local/nagios/etc/cgi.cfg"
#define DEFAULT_LOCK_FILE "/usr/local/nagios/var/nagios.lock"
#define DEFAULT_OBJECT_CACHE_FILE "/usr/local/nagios/var/objects.cache"
#define DEFAULT_PRECACHED_OBJECT_FILE "/usr/local/nagios/var/objects.precache"
#define DEFAULT_EVENT_BROKER_FILE "/usr/local/nagios/var/broker.socket"

90
nagios4/logging.h Normal file
View File

@@ -0,0 +1,90 @@
#ifndef INCLUDE_logging_h__
#define INCLUDE_logging_h__
#include "objects.h"
/******************* LOGGING TYPES ********************/
#define NSLOG_RUNTIME_ERROR 1
#define NSLOG_RUNTIME_WARNING 2
#define NSLOG_VERIFICATION_ERROR 4
#define NSLOG_VERIFICATION_WARNING 8
#define NSLOG_CONFIG_ERROR 16
#define NSLOG_CONFIG_WARNING 32
#define NSLOG_PROCESS_INFO 64
#define NSLOG_EVENT_HANDLER 128
/*#define NSLOG_NOTIFICATION 256*/ /* NOT USED ANYMORE - CAN BE REUSED */
#define NSLOG_EXTERNAL_COMMAND 512
#define NSLOG_HOST_UP 1024
#define NSLOG_HOST_DOWN 2048
#define NSLOG_HOST_UNREACHABLE 4096
#define NSLOG_SERVICE_OK 8192
#define NSLOG_SERVICE_UNKNOWN 16384
#define NSLOG_SERVICE_WARNING 32768
#define NSLOG_SERVICE_CRITICAL 65536
#define NSLOG_PASSIVE_CHECK 131072
#define NSLOG_INFO_MESSAGE 262144
#define NSLOG_HOST_NOTIFICATION 524288
#define NSLOG_SERVICE_NOTIFICATION 1048576
/***************** DEBUGGING LEVELS *******************/
#define DEBUGL_ALL -1
#define DEBUGL_NONE 0
#define DEBUGL_FUNCTIONS 1
#define DEBUGL_CONFIG 2
#define DEBUGL_PROCESS 4
#define DEBUGL_STATUSDATA 4
#define DEBUGL_RETENTIONDATA 4
#define DEBUGL_EVENTS 8
#define DEBUGL_CHECKS 16
#define DEBUGL_FLAPPING 16
#define DEBUGL_EVENTHANDLERS 16
#define DEBUGL_PERFDATA 16
#define DEBUGL_NOTIFICATIONS 32
#define DEBUGL_EVENTBROKER 64
#define DEBUGL_EXTERNALCOMMANDS 128
#define DEBUGL_COMMANDS 256
#define DEBUGL_DOWNTIME 512
#define DEBUGL_COMMENTS 1024
#define DEBUGL_MACROS 2048
#define DEBUGL_IPC 4096
#define DEBUGL_SCHEDULING 8192
#define DEBUGV_BASIC 0
#define DEBUGV_MORE 1
#define DEBUGV_MOST 2
NAGIOS_BEGIN_DECL
/**** Logging Functions ****/
void logit(int, int, const char *, ...)
__attribute__((__format__(__printf__, 3, 4)));
int log_debug_info(int, int, const char *, ...)
__attribute__((__format__(__printf__, 3, 4)));
#ifndef NSCGI
int write_to_all_logs(char *, unsigned long); /* writes a string to main log file and syslog facility */
int write_to_log(char *, unsigned long, time_t *); /* write a string to the main log file */
int write_to_syslog(char *, unsigned long); /* write a string to the syslog facility */
int log_service_event(service *); /* logs a service event */
int log_host_event(host *); /* logs a host event */
int log_host_states(int, time_t *); /* logs initial/current host states */
int log_service_states(int, time_t *); /* logs initial/current service states */
int rotate_log_file(time_t); /* rotates the main log file */
int write_log_file_info(time_t *); /* records log file/version info */
int open_debug_log(void);
int close_debug_log(void);
int close_log_file(void);
int fix_log_file_owner(uid_t uid, gid_t gid);
#endif /* !NSCGI */
NAGIOS_END_DECL
#endif

339
nagios4/macros.h Normal file
View File

@@ -0,0 +1,339 @@
/************************************************************************
*
* MACROS.H - Common macro functions
* Written By: Ethan Galstad (egalstad@nagios.org)
*
* 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.
************************************************************************/
#ifndef _MACROS_H
#define _MACROS_H
#include "common.h"
#include "objects.h"
/****************** LENGTH LIMITATIONS ****************/
#define MAX_COMMAND_ARGUMENTS 32 /* maximum number of $ARGx$ macros */
/****************** MACRO DEFINITIONS *****************/
#define MACRO_ENV_VAR_PREFIX "NAGIOS_"
#define MAX_USER_MACROS 256 /* maximum number of $USERx$ macros */
#define MACRO_X_COUNT 156 /* size of macro_x[] array */
NAGIOS_BEGIN_DECL
struct nagios_macros {
char *x[MACRO_X_COUNT];
char *argv[MAX_COMMAND_ARGUMENTS];
char *contactaddress[MAX_CONTACT_ADDRESSES];
char *ondemand;
host *host_ptr;
hostgroup *hostgroup_ptr;
service *service_ptr;
servicegroup *servicegroup_ptr;
contact *contact_ptr;
contactgroup *contactgroup_ptr;
customvariablesmember *custom_host_vars;
customvariablesmember *custom_service_vars;
customvariablesmember *custom_contact_vars;
};
typedef struct nagios_macros nagios_macros;
#define MACRO_HOSTNAME 0
#define MACRO_HOSTALIAS 1
#define MACRO_HOSTADDRESS 2
#define MACRO_SERVICEDESC 3
#define MACRO_SERVICESTATE 4
#define MACRO_SERVICESTATEID 5
#define MACRO_SERVICEATTEMPT 6
#define MACRO_LONGDATETIME 7
#define MACRO_SHORTDATETIME 8
#define MACRO_DATE 9
#define MACRO_TIME 10
#define MACRO_TIMET 11
#define MACRO_LASTHOSTCHECK 12
#define MACRO_LASTSERVICECHECK 13
#define MACRO_LASTHOSTSTATECHANGE 14
#define MACRO_LASTSERVICESTATECHANGE 15
#define MACRO_HOSTOUTPUT 16
#define MACRO_SERVICEOUTPUT 17
#define MACRO_HOSTPERFDATA 18
#define MACRO_SERVICEPERFDATA 19
#define MACRO_CONTACTNAME 20
#define MACRO_CONTACTALIAS 21
#define MACRO_CONTACTEMAIL 22
#define MACRO_CONTACTPAGER 23
#define MACRO_ADMINEMAIL 24
#define MACRO_ADMINPAGER 25
#define MACRO_HOSTSTATE 26
#define MACRO_HOSTSTATEID 27
#define MACRO_HOSTATTEMPT 28
#define MACRO_NOTIFICATIONTYPE 29
#define MACRO_NOTIFICATIONNUMBER 30 /* deprecated - see HOSTNOTIFICATIONNUMBER and SERVICENOTIFICATIONNUMBER macros */
#define MACRO_HOSTEXECUTIONTIME 31
#define MACRO_SERVICEEXECUTIONTIME 32
#define MACRO_HOSTLATENCY 33
#define MACRO_SERVICELATENCY 34
#define MACRO_HOSTDURATION 35
#define MACRO_SERVICEDURATION 36
#define MACRO_HOSTDURATIONSEC 37
#define MACRO_SERVICEDURATIONSEC 38
#define MACRO_HOSTDOWNTIME 39
#define MACRO_SERVICEDOWNTIME 40
#define MACRO_HOSTSTATETYPE 41
#define MACRO_SERVICESTATETYPE 42
#define MACRO_HOSTPERCENTCHANGE 43
#define MACRO_SERVICEPERCENTCHANGE 44
#define MACRO_HOSTGROUPNAME 45
#define MACRO_HOSTGROUPALIAS 46
#define MACRO_SERVICEGROUPNAME 47
#define MACRO_SERVICEGROUPALIAS 48
#define MACRO_HOSTACKAUTHOR 49
#define MACRO_HOSTACKCOMMENT 50
#define MACRO_SERVICEACKAUTHOR 51
#define MACRO_SERVICEACKCOMMENT 52
#define MACRO_LASTSERVICEOK 53
#define MACRO_LASTSERVICEWARNING 54
#define MACRO_LASTSERVICEUNKNOWN 55
#define MACRO_LASTSERVICECRITICAL 56
#define MACRO_LASTHOSTUP 57
#define MACRO_LASTHOSTDOWN 58
#define MACRO_LASTHOSTUNREACHABLE 59
#define MACRO_SERVICECHECKCOMMAND 60
#define MACRO_HOSTCHECKCOMMAND 61
#define MACRO_MAINCONFIGFILE 62
#define MACRO_STATUSDATAFILE 63
#define MACRO_HOSTDISPLAYNAME 64
#define MACRO_SERVICEDISPLAYNAME 65
#define MACRO_RETENTIONDATAFILE 66
#define MACRO_OBJECTCACHEFILE 67
#define MACRO_TEMPFILE 68
#define MACRO_LOGFILE 69
#define MACRO_RESOURCEFILE 70
#define MACRO_COMMANDFILE 71
#define MACRO_HOSTPERFDATAFILE 72
#define MACRO_SERVICEPERFDATAFILE 73
#define MACRO_HOSTACTIONURL 74
#define MACRO_HOSTNOTESURL 75
#define MACRO_HOSTNOTES 76
#define MACRO_SERVICEACTIONURL 77
#define MACRO_SERVICENOTESURL 78
#define MACRO_SERVICENOTES 79
#define MACRO_TOTALHOSTSUP 80
#define MACRO_TOTALHOSTSDOWN 81
#define MACRO_TOTALHOSTSUNREACHABLE 82
#define MACRO_TOTALHOSTSDOWNUNHANDLED 83
#define MACRO_TOTALHOSTSUNREACHABLEUNHANDLED 84
#define MACRO_TOTALHOSTPROBLEMS 85
#define MACRO_TOTALHOSTPROBLEMSUNHANDLED 86
#define MACRO_TOTALSERVICESOK 87
#define MACRO_TOTALSERVICESWARNING 88
#define MACRO_TOTALSERVICESCRITICAL 89
#define MACRO_TOTALSERVICESUNKNOWN 90
#define MACRO_TOTALSERVICESWARNINGUNHANDLED 91
#define MACRO_TOTALSERVICESCRITICALUNHANDLED 92
#define MACRO_TOTALSERVICESUNKNOWNUNHANDLED 93
#define MACRO_TOTALSERVICEPROBLEMS 94
#define MACRO_TOTALSERVICEPROBLEMSUNHANDLED 95
#define MACRO_PROCESSSTARTTIME 96
#define MACRO_HOSTCHECKTYPE 97
#define MACRO_SERVICECHECKTYPE 98
#define MACRO_LONGHOSTOUTPUT 99
#define MACRO_LONGSERVICEOUTPUT 100
#define MACRO_TEMPPATH 101
#define MACRO_HOSTNOTIFICATIONNUMBER 102
#define MACRO_SERVICENOTIFICATIONNUMBER 103
#define MACRO_HOSTNOTIFICATIONID 104
#define MACRO_SERVICENOTIFICATIONID 105
#define MACRO_HOSTEVENTID 106
#define MACRO_LASTHOSTEVENTID 107
#define MACRO_SERVICEEVENTID 108
#define MACRO_LASTSERVICEEVENTID 109
#define MACRO_HOSTGROUPNAMES 110
#define MACRO_SERVICEGROUPNAMES 111
#define MACRO_HOSTACKAUTHORNAME 112
#define MACRO_HOSTACKAUTHORALIAS 113
#define MACRO_SERVICEACKAUTHORNAME 114
#define MACRO_SERVICEACKAUTHORALIAS 115
#define MACRO_MAXHOSTATTEMPTS 116
#define MACRO_MAXSERVICEATTEMPTS 117
#define MACRO_SERVICEISVOLATILE 118
#define MACRO_TOTALHOSTSERVICES 119
#define MACRO_TOTALHOSTSERVICESOK 120
#define MACRO_TOTALHOSTSERVICESWARNING 121
#define MACRO_TOTALHOSTSERVICESUNKNOWN 122
#define MACRO_TOTALHOSTSERVICESCRITICAL 123
#define MACRO_HOSTGROUPNOTES 124
#define MACRO_HOSTGROUPNOTESURL 125
#define MACRO_HOSTGROUPACTIONURL 126
#define MACRO_SERVICEGROUPNOTES 127
#define MACRO_SERVICEGROUPNOTESURL 128
#define MACRO_SERVICEGROUPACTIONURL 129
#define MACRO_HOSTGROUPMEMBERS 130
#define MACRO_SERVICEGROUPMEMBERS 131
#define MACRO_CONTACTGROUPNAME 132
#define MACRO_CONTACTGROUPALIAS 133
#define MACRO_CONTACTGROUPMEMBERS 134
#define MACRO_CONTACTGROUPNAMES 135
#define MACRO_NOTIFICATIONRECIPIENTS 136
#define MACRO_NOTIFICATIONISESCALATED 137
#define MACRO_NOTIFICATIONAUTHOR 138
#define MACRO_NOTIFICATIONAUTHORNAME 139
#define MACRO_NOTIFICATIONAUTHORALIAS 140
#define MACRO_NOTIFICATIONCOMMENT 141
#define MACRO_EVENTSTARTTIME 142
#define MACRO_HOSTPROBLEMID 143
#define MACRO_LASTHOSTPROBLEMID 144
#define MACRO_SERVICEPROBLEMID 145
#define MACRO_LASTSERVICEPROBLEMID 146
#define MACRO_ISVALIDTIME 147
#define MACRO_NEXTVALIDTIME 148
#define MACRO_LASTHOSTSTATE 149
#define MACRO_LASTHOSTSTATEID 150
#define MACRO_LASTSERVICESTATE 151
#define MACRO_LASTSERVICESTATEID 152
#define MACRO_HOSTVALUE 153
#define MACRO_SERVICEVALUE 154
#define MACRO_PROBLEMVALUE 155
/************* MACRO CLEANING OPTIONS *****************/
#define STRIP_ILLEGAL_MACRO_CHARS 1
#define ESCAPE_MACRO_CHARS 2
#define URL_ENCODE_MACRO_CHARS 4
/****************** MACRO FUNCTIONS ******************/
nagios_macros *get_global_macros(void);
/*
* Replace macros with their actual values
* This function modifies the global_macros struct and is thus
* not thread-safe.
*/
int process_macros(char *, char **, int);
/* thread-safe version of the above */
int process_macros_r(nagios_macros *mac, char *, char **, int);
/* cleans macros characters before insertion into output string */
char *clean_macro_chars(char *, int);
/*
* These functions updates **macros with the values from
* their respective object type.
*/
int grab_service_macros(service *);
int grab_host_macros(host *);
int grab_servicegroup_macros(servicegroup *);
int grab_hostgroup_macros(hostgroup *);
int grab_contact_macros(contact *);
int grab_macro_value(char *, char **, int *, int *);
int grab_macrox_value(int, char *, char *, char **, int *);
int grab_custom_macro_value(char *, char *, char *, char **);
int grab_datetime_macro(int, char *, char *, char **);
int grab_standard_host_macro(int, host *, char **, int *);
int grab_standard_hostgroup_macro(int, hostgroup *, char **);
int grab_standard_service_macro(int, service *, char **, int *);
int grab_standard_servicegroup_macro(int, servicegroup *, char **);
int grab_standard_contact_macro(int, contact *, char **);
int grab_contact_address_macro(int, contact *, char **);
int grab_standard_contactgroup_macro(int, contactgroup *, char **);
int grab_custom_object_macro(char *, customvariablesmember *, char **);
/* thread-safe version of the above */
int grab_service_macros_r(nagios_macros *mac, service *);
int grab_host_macros_r(nagios_macros *mac, host *);
int grab_servicegroup_macros_r(nagios_macros *mac, servicegroup *);
int grab_hostgroup_macros_r(nagios_macros *mac, hostgroup *);
int grab_contact_macros_r(nagios_macros *mac, contact *);
int grab_macro_value_r(nagios_macros *mac, char *, char **, int *, int *);
int grab_macrox_value_r(nagios_macros *mac, int, char *, char *, char **, int *);
int grab_custom_macro_value_r(nagios_macros *mac, char *, char *, char *, char **);
int grab_datetime_macro_r(nagios_macros *mac, int, char *, char *, char **);
int grab_standard_host_macro_r(nagios_macros *mac, int, host *, char **, int *);
int grab_standard_hostgroup_macro_r(nagios_macros *mac, int, hostgroup *, char **);
int grab_standard_service_macro_r(nagios_macros *mac, int, service *, char **, int *);
int grab_standard_servicegroup_macro_r(nagios_macros *mac, int, servicegroup *, char **);
int grab_standard_contact_macro_r(nagios_macros *mac, int, contact *, char **);
int grab_custom_object_macro_r(nagios_macros *mac, char *, customvariablesmember *, char **);
char *get_url_encoded_string(char *); /* URL encode a string */
int init_macros(void);
int init_macrox_names(void);
int free_macrox_names(void);
extern void copy_constant_macros(char **dest);
/* clear macros */
int clear_argv_macros(void);
int clear_volatile_macros(void);
int clear_host_macros(void);
int clear_service_macros(void);
int clear_hostgroup_macros(void);
int clear_servicegroup_macros(void);
int clear_contact_macros(void);
int clear_contactgroup_macros(void);
int clear_summary_macros(void);
/* thread-safe version of the above */
int clear_argv_macros_r(nagios_macros *mac);
int clear_volatile_macros_r(nagios_macros *mac);
int clear_host_macros_r(nagios_macros *mac);
int clear_service_macros_r(nagios_macros *mac);
int clear_hostgroup_macros_r(nagios_macros *mac);
int clear_servicegroup_macros_r(nagios_macros *mac);
int clear_contact_macros_r(nagios_macros *mac);
int clear_contactgroup_macros_r(nagios_macros *mac);
int clear_summary_macros_r(nagios_macros *mac);
#ifndef NSCGI
int set_all_macro_environment_vars(int);
int set_macrox_environment_vars(int);
int set_argv_macro_environment_vars(int);
int set_custom_macro_environment_vars(int);
int set_contact_address_environment_vars(int);
int set_macro_environment_var(char *, char *, int);
/* thread-safe version of the above */
int set_all_macro_environment_vars_r(nagios_macros *mac, int);
int set_macrox_environment_vars_r(nagios_macros *mac, int);
int set_argv_macro_environment_vars_r(nagios_macros *mac, int);
int set_custom_macro_environment_vars_r(nagios_macros *mac, int);
int set_contact_address_environment_vars_r(nagios_macros *mac, int);
#endif
NAGIOS_END_DECL
#endif

756
nagios4/nagios.h Normal file
View File

@@ -0,0 +1,756 @@
/************************************************************************
*
* Nagios Main Header File
* Written By: Ethan Galstad (egalstad@nagios.org)
*
* 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.
************************************************************************/
#ifndef _NAGIOS_H
#define _NAGIOS_H
#ifndef NSCORE
# define NSCORE
#endif
#include "defaults.h"
#include "common.h"
#include "logging.h"
#include "locations.h"
#include "objects.h"
#include "macros.h"
#include "config.h"
/*
* global variables only used in the core. Reducing this list would be
* a Good Thing(tm).
*/
extern char *nagios_binary_path;
extern char *config_file;
extern char *command_file;
extern char *temp_file;
extern char *temp_path;
extern char *check_result_path;
extern char *lock_file;
extern char *object_precache_file;
extern unsigned int nofile_limit, nproc_limit, max_apps;
extern int num_check_workers;
extern char *qh_socket_path;
extern char *nagios_user;
extern char *nagios_group;
extern char *macro_user[MAX_USER_MACROS];
extern char *ocsp_command;
extern char *ochp_command;
extern command *ocsp_command_ptr;
extern command *ochp_command_ptr;
extern int ocsp_timeout;
extern int ochp_timeout;
extern char *global_host_event_handler;
extern char *global_service_event_handler;
extern command *global_host_event_handler_ptr;
extern command *global_service_event_handler_ptr;
extern char *illegal_object_chars;
extern int use_regexp_matches;
extern int use_true_regexp_matching;
extern int use_syslog;
extern char *log_file;
extern char *log_archive_path;
extern int log_notifications;
extern int log_service_retries;
extern int log_host_retries;
extern int log_event_handlers;
extern int log_external_commands;
extern int log_passive_checks;
extern unsigned long logging_options;
extern unsigned long syslog_options;
extern int service_check_timeout;
extern int service_check_timeout_state;
extern int host_check_timeout;
extern int event_handler_timeout;
extern int notification_timeout;
extern int log_initial_states;
extern int log_current_states;
extern int daemon_dumps_core;
extern int sig_id;
extern int caught_signal;
extern int verify_config;
extern int test_scheduling;
extern int precache_objects;
extern int use_precached_objects;
extern int service_inter_check_delay_method;
extern int host_inter_check_delay_method;
extern int service_interleave_factor_method;
extern int max_host_check_spread;
extern int max_service_check_spread;
extern sched_info scheduling_info;
extern int max_parallel_service_checks;
extern int check_reaper_interval;
extern int max_check_reaper_time;
extern int service_freshness_check_interval;
extern int host_freshness_check_interval;
extern int auto_rescheduling_interval;
extern int auto_rescheduling_window;
extern int check_orphaned_services;
extern int check_orphaned_hosts;
extern int check_service_freshness;
extern int check_host_freshness;
extern int auto_reschedule_checks;
extern int additional_freshness_latency;
extern int check_for_updates;
extern int bare_update_check;
extern time_t last_update_check;
extern unsigned long update_uid;
extern int update_available;
extern char *last_program_version;
extern char *new_program_version;
extern int use_aggressive_host_checking;
extern time_t cached_host_check_horizon;
extern time_t cached_service_check_horizon;
extern int enable_predictive_host_dependency_checks;
extern int enable_predictive_service_dependency_checks;
extern int soft_state_dependencies;
extern int retain_state_information;
extern int retention_update_interval;
extern int use_retained_program_state;
extern int use_retained_scheduling_info;
extern int retention_scheduling_horizon;
extern char *retention_file;
extern unsigned long retained_host_attribute_mask;
extern unsigned long retained_service_attribute_mask;
extern unsigned long retained_contact_host_attribute_mask;
extern unsigned long retained_contact_service_attribute_mask;
extern unsigned long retained_process_host_attribute_mask;
extern unsigned long retained_process_service_attribute_mask;
extern int translate_passive_host_checks;
extern int passive_host_checks_are_soft;
extern int status_update_interval;
extern char *retention_file;
extern int time_change_threshold;
extern unsigned long event_broker_options;
extern double low_service_flap_threshold;
extern double high_service_flap_threshold;
extern double low_host_flap_threshold;
extern double high_host_flap_threshold;
extern int use_large_installation_tweaks;
extern int enable_environment_macros;
extern int free_child_process_memory;
extern int child_processes_fork_twice;
extern char *use_timezone;
extern time_t max_check_result_file_age;
extern char *debug_file;
extern int debug_level;
extern int debug_verbosity;
extern unsigned long max_debug_file_size;
extern int allow_empty_hostgroup_assignment;
extern time_t last_program_stop;
extern time_t event_start;
extern int sigshutdown, sigrestart;
extern int currently_running_service_checks;
extern int currently_running_host_checks;
extern unsigned long next_event_id;
extern unsigned long next_problem_id;
extern unsigned long next_comment_id;
extern unsigned long next_notification_id;
extern unsigned long modified_process_attributes;
extern unsigned long modified_host_process_attributes;
extern unsigned long modified_service_process_attributes;
extern squeue_t *nagios_squeue;
extern iobroker_set *nagios_iobs;
extern struct check_stats check_statistics[MAX_CHECK_STATS_TYPES];
/*** perfdata variables ***/
extern int perfdata_timeout;
extern char *host_perfdata_command;
extern char *service_perfdata_command;
extern char *host_perfdata_file_template;
extern char *service_perfdata_file_template;
extern char *host_perfdata_file;
extern char *service_perfdata_file;
extern int host_perfdata_file_append;
extern int service_perfdata_file_append;
extern int host_perfdata_file_pipe;
extern int service_perfdata_file_pipe;
extern unsigned long host_perfdata_file_processing_interval;
extern unsigned long service_perfdata_file_processing_interval;
extern char *host_perfdata_file_processing_command;
extern char *service_perfdata_file_processing_command;
extern int host_perfdata_process_empty_results;
extern int service_perfdata_process_empty_results;
/*** end perfdata variables */
extern struct notify_list *notification_list;
extern struct check_engine nagios_check_engine;
/*
* Everything we need to keep system load in check.
* Don't use this from modules.
*/
struct load_control {
time_t last_check; /* last time we checked the real load */
time_t last_change; /* last time we changed settings */
time_t check_interval; /* seconds between load checks */
double load[3]; /* system load, as reported by getloadavg() */
float backoff_limit; /* limit we must reach before we back off */
float rampup_limit; /* limit we must reach before we ramp back up */
unsigned int backoff_change; /* backoff by this much */
unsigned int rampup_change; /* ramp up by this much */
unsigned int changes; /* number of times we've changed settings */
unsigned int jobs_max; /* upper setting for jobs_limit */
unsigned int jobs_limit; /* current limit */
unsigned int jobs_min; /* lower setting for jobs_limit */
unsigned int jobs_running; /* jobs currently running */
unsigned int nproc_limit; /* rlimit for user processes */
unsigned int nofile_limit; /* rlimit for open files */
unsigned int options; /* various option flags */
};
extern struct load_control loadctl;
/* options for load control */
#define LOADCTL_ENABLED (1 << 0)
/************* MISC LENGTH/SIZE DEFINITIONS ***********/
/*
NOTE: Plugin length is artificially capped at 8k to prevent runaway plugins from returning MBs/GBs of data
back to Nagios. If you increase the 8k cap by modifying this value, make sure you also increase the value
of MAX_EXTERNAL_COMMAND_LENGTH in common.h to allow for passive checks results received through the external
command file. EG 10/19/07
*/
#define MAX_PLUGIN_OUTPUT_LENGTH 8192 /* max length of plugin output (including perf data) */
/******************* STATE LOGGING TYPES **************/
#define INITIAL_STATES 1
#define CURRENT_STATES 2
/************ SERVICE DEPENDENCY VALUES ***************/
#define DEPENDENCIES_OK 0
#define DEPENDENCIES_FAILED 1
/*********** ROUTE CHECK PROPAGATION TYPES ************/
#define PROPAGATE_TO_PARENT_HOSTS 1
#define PROPAGATE_TO_CHILD_HOSTS 2
/****************** FLAPPING TYPES ********************/
#define HOST_FLAPPING 0
#define SERVICE_FLAPPING 1
/**************** NOTIFICATION TYPES ******************/
#define HOST_NOTIFICATION 0
#define SERVICE_NOTIFICATION 1
/************* NOTIFICATION REASON TYPES ***************/
#define NOTIFICATION_NORMAL 0
#define NOTIFICATION_ACKNOWLEDGEMENT 1
#define NOTIFICATION_FLAPPINGSTART 2
#define NOTIFICATION_FLAPPINGSTOP 3
#define NOTIFICATION_FLAPPINGDISABLED 4
#define NOTIFICATION_DOWNTIMESTART 5
#define NOTIFICATION_DOWNTIMEEND 6
#define NOTIFICATION_DOWNTIMECANCELLED 7
#define NOTIFICATION_CUSTOM 8
/**************** EVENT HANDLER TYPES *****************/
#define HOST_EVENTHANDLER 0
#define SERVICE_EVENTHANDLER 1
#define GLOBAL_HOST_EVENTHANDLER 2
#define GLOBAL_SERVICE_EVENTHANDLER 3
/***************** STATE CHANGE TYPES *****************/
#define HOST_STATECHANGE 0
#define SERVICE_STATECHANGE 1
/***************** OBJECT CHECK TYPES *****************/
#define SERVICE_CHECK 0
#define HOST_CHECK 1
/******************* EVENT TYPES **********************/
#define EVENT_SERVICE_CHECK 0 /* active service check */
#define EVENT_COMMAND_CHECK 1 /* external command check */
#define EVENT_LOG_ROTATION 2 /* log file rotation */
#define EVENT_PROGRAM_SHUTDOWN 3 /* program shutdown */
#define EVENT_PROGRAM_RESTART 4 /* program restart */
#define EVENT_CHECK_REAPER 5 /* reaps results from host and service checks */
#define EVENT_ORPHAN_CHECK 6 /* checks for orphaned hosts and services */
#define EVENT_RETENTION_SAVE 7 /* save (dump) retention data */
#define EVENT_STATUS_SAVE 8 /* save (dump) status data */
#define EVENT_SCHEDULED_DOWNTIME 9 /* scheduled host or service downtime */
#define EVENT_SFRESHNESS_CHECK 10 /* checks service result "freshness" */
#define EVENT_EXPIRE_DOWNTIME 11 /* checks for (and removes) expired scheduled downtime */
#define EVENT_HOST_CHECK 12 /* active host check */
#define EVENT_HFRESHNESS_CHECK 13 /* checks host result "freshness" */
#define EVENT_RESCHEDULE_CHECKS 14 /* adjust scheduling of host and service checks */
#define EVENT_EXPIRE_COMMENT 15 /* removes expired comments */
#define EVENT_CHECK_PROGRAM_UPDATE 16 /* checks for new version of Nagios */
#define EVENT_SLEEP 98 /* asynchronous sleep event that occurs when event queues are empty */
#define EVENT_USER_FUNCTION 99 /* USER-defined function (modules) */
/*
* VERSIONFIX: Make EVENT_SLEEP and EVENT_USER_FUNCTION appear
* linearly in order.
*/
#define EVENT_TYPE_STR(type) ( \
type == EVENT_SERVICE_CHECK ? "SERVICE_CHECK" : \
type == EVENT_COMMAND_CHECK ? "COMMAND_CHECK" : \
type == EVENT_LOG_ROTATION ? "LOG_ROTATION" : \
type == EVENT_PROGRAM_SHUTDOWN ? "PROGRAM_SHUTDOWN" : \
type == EVENT_PROGRAM_RESTART ? "PROGRAM_RESTART" : \
type == EVENT_CHECK_REAPER ? "CHECK_REAPER" : \
type == EVENT_ORPHAN_CHECK ? "ORPHAN_CHECK" : \
type == EVENT_RETENTION_SAVE ? "RETENTION_SAVE" : \
type == EVENT_STATUS_SAVE ? "STATUS_SAVE" : \
type == EVENT_SCHEDULED_DOWNTIME ? "SCHEDULED_DOWNTIME" : \
type == EVENT_SFRESHNESS_CHECK ? "SFRESHNESS_CHECK" : \
type == EVENT_EXPIRE_DOWNTIME ? "EXPIRE_DOWNTIME" : \
type == EVENT_HOST_CHECK ? "HOST_CHECK" : \
type == EVENT_HFRESHNESS_CHECK ? "HFRESHNESS_CHECK" : \
type == EVENT_RESCHEDULE_CHECKS ? "RESCHEDULE_CHECKS" : \
type == EVENT_EXPIRE_COMMENT ? "EXPIRE_COMMENT" : \
type == EVENT_CHECK_PROGRAM_UPDATE ? "CHECK_PROGRAM_UPDATE" : \
type == EVENT_SLEEP ? "SLEEP" : \
type == EVENT_USER_FUNCTION ? "USER_FUNCTION" : \
"UNKNOWN" \
)
/******* INTER-CHECK DELAY CALCULATION TYPES **********/
#define ICD_NONE 0 /* no inter-check delay */
#define ICD_DUMB 1 /* dumb delay of 1 second */
#define ICD_SMART 2 /* smart delay */
#define ICD_USER 3 /* user-specified delay */
/******* INTERLEAVE FACTOR CALCULATION TYPES **********/
#define ILF_USER 0 /* user-specified interleave factor */
#define ILF_SMART 1 /* smart interleave */
/************ SCHEDULED DOWNTIME TYPES ****************/
#define ACTIVE_DOWNTIME 0 /* active downtime - currently in effect */
#define PENDING_DOWNTIME 1 /* pending downtime - scheduled for the future */
NAGIOS_BEGIN_DECL
/* useful for hosts and services to determine time 'til next check */
#define normal_check_window(o) ((time_t)(o->check_interval * interval_length))
#define retry_check_window(o) ((time_t)(o->retry_interval * interval_length))
#define check_window(o) \
((!o->current_state && o->state_type == SOFT_STATE) ? \
retry_check_window(o) : \
normal_check_window(o))
/** Nerd subscription type */
struct nerd_subscription {
int sd;
struct nerd_channel *chan;
char *format; /* requested format (macro string) for this subscription */
};
/******************** FUNCTIONS **********************/
extern int set_loadctl_options(char *opts, unsigned int len);
/* silly helpers useful pretty much all over the place */
extern const char *service_state_name(int state);
extern const char *host_state_name(int state);
extern const char *state_type_name(int state_type);
extern const char *check_type_name(int check_type);
extern const char *check_result_source(check_result *cr);
/*** Nagios Event Radio Dispatcher functions ***/
extern int nerd_init(void);
extern int nerd_mkchan(const char *name, const char *description, int (*handler)(int, void *), unsigned int callbacks);
extern int nerd_cancel_subscriber(int sd);
extern int nerd_get_channel_id(const char *chan_name);
extern objectlist *nerd_get_subscriptions(int chan_id);
extern int nerd_broadcast(unsigned int chan_id, void *buf, unsigned int len);
/*** Query Handler functions, types and macros*/
typedef int (*qh_handler)(int, char *, unsigned int);
extern int dump_event_stats(int sd);
/* return codes for query_handlers() */
#define QH_OK 0 /* keep listening */
#define QH_CLOSE 1 /* we should close the socket */
#define QH_INVALID 2 /* invalid query. Log and close */
#define QH_TAKEOVER 3 /* handler will take full control. de-register but don't close */
extern int qh_init(const char *path);
extern void qh_deinit(const char *path);
extern int qh_register_handler(const char *name, const char *description, unsigned int options, qh_handler handler);
extern const char *qh_strerror(int code);
/**** Configuration Functions ****/
int read_main_config_file(char *); /* reads the main config file (nagios.cfg) */
int read_resource_file(char *); /* processes macros in resource file */
int read_all_object_data(char *); /* reads all object config data */
/**** Setup Functions ****/
int pre_flight_check(void); /* try and verify the configuration data */
int pre_flight_object_check(int *, int *); /* verify object relationships and settings */
int pre_flight_circular_check(int *, int *); /* detects circular dependencies and paths */
void init_timing_loop(void); /* setup the initial scheduling queue */
void setup_sighandler(void); /* trap signals */
void reset_sighandler(void); /* reset signals to default action */
extern void handle_sigxfsz(int); /* handle SIGXFSZ */
int daemon_init(void); /* switches to daemon mode */
int drop_privileges(char *, char *); /* drops privileges before startup */
void display_scheduling_info(void); /* displays service check scheduling information */
/**** Event Queue Functions ****/
int init_event_queue(void); /* creates the queue nagios_squeue */
timed_event *schedule_new_event(int, int, time_t, int, unsigned long, void *, int, void *, void *, int); /* schedules a new timed event */
void reschedule_event(squeue_t *sq, timed_event *event); /* reschedules an event */
void add_event(squeue_t *sq, timed_event *event); /* adds an event to the execution queue */
void remove_event(squeue_t *sq, timed_event *event); /* remove an event from the execution queue */
int event_execution_loop(void); /* main monitoring/event handler loop */
int handle_timed_event(timed_event *); /* top level handler for timed events */
void adjust_check_scheduling(void); /* auto-adjusts scheduling of host and service checks */
void compensate_for_system_time_change(unsigned long, unsigned long); /* attempts to compensate for a change in the system time */
void adjust_timestamp_for_time_change(time_t, time_t, unsigned long, time_t *); /* adjusts a timestamp variable for a system time change */
/**** IPC Functions ****/
int process_check_result_queue(char *);
int process_check_result_file(char *);
int process_check_result(check_result *);
int delete_check_result_file(char *);
int init_check_result(check_result *);
int free_check_result(check_result *); /* frees memory associated with a host/service check result */
int parse_check_output(char *, char **, char **, char **, int, int);
int open_command_file(void); /* creates the external command file as a named pipe (FIFO) and opens it for reading */
int close_command_file(void); /* closes and deletes the external command file (FIFO) */
/**** Monitoring/Event Handler Functions ****/
int check_service_dependencies(service *, int); /* checks service dependencies */
int check_host_dependencies(host *, int); /* checks host dependencies */
void check_for_orphaned_services(void); /* checks for orphaned services */
void check_for_orphaned_hosts(void); /* checks for orphaned hosts */
void check_service_result_freshness(void); /* checks the "freshness" of service check results */
int is_service_result_fresh(service *, time_t, int); /* determines if a service's check results are fresh */
void check_host_result_freshness(void); /* checks the "freshness" of host check results */
int is_host_result_fresh(host *, time_t, int); /* determines if a host's check results are fresh */
int my_system(char *, int, int *, double *, char **, int); /* executes a command via popen(), but also protects against timeouts */
int my_system_r(nagios_macros *mac, char *, int, int *, double *, char **, int); /* thread-safe version of the above */
/**** Flap Detection Functions ****/
void check_for_service_flapping(service *, int, int); /* determines whether or not a service is "flapping" between states */
void check_for_host_flapping(host *, int, int, int); /* determines whether or not a host is "flapping" between states */
void set_service_flap(service *, double, double, double, int); /* handles a service that is flapping */
void clear_service_flap(service *, double, double, double); /* handles a service that has stopped flapping */
void set_host_flap(host *, double, double, double, int); /* handles a host that is flapping */
void clear_host_flap(host *, double, double, double); /* handles a host that has stopped flapping */
void enable_flap_detection_routines(void); /* enables flap detection on a program-wide basis */
void disable_flap_detection_routines(void); /* disables flap detection on a program-wide basis */
void enable_host_flap_detection(host *); /* enables flap detection for a particular host */
void disable_host_flap_detection(host *); /* disables flap detection for a particular host */
void enable_service_flap_detection(service *); /* enables flap detection for a particular service */
void disable_service_flap_detection(service *); /* disables flap detection for a particular service */
void handle_host_flap_detection_disabled(host *); /* handles the details when flap detection is disabled globally or on a per-host basis */
void handle_service_flap_detection_disabled(service *); /* handles the details when flap detection is disabled globally or on a per-service basis */
/**** Route/Host Check Functions ****/
int check_host_check_viability(host *, int, int *, time_t *);
int adjust_host_check_attempt(host *, int);
int determine_host_reachability(host *);
int process_host_check_result(host *, int, char *, int, int, int, unsigned long);
int perform_on_demand_host_check(host *, int *, int, int, unsigned long);
int execute_sync_host_check(host *);
int run_scheduled_host_check(host *, int, double);
int run_async_host_check(host *, int, double, int, int, int *, time_t *);
int handle_async_host_check_result(host *, check_result *);
/**** Service Check Functions ****/
int check_service_check_viability(service *, int, int *, time_t *);
int run_scheduled_service_check(service *, int, double);
int run_async_service_check(service *, int, double, int, int, int *, time_t *);
int handle_async_service_check_result(service *, check_result *);
/**** Event Handler Functions ****/
int handle_host_state(host *); /* top level host state handler */
/**** Common Check Fucntions *****/
int reap_check_results(void);
/**** Check Statistics Functions ****/
int init_check_stats(void);
int update_check_stats(int, time_t);
int generate_check_stats(void);
/**** Event Handler Functions ****/
int obsessive_compulsive_service_check_processor(service *); /* distributed monitoring craziness... */
int obsessive_compulsive_host_check_processor(host *); /* distributed monitoring craziness... */
int handle_service_event(service *); /* top level service event logic */
int run_service_event_handler(nagios_macros *mac, service *); /* runs the event handler for a specific service */
int run_global_service_event_handler(nagios_macros *mac, service *); /* runs the global service event handler */
int handle_host_event(host *); /* top level host event logic */
int run_host_event_handler(nagios_macros *mac, host *); /* runs the event handler for a specific host */
int run_global_host_event_handler(nagios_macros *mac, host *); /* runs the global host event handler */
/**** Notification Functions ****/
const char *notification_reason_name(unsigned int reason_type);
int check_service_notification_viability(service *, int, int); /* checks viability of notifying all contacts about a service */
int is_valid_escalation_for_service_notification(service *, serviceescalation *, int); /* checks if an escalation entry is valid for a particular service notification */
int should_service_notification_be_escalated(service *); /* checks if a service notification should be escalated */
int service_notification(service *, int, char *, char *, int); /* notify all contacts about a service (problem or recovery) */
int check_contact_service_notification_viability(contact *, service *, int, int); /* checks viability of notifying a contact about a service */
int notify_contact_of_service(nagios_macros *mac, contact *, service *, int, char *, char *, int, int); /* notify a single contact about a service */
int check_host_notification_viability(host *, int, int); /* checks viability of notifying all contacts about a host */
int is_valid_escalation_for_host_notification(host *, hostescalation *, int); /* checks if an escalation entry is valid for a particular host notification */
int should_host_notification_be_escalated(host *); /* checks if a host notification should be escalated */
int host_notification(host *, int, char *, char *, int); /* notify all contacts about a host (problem or recovery) */
int check_contact_host_notification_viability(contact *, host *, int, int); /* checks viability of notifying a contact about a host */
int notify_contact_of_host(nagios_macros *mac, contact *, host *, int, char *, char *, int, int); /* notify a single contact about a host */
int create_notification_list_from_host(nagios_macros *mac, host *,int,int *,int); /* given a host, create list of contacts to be notified (remove duplicates) */
int create_notification_list_from_service(nagios_macros *mac, service *,int,int *,int); /* given a service, create list of contacts to be notified (remove duplicates) */
int add_notification(nagios_macros *mac, contact *); /* adds a notification instance */
notification *find_notification(contact *); /* finds a notification object */
time_t get_next_host_notification_time(host *, time_t); /* calculates nex acceptable re-notification time for a host */
time_t get_next_service_notification_time(service *, time_t); /* calculates nex acceptable re-notification time for a service */
/**** Cleanup Functions ****/
void cleanup(void); /* cleanup after ourselves (before quitting or restarting) */
void free_memory(nagios_macros *mac); /* free memory allocated to all linked lists in memory */
int reset_variables(void); /* reset all global variables */
void free_notification_list(void); /* frees all memory allocated to the notification list */
/**** Miscellaneous Functions ****/
void sighandler(int); /* handles signals */
void my_system_sighandler(int); /* handles timeouts when executing commands via my_system() */
char *get_next_string_from_buf(char *buf, int *start_index, int bufsize);
int compare_strings(char *, char *); /* compares two strings for equality */
char *escape_newlines(char *);
int contains_illegal_object_chars(char *); /* tests whether or not an object name (host, service, etc.) contains illegal characters */
int my_rename(char *, char *); /* renames a file - works across filesystems */
int my_fcopy(char *, char *); /* copies a file - works across filesystems */
int my_fdcopy(char *, char *, int); /* copies a named source to an already opened destination file */
/* thread-safe version of get_raw_command_line_r() */
extern int get_raw_command_line_r(nagios_macros *mac, command *, char *, char **, int);
/*
* given a raw command line, determine the actual command to run
* Manipulates global_macros.argv and is thus not threadsafe
*/
extern int get_raw_command_line(command *, char *, char **, int);
int check_time_against_period(time_t, timeperiod *); /* check to see if a specific time is covered by a time period */
int is_daterange_single_day(daterange *);
time_t calculate_time_from_weekday_of_month(int, int, int, int); /* calculates midnight time of specific (3rd, last, etc.) weekday of a particular month */
time_t calculate_time_from_day_of_month(int, int, int); /* calculates midnight time of specific (1st, last, etc.) day of a particular month */
void get_next_valid_time(time_t, time_t *, timeperiod *); /* get the next valid time in a time period */
time_t get_next_log_rotation_time(void); /* determine the next time to schedule a log rotation */
int dbuf_init(dbuf *, int);
int dbuf_free(dbuf *);
int dbuf_strcat(dbuf *, const char *);
int set_environment_var(char *, char *, int); /* sets/clears and environment variable */
int check_for_nagios_updates(int, int); /* checks to see if new version of Nagios are available */
int query_update_api(void); /* checks to see if new version of Nagios are available */
/**** External Command Functions ****/
int process_external_command1(char *); /* top-level external command processor */
int process_external_command2(int, time_t, char *); /* process an external command */
int process_external_commands_from_file(char *, int); /* process external commands in a file */
int process_host_command(int, time_t, char *); /* process an external host command */
int process_hostgroup_command(int, time_t, char *); /* process an external hostgroup command */
int process_service_command(int, time_t, char *); /* process an external service command */
int process_servicegroup_command(int, time_t, char *); /* process an external servicegroup command */
int process_contact_command(int, time_t, char *); /* process an external contact command */
int process_contactgroup_command(int, time_t, char *); /* process an external contactgroup command */
/**** External Command Implementations ****/
int cmd_add_comment(int, time_t, char *); /* add a service or host comment */
int cmd_delete_comment(int, char *); /* delete a service or host comment */
int cmd_delete_all_comments(int, char *); /* delete all comments associated with a host or service */
int cmd_delay_notification(int, char *); /* delay a service or host notification */
int cmd_schedule_check(int, char *); /* schedule an immediate or delayed host check */
int cmd_schedule_host_service_checks(int, char *, int); /* schedule an immediate or delayed checks of all services on a host */
int cmd_signal_process(int, char *); /* schedules a program shutdown or restart */
int cmd_process_service_check_result(int, time_t, char *); /* processes a passive service check */
int cmd_process_host_check_result(int, time_t, char *); /* processes a passive host check */
int cmd_acknowledge_problem(int, char *); /* acknowledges a host or service problem */
int cmd_remove_acknowledgement(int, char *); /* removes a host or service acknowledgement */
int cmd_schedule_downtime(int, time_t, char *); /* schedules host or service downtime */
int cmd_delete_downtime(int, char *); /* cancels active/pending host or service scheduled downtime */
int cmd_change_object_int_var(int, char *); /* changes host/svc (int) variable */
int cmd_change_object_char_var(int, char *); /* changes host/svc (char) variable */
int cmd_change_object_custom_var(int, char *); /* changes host/svc custom variable */
int cmd_process_external_commands_from_file(int, char *); /* process external commands from a file */
int cmd_delete_downtime_by_start_time_comment(int, char *);
int cmd_delete_downtime_by_host_name(int, char *);
int cmd_delete_downtime_by_hostgroup_name(int, char *);
int process_passive_service_check(time_t, char *, char *, int, char *);
int process_passive_host_check(time_t, char *, int, char *);
/**** Internal Command Implementations ****/
void disable_service_checks(service *); /* disables a service check */
void enable_service_checks(service *); /* enables a service check */
void schedule_service_check(service *, time_t, int); /* schedules an immediate or delayed service check */
void schedule_host_check(host *, time_t, int); /* schedules an immediate or delayed host check */
void enable_all_notifications(void); /* enables notifications on a program-wide basis */
void disable_all_notifications(void); /* disables notifications on a program-wide basis */
void enable_service_notifications(service *); /* enables service notifications */
void disable_service_notifications(service *); /* disables service notifications */
void enable_host_notifications(host *); /* enables host notifications */
void disable_host_notifications(host *); /* disables host notifications */
void enable_and_propagate_notifications(host *, int, int, int, int); /* enables notifications for all hosts and services beyond a given host */
void disable_and_propagate_notifications(host *, int, int, int, int); /* disables notifications for all hosts and services beyond a given host */
void schedule_and_propagate_downtime(host *, time_t, char *, char *, time_t, time_t, int, unsigned long, unsigned long); /* schedules downtime for all hosts beyond a given host */
void acknowledge_host_problem(host *, char *, char *, int, int, int); /* acknowledges a host problem */
void acknowledge_service_problem(service *, char *, char *, int, int, int); /* acknowledges a service problem */
void remove_host_acknowledgement(host *); /* removes a host acknowledgement */
void remove_service_acknowledgement(service *); /* removes a service acknowledgement */
void start_executing_service_checks(void); /* starts executing service checks */
void stop_executing_service_checks(void); /* stops executing service checks */
void start_accepting_passive_service_checks(void); /* starts accepting passive service check results */
void stop_accepting_passive_service_checks(void); /* stops accepting passive service check results */
void enable_passive_service_checks(service *); /* enables passive service checks for a particular service */
void disable_passive_service_checks(service *); /* disables passive service checks for a particular service */
void start_using_event_handlers(void); /* enables event handlers on a program-wide basis */
void stop_using_event_handlers(void); /* disables event handlers on a program-wide basis */
void enable_service_event_handler(service *); /* enables the event handler for a particular service */
void disable_service_event_handler(service *); /* disables the event handler for a particular service */
void enable_host_event_handler(host *); /* enables the event handler for a particular host */
void disable_host_event_handler(host *); /* disables the event handler for a particular host */
void enable_host_checks(host *); /* enables checks of a particular host */
void disable_host_checks(host *); /* disables checks of a particular host */
void start_obsessing_over_service_checks(void); /* start obsessing about service check results */
void stop_obsessing_over_service_checks(void); /* stop obsessing about service check results */
void start_obsessing_over_host_checks(void); /* start obsessing about host check results */
void stop_obsessing_over_host_checks(void); /* stop obsessing about host check results */
void enable_service_freshness_checks(void); /* enable service freshness checks */
void disable_service_freshness_checks(void); /* disable service freshness checks */
void enable_host_freshness_checks(void); /* enable host freshness checks */
void disable_host_freshness_checks(void); /* disable host freshness checks */
void enable_performance_data(void); /* enables processing of performance data on a program-wide basis */
void disable_performance_data(void); /* disables processing of performance data on a program-wide basis */
void start_executing_host_checks(void); /* starts executing host checks */
void stop_executing_host_checks(void); /* stops executing host checks */
void start_accepting_passive_host_checks(void); /* starts accepting passive host check results */
void stop_accepting_passive_host_checks(void); /* stops accepting passive host check results */
void enable_passive_host_checks(host *); /* enables passive host checks for a particular host */
void disable_passive_host_checks(host *); /* disables passive host checks for a particular host */
void start_obsessing_over_service(service *); /* start obsessing about specific service check results */
void stop_obsessing_over_service(service *); /* stop obsessing about specific service check results */
void start_obsessing_over_host(host *); /* start obsessing about specific host check results */
void stop_obsessing_over_host(host *); /* stop obsessing about specific host check results */
void set_host_notification_number(host *, int); /* sets current notification number for a specific host */
void set_service_notification_number(service *, int); /* sets current notification number for a specific service */
void enable_contact_host_notifications(contact *); /* enables host notifications for a specific contact */
void disable_contact_host_notifications(contact *); /* disables host notifications for a specific contact */
void enable_contact_service_notifications(contact *); /* enables service notifications for a specific contact */
void disable_contact_service_notifications(contact *); /* disables service notifications for a specific contact */
int launch_command_file_worker(void);
int shutdown_command_file_worker(void);
char *get_program_version(void);
char *get_program_modification_date(void);
NAGIOS_END_DECL
#endif

70
nagios4/nebcallbacks.h Normal file
View File

@@ -0,0 +1,70 @@
/*****************************************************************************
*
* NEBCALLBACKS.H - Include file for event broker modules
*
*
* 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.
*
*****************************************************************************/
#ifndef _NEBCALLBACKS_H
#define _NEBCALLBACKS_H
#include "nebmodules.h"
/***** CALLBACK TYPES *****/
#define NEBCALLBACK_NUMITEMS 26 /* total number of callback types we have */
#define NEBCALLBACK_PROCESS_DATA 0
#define NEBCALLBACK_TIMED_EVENT_DATA 1
#define NEBCALLBACK_LOG_DATA 2
#define NEBCALLBACK_SYSTEM_COMMAND_DATA 3
#define NEBCALLBACK_EVENT_HANDLER_DATA 4
#define NEBCALLBACK_NOTIFICATION_DATA 5
#define NEBCALLBACK_SERVICE_CHECK_DATA 6
#define NEBCALLBACK_HOST_CHECK_DATA 7
#define NEBCALLBACK_COMMENT_DATA 8
#define NEBCALLBACK_DOWNTIME_DATA 9
#define NEBCALLBACK_FLAPPING_DATA 10
#define NEBCALLBACK_PROGRAM_STATUS_DATA 11
#define NEBCALLBACK_HOST_STATUS_DATA 12
#define NEBCALLBACK_SERVICE_STATUS_DATA 13
#define NEBCALLBACK_ADAPTIVE_PROGRAM_DATA 14
#define NEBCALLBACK_ADAPTIVE_HOST_DATA 15
#define NEBCALLBACK_ADAPTIVE_SERVICE_DATA 16
#define NEBCALLBACK_EXTERNAL_COMMAND_DATA 17
#define NEBCALLBACK_AGGREGATED_STATUS_DATA 18
#define NEBCALLBACK_RETENTION_DATA 19
#define NEBCALLBACK_CONTACT_NOTIFICATION_DATA 20
#define NEBCALLBACK_CONTACT_NOTIFICATION_METHOD_DATA 21
#define NEBCALLBACK_ACKNOWLEDGEMENT_DATA 22
#define NEBCALLBACK_STATE_CHANGE_DATA 23
#define NEBCALLBACK_CONTACT_STATUS_DATA 24
#define NEBCALLBACK_ADAPTIVE_CONTACT_DATA 25
#define nebcallback_flag(x) (1 << (x))
/***** CALLBACK FUNCTIONS *****/
NAGIOS_BEGIN_DECL
int neb_register_callback(int callback_type, void *mod_handle, int priority, int (*callback_func)(int, void *));
int neb_deregister_callback(int callback_type, int (*callback_func)(int, void *));
int neb_deregister_module_callbacks(nebmodule *);
NAGIOS_END_DECL
#endif

67
nagios4/neberrors.h Normal file
View File

@@ -0,0 +1,67 @@
/*****************************************************************************
*
* NEBERRORS.H - Event broker errors
*
*
* 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.
*
*****************************************************************************/
#ifndef _NEBERRORS_H
#define _NEBERRORS_H
/***** GENERIC DEFINES *****/
#define NEB_OK 0
#define NEB_ERROR -1
#define NEB_TRUE 1
#define NEB_FALSE 0
/***** GENERIC ERRORS *****/
#define NEBERROR_NOMEM 100 /* memory could not be allocated */
/***** CALLBACK ERRORS *****/
#define NEBERROR_NOCALLBACKFUNC 200 /* no callback function was specified */
#define NEBERROR_NOCALLBACKLIST 201 /* callback list not initialized */
#define NEBERROR_CALLBACKBOUNDS 202 /* callback type was out of bounds */
#define NEBERROR_CALLBACKNOTFOUND 203 /* the callback could not be found */
#define NEBERROR_NOMODULEHANDLE 204 /* no module handle specified */
#define NEBERROR_BADMODULEHANDLE 205 /* bad module handle */
#define NEBERROR_CALLBACKOVERRIDE 206 /* module wants to override default Nagios handling of event */
#define NEBERROR_CALLBACKCANCEL 207 /* module wants to cancel callbacks to other modules */
/***** MODULE ERRORS *****/
#define NEBERROR_NOMODULE 300 /* no module was specified */
/***** MODULE INFO ERRORS *****/
#define NEBERROR_MODINFOBOUNDS 400 /* module info index was out of bounds */
#endif

62
nagios4/nebmods.h Normal file
View File

@@ -0,0 +1,62 @@
/*****************************************************************************
*
* NEBMODS.H - Include file for event broker modules
*
*
* 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.
*
*****************************************************************************/
#ifndef _NEBMODS_H
#define _NEBMODS_H
#include "nebcallbacks.h"
#include "nebmodules.h"
NAGIOS_BEGIN_DECL
/***** MODULE STRUCTURES *****/
/* NEB module callback list struct */
typedef struct nebcallback_struct {
void *callback_func;
void *module_handle;
int priority;
struct nebcallback_struct *next;
} nebcallback;
/***** MODULE FUNCTIONS *****/
int neb_init_modules(void);
int neb_deinit_modules(void);
int neb_load_all_modules(void);
int neb_load_module(nebmodule *);
int neb_free_module_list(void);
int neb_unload_all_modules(int, int);
int neb_unload_module(nebmodule *, int, int);
int neb_add_module(char *, char *, int);
int neb_add_core_module(nebmodule *mod);
/***** CALLBACK FUNCTIONS *****/
int neb_init_callback_list(void);
int neb_free_callback_list(void);
int neb_make_callbacks(int, void *);
NAGIOS_END_DECL
#endif

94
nagios4/nebmodules.h Normal file
View File

@@ -0,0 +1,94 @@
/*****************************************************************************
*
* NEBMODULES.H - Include file for event broker modules
*
*
* 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.
*
*****************************************************************************/
#ifndef _NEBMODULES_H
#define _NEBMODULES_H
#include "common.h"
NAGIOS_BEGIN_DECL
/***** MODULE VERSION INFORMATION *****/
#define NEB_API_VERSION(x) int __neb_api_version = x;
#define CURRENT_NEB_API_VERSION 4
/***** MODULE INFORMATION *****/
#define NEBMODULE_MODINFO_NUMITEMS 6
#define NEBMODULE_MODINFO_TITLE 0
#define NEBMODULE_MODINFO_AUTHOR 1
#define NEBMODULE_MODINFO_COPYRIGHT 2
#define NEBMODULE_MODINFO_VERSION 3
#define NEBMODULE_MODINFO_LICENSE 4
#define NEBMODULE_MODINFO_DESC 5
/***** MODULE LOAD/UNLOAD OPTIONS *****/
#define NEBMODULE_NORMAL_LOAD 0 /* module is being loaded normally */
#define NEBMODULE_REQUEST_UNLOAD 0 /* request module to unload (but don't force it) */
#define NEBMODULE_FORCE_UNLOAD 1 /* force module to unload */
/***** MODULES UNLOAD REASONS *****/
#define NEBMODULE_NEB_SHUTDOWN 1 /* event broker is shutting down */
#define NEBMODULE_NEB_RESTART 2 /* event broker is restarting */
#define NEBMODULE_ERROR_NO_INIT 3 /* _module_init() function was not found in module */
#define NEBMODULE_ERROR_BAD_INIT 4 /* _module_init() function returned a bad code */
#define NEBMODULE_ERROR_API_VERSION 5 /* module version is incompatible with current api */
/***** MODULE STRUCTURES *****/
/* NEB module structure */
typedef struct nebmodule_struct {
char *filename;
char *dl_file; /* the file we actually loaded */
char *args;
char *info[NEBMODULE_MODINFO_NUMITEMS];
int should_be_loaded;
int is_currently_loaded;
int core_module;
#ifdef USE_LTDL
lt_dlhandle module_handle;
lt_ptr init_func;
lt_ptr deinit_func;
#else
void *module_handle;
void *init_func;
void *deinit_func;
#endif
struct nebmodule_struct *next;
} nebmodule;
/***** MODULE FUNCTIONS *****/
int neb_set_module_info(void *, int, char *);
NAGIOS_END_DECL
#endif

525
nagios4/nebstructs.h Normal file
View File

@@ -0,0 +1,525 @@
/*****************************************************************************
*
* NEBSTRUCTS.H - Event broker includes for Nagios
*
*
* 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.
*
*****************************************************************************/
#ifndef _NEBSTRUCTS_H
#define _NEBSTRUCTS_H
#include "common.h"
#include "objects.h"
#include "nagios.h"
NAGIOS_BEGIN_DECL
/****** STRUCTURES *************************/
/* process data structure */
typedef struct nebstruct_process_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
} nebstruct_process_data;
/* timed event data structure */
typedef struct nebstruct_timed_event_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int event_type;
int recurring;
time_t run_time;
void *event_data;
void *event_ptr;
} nebstruct_timed_event_data;
/* log data structure */
typedef struct nebstruct_log_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
time_t entry_time;
int data_type;
char *data;
} nebstruct_log_data;
/* system command structure */
typedef struct nebstruct_system_command_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
struct timeval start_time;
struct timeval end_time;
int timeout;
char *command_line;
int early_timeout;
double execution_time;
int return_code;
char *output;
} nebstruct_system_command_data;
/* event handler structure */
typedef struct nebstruct_event_handler_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int eventhandler_type;
char *host_name;
char *service_description;
int state_type;
int state;
int timeout;
char *command_name;
char *command_args;
char *command_line;
struct timeval start_time;
struct timeval end_time;
int early_timeout;
double execution_time;
int return_code;
char *output;
void *object_ptr;
} nebstruct_event_handler_data;
/* host check structure */
typedef struct nebstruct_host_check_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
char *host_name;
int current_attempt;
int check_type;
int max_attempts;
int state_type;
int state;
int timeout;
char *command_name;
char *command_args;
char *command_line;
struct timeval start_time;
struct timeval end_time;
int early_timeout;
double execution_time;
double latency;
int return_code;
char *output;
char *long_output;
char *perf_data;
check_result *check_result_ptr;
void *object_ptr;
} nebstruct_host_check_data;
/* service check structure */
typedef struct nebstruct_service_check_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
char *host_name;
char *service_description;
int check_type;
int current_attempt;
int max_attempts;
int state_type;
int state;
int timeout;
char *command_name;
char *command_args;
char *command_line;
struct timeval start_time;
struct timeval end_time;
int early_timeout;
double execution_time;
double latency;
int return_code;
char *output;
char *long_output;
char *perf_data;
check_result *check_result_ptr;
void *object_ptr;
} nebstruct_service_check_data;
/* comment data structure */
typedef struct nebstruct_comment_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int comment_type;
char *host_name;
char *service_description;
time_t entry_time;
char *author_name;
char *comment_data;
int persistent;
int source;
int entry_type;
int expires;
time_t expire_time;
unsigned long comment_id;
void *object_ptr; /* not implemented yet */
} nebstruct_comment_data;
/* downtime data structure */
typedef struct nebstruct_downtime_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int downtime_type;
char *host_name;
char *service_description;
time_t entry_time;
char *author_name;
char *comment_data;
time_t start_time;
time_t end_time;
int fixed;
unsigned long duration;
unsigned long triggered_by;
unsigned long downtime_id;
void *object_ptr; /* not implemented yet */
} nebstruct_downtime_data;
/* flapping data structure */
typedef struct nebstruct_flapping_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int flapping_type;
char *host_name;
char *service_description;
double percent_change;
double high_threshold;
double low_threshold;
unsigned long comment_id;
void *object_ptr;
} nebstruct_flapping_data;
/* program status structure */
typedef struct nebstruct_program_status_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
time_t program_start;
int pid;
int daemon_mode;
time_t last_log_rotation;
int notifications_enabled;
int active_service_checks_enabled;
int passive_service_checks_enabled;
int active_host_checks_enabled;
int passive_host_checks_enabled;
int event_handlers_enabled;
int flap_detection_enabled;
int process_performance_data;
int obsess_over_hosts;
int obsess_over_services;
unsigned long modified_host_attributes;
unsigned long modified_service_attributes;
char *global_host_event_handler;
char *global_service_event_handler;
} nebstruct_program_status_data;
/* host status structure */
typedef struct nebstruct_host_status_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
void *object_ptr;
} nebstruct_host_status_data;
/* service status structure */
typedef struct nebstruct_service_status_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
void *object_ptr;
} nebstruct_service_status_data;
/* contact status structure */
typedef struct nebstruct_contact_status_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
void *object_ptr;
} nebstruct_contact_status_data;
/* notification data structure */
typedef struct nebstruct_notification_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int notification_type;
struct timeval start_time;
struct timeval end_time;
char *host_name;
char *service_description;
int reason_type;
int state;
char *output;
char *ack_author;
char *ack_data;
int escalated;
int contacts_notified;
void *object_ptr;
} nebstruct_notification_data;
/* contact notification data structure */
typedef struct nebstruct_contact_notification_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int notification_type;
struct timeval start_time;
struct timeval end_time;
char *host_name;
char *service_description;
char *contact_name;
int reason_type;
int state;
char *output;
char *ack_author;
char *ack_data;
int escalated;
void *object_ptr;
void *contact_ptr;
} nebstruct_contact_notification_data;
/* contact notification method data structure */
typedef struct nebstruct_contact_notification_method_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int notification_type;
struct timeval start_time;
struct timeval end_time;
char *host_name;
char *service_description;
char *contact_name;
char *command_name;
char *command_args;
int reason_type;
int state;
char *output;
char *ack_author;
char *ack_data;
int escalated;
void *object_ptr;
void *contact_ptr;
} nebstruct_contact_notification_method_data;
/* adaptive program data structure */
typedef struct nebstruct_adaptive_program_data_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int command_type;
unsigned long modified_host_attribute;
unsigned long modified_host_attributes;
unsigned long modified_service_attribute;
unsigned long modified_service_attributes;
} nebstruct_adaptive_program_data;
/* adaptive host data structure */
typedef struct nebstruct_adaptive_host_data_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int command_type;
unsigned long modified_attribute;
unsigned long modified_attributes;
void *object_ptr;
} nebstruct_adaptive_host_data;
/* adaptive service data structure */
typedef struct nebstruct_adaptive_service_data_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int command_type;
unsigned long modified_attribute;
unsigned long modified_attributes;
void *object_ptr;
} nebstruct_adaptive_service_data;
/* adaptive contact data structure */
typedef struct nebstruct_adaptive_contact_data_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int command_type;
unsigned long modified_attribute;
unsigned long modified_attributes;
unsigned long modified_host_attribute;
unsigned long modified_host_attributes;
unsigned long modified_service_attribute;
unsigned long modified_service_attributes;
void *object_ptr;
} nebstruct_adaptive_contact_data;
/* external command data structure */
typedef struct nebstruct_external_command_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int command_type;
time_t entry_time;
char *command_string;
char *command_args;
} nebstruct_external_command_data;
/* aggregated status data structure */
typedef struct nebstruct_aggregated_status_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
} nebstruct_aggregated_status_data;
/* retention data structure */
typedef struct nebstruct_retention_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
} nebstruct_retention_data;
/* acknowledgement structure */
typedef struct nebstruct_acknowledgement_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int acknowledgement_type;
char *host_name;
char *service_description;
int state;
char *author_name;
char *comment_data;
int is_sticky;
int persistent_comment;
int notify_contacts;
void *object_ptr;
} nebstruct_acknowledgement_data;
/* state change structure */
typedef struct nebstruct_statechange_struct {
int type;
int flags;
int attr;
struct timeval timestamp;
int statechange_type;
char *host_name;
char *service_description;
int state;
int state_type;
int current_attempt;
int max_attempts;
char *output;
void *object_ptr;
} nebstruct_statechange_data;
NAGIOS_END_DECL
#endif

76
nagios4/nsock.h Normal file
View File

@@ -0,0 +1,76 @@
#ifndef LIBNAGIOS_nsock_h__
#define LIBNAGIOS_nsock_h__
#include <errno.h>
/**
* @file nsock.h
* @brief Nagios socket helper library
*
* This is a pretty stupid library, but since so many addons and
* now Nagios core itself makes use of sockets, we might as well
* have some simple wrappers for it that handle the most common
* cases.
*
* @{
*/
#define NSOCK_EBIND (-1) /**< failed to bind() */
#define NSOCK_ELISTEN (-2) /**< failed to listen() */
#define NSOCK_ESOCKET (-3) /**< failed to socket() */
#define NSOCK_EUNLINK (-4) /**< failed to unlink() */
#define NSOCK_ECONNECT (-5) /**< failed to connect() */
#define NSOCK_EFCNTL (-6) /**< failed to fcntl() */
#define NSOCK_EINVAL (-EINVAL) /**< -22, normally */
/* flags for the various create calls */
#define NSOCK_TCP (1 << 0) /**< use tcp mode */
#define NSOCK_UDP (1 << 1) /**< use udp mode */
#define NSOCK_UNLINK (1 << 2) /**< unlink existing path (only nsock_unix) */
#define NSOCK_REUSE (1 << 2) /**< reuse existing address */
#define NSOCK_CONNECT (1 << 3) /**< connect rather than create */
#define NSOCK_BLOCK (1 << 4) /**< socket should be in blocking mode */
/**
* Grab an error string relating to nsock_unix()
* @param code The error code return by the nsock library
* @return An error string describing the error
*/
extern const char *nsock_strerror(int code);
/**
* Create or connect to a unix socket
* To control permissions on sockets when NSOCK_LISTEN is specified,
* callers will have to modify their umask() before (and possibly
* after) the nsock_unix() call.
*
* @param path The path to connect to or create
* @param flags Various options controlling the mode of the socket
* @return An NSOCK_E macro on errors, the created socket on succes
*/
extern int nsock_unix(const char *path, unsigned int flags);
/**
* Write a nul-terminated message to the socket pointed to by sd.
* This isn't quite the same as dprintf(), which doesn't include
* the terminating nul byte.
* @note This function may block, so poll(2) for writability
* @param sd The socket to write to
* @param fmt The format string
* @return Whatever write() returns
*/
extern int nsock_printf_nul(int sd, const char *fmt, ...)
__attribute__((__format__(__printf__, 2, 3)));
/**
* Write a printf()-formatted string to the socket pointed to by sd.
* This is identical to dprintf(), which is unfortunately GNU only.
* @note This function may block, so poll(2) for writability
* @param sd The socket to write to
* @param fmt The format string
* @return Whatever write() returns
*/
extern int nsock_printf(int sd, const char *fmt, ...)
__attribute__((__format__(__printf__, 2, 3)));
/** @} */
#endif /* LIBNAGIOS_nsock_h__ */

91
nagios4/nspath.h Normal file
View File

@@ -0,0 +1,91 @@
#ifndef LIBNAGIOS_nspath_h__
#define LIBNAGIOS_nspath_h__
#ifndef _GNU_SOURCE
# ifndef NODOXY
# define _GNU_SOURCE 1
# endif
#endif
#include <errno.h>
#include <sys/stat.h>
#include "snprintf.h"
/**
* @file nspath.h
* @brief path handling functions
*
* This library handles path normalization and resolution. It's nifty
* if you want to turn relative paths into absolute ones, or if you
* want to make insane ones sane, but without chdir()'ing your way
* around the filesystem.
*
* @{
*/
/**
* Normalize a path
* By "normalize", we mean that we convert dot-slash and dot-dot-slash
* embedded components into a legible continuous string of characters.
* Leading and trailing slashes are kept exactly as they are in input,
* but with sequences of slashes reduced to a single one.
*
* "foo/bar/.././lala.txt" becomes "foo/lala.txt"
* "../../../../bar/../foo/" becomes "/foo/"
* "////foo////././bar" becomes "/foo/bar"
* @param orig_path The path to normalize
* @return A newly allocated string containing the normalized path
*/
extern char *nspath_normalize(const char *orig_path);
/**
* Make the "base"-relative path "rel_path" absolute.
* Turns the relative path "rel_path" into an absolute path and
* resolves it as if we were currently in "base". If "base" is
* NULL, the current working directory is used. If "base" is not
* null, it should be an absolute path for the result to make
* sense.
*
* @param rel_path The relative path to convert
* @param base The base directory (if NULL, we use current working dir)
* @return A newly allocated string containing the absolute path
*/
extern char *nspath_absolute(const char *rel_path, const char *base);
/**
* Canonicalize the "base"-relative path "rel_path".
* errno gets properly set in case of errors.
* @param rel_path The path to transform
* @param base The base we should operate relative to
* @return Newly allocated canonical path on succes, NULL on errors
*/
extern char *nspath_real(const char *rel_path, const char *base);
/**
* Get absolute dirname of "path", relative to "base"
* @param path Full path to target object (file or subdir)
* @param base The base directory (if NULL, we use current working dir)
* @return NULL on errors, allocated absolute directory name on success
*/
extern char *nspath_absolute_dirname(const char *path, const char *base);
/**
* Recursively create a directory, just like mkdir_p would.
* @note This function *will* taint errno with ENOENT if any path
* component has to be created.
* @note If "path" has a trailing slash, NSPATH_MKDIR_SKIP_LAST
* won't have any effect. That's considered a feature, since the
* option is designed so one can send a file-path to the function
* and have it create the directory structure for it.
* @param path Path to create, in normalized form
* @param mode Filemode (same as mkdir() takes)
* @param options Options flag. See NSPATH_MKDIR_* for or-able options
* @return 0 on success, -1 on errors and errno will hold error code
* from either stat() or mkdir().
*/
extern int nspath_mkdir_p(const char *path, mode_t mode, int options);
/** Don't mkdir() last element of path when calling nspath_mkdir_p() */
#define NSPATH_MKDIR_SKIP_LAST (1 << 0)
/** @} */
#endif

111
nagios4/nsutils.h Normal file
View File

@@ -0,0 +1,111 @@
#ifndef LIBNAGIOS_nsutils_h__
#define LIBNAGIOS_nsutils_h__
#include <sys/types.h>
/**
* @file nsutils.h
* @brief Non-Standard (or Nagios) utility functions and macros.
*
* This is where we house all helpers and macros that fall outside
* the "standard-ish" norm. The prefixes "nsu_" and NSU_ are
* reserved for this purpose, so we avoid clashing with other
* applications that may have similarly-acting functions with
* identical names.
*
* The functions already here lack the nsu_ prefix for backwards
* compatibility reasons. It's possible we'll have to fix that
* some day, but let's leave that for later.
*
* @{
*/
/** Macro for dynamically increasing vector lengths */
#define alloc_nr(x) (((x)+16)*3/2)
/**
* Check if a number is a power of 2
* @param x The number to check
* @return 1 if the number is a power of 2, 0 if it's not
*/
static inline int nsu_ispow2(unsigned int x)
{
return x > 1 ? !(x & (x - 1)) : 0;
}
/**
* Round up to a power of 2
* Yes, this is the most cryptic function name in all of Nagios, but I
* like it, so shush.
* @param r The number to round up
* @return r, rounded up to the nearest power of 2.
*/
static inline unsigned int rup2pof2(unsigned int r)
{
r--;
if (!r)
return 2;
r |= r >> 1;
r |= r >> 2;
r |= r >> 4;
r |= r >> 8;
r |= r >> 16;
return r + 1;
}
/**
* Grab a random unsigned int in the range between low and high.
* Note that the PRNG has to be seeded prior to calling this.
* @param low The lower bound, inclusive
* @param high The higher bound, inclusive
* @return An unsigned integer in the mathematical range [low, high]
*/
static inline unsigned int ranged_urand(unsigned int low, unsigned int high)
{
return low + (rand() * (1.0 / (RAND_MAX + 1.0)) * (high - low));
}
/**
* Get number of online cpus
* @return Active cpu cores detected on success. 0 on failure.
*/
extern int real_online_cpus(void);
/**
* Wrapper for real_online_cpus(), returning 1 in case we can't
* detect any active cpus.
* @return Number of active cpu cores on success. 1 on failure.
*/
extern int online_cpus(void);
/**
* Create a short-lived string in stack-allocated memory
* The number and size of strings is limited (currently to 256 strings of
* 32 bytes each), so beware and use this sensibly. Intended for
* number-to-string conversion and other short strings.
* @note The returned string must *not* be free()'d!
* @param[in] fmt The format string
* @return A pointer to the formatted string on success. Undefined on errors
*/
extern const char *mkstr(const char *fmt, ...)
__attribute__((__format__(__printf__, 1, 2)));
/**
* Calculate the millisecond delta between two timeval structs
* @param[in] start The start time
* @param[in] stop The stop time
* @return The millisecond delta between the two structs
*/
extern int tv_delta_msec(const struct timeval *start, const struct timeval *stop);
/**
* Get timeval delta as seconds
* @param start The start time
* @param stop The stop time
* @return time difference in fractions of seconds
*/
extern float tv_delta_f(const struct timeval *start, const struct timeval *stop);
/** @} */
#endif /* LIBNAGIOS_nsutils_h__ */

853
nagios4/objects.h Normal file
View File

@@ -0,0 +1,853 @@
/*****************************************************************************
*
* OBJECTS.H - Header file for object addition/search functions
*
*
* 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.
*
*****************************************************************************/
#ifndef _OBJECTS_H
#define _OBJECTS_H
#include "common.h"
NAGIOS_BEGIN_DECL
/*************** CURRENT OBJECT REVISION **************/
#define CURRENT_OBJECT_STRUCTURE_VERSION 402 /* increment when changes are made to data structures... */
/* Nagios 3 starts at 300, Nagios 4 at 400, etc. */
/***************** OBJECT SIZE LIMITS *****************/
#define MAX_STATE_HISTORY_ENTRIES 21 /* max number of old states to keep track of for flap detection */
#define MAX_CONTACT_ADDRESSES 6 /* max number of custom addresses a contact can have */
/***************** SKIP LISTS ****************/
#define NUM_OBJECT_SKIPLISTS 12
#define NUM_HASHED_OBJECT_TYPES 8
#define HOST_SKIPLIST 0
#define SERVICE_SKIPLIST 1
#define COMMAND_SKIPLIST 2
#define TIMEPERIOD_SKIPLIST 3
#define CONTACT_SKIPLIST 4
#define CONTACTGROUP_SKIPLIST 5
#define HOSTGROUP_SKIPLIST 6
#define SERVICEGROUP_SKIPLIST 7
#define HOSTDEPENDENCY_SKIPLIST 8
#define SERVICEDEPENDENCY_SKIPLIST 9
#define HOSTESCALATION_SKIPLIST 10
#define SERVICEESCALATION_SKIPLIST 11
/***************** DATE RANGE TYPES *******************/
#define DATERANGE_CALENDAR_DATE 0 /* 2008-12-25 */
#define DATERANGE_MONTH_DATE 1 /* july 4 (specific month) */
#define DATERANGE_MONTH_DAY 2 /* day 21 (generic month) */
#define DATERANGE_MONTH_WEEK_DAY 3 /* 3rd thursday (specific month) */
#define DATERANGE_WEEK_DAY 4 /* 3rd thursday (generic month) */
#define DATERANGE_TYPES 5
/*
* flags for notification_options, flapping_options and other similar
* flags. They overlap (hosts and services), so we can't use enum's.
*/
#define OPT_NOTHING 0 /* no options selected */
#define OPT_ALL (~0) /* everything selected, so all bits set */
#define OPT_DOWN (1 << HOST_DOWN)
#define OPT_UP (1 << HOST_UP)
#define OPT_UNREACHABLE (1 << HOST_UNREACHABLE)
#define OPT_OK (1 << STATE_OK)
#define OPT_WARNING (1 << STATE_WARNING)
#define OPT_CRITICAL (1 << STATE_CRITICAL)
#define OPT_UNKNOWN (1 << STATE_UNKNOWN)
#define OPT_RECOVERY OPT_OK
/* and now the "unreal" states... */
#define OPT_PENDING (1 << 10)
#define OPT_FLAPPING (1 << 11)
#define OPT_DOWNTIME (1 << 12)
#define OPT_DISABLED (1 << 15) /* will denote disabled checks some day */
/* macros useful with both hosts and services */
#define flag_set(c, flag) ((c) |= (flag))
#define flag_get(c, flag) (unsigned int)((c) & (flag))
#define flag_isset(c, flag) (flag_get((c), (flag)) == (unsigned int)(flag))
#define flag_unset(c, flag) (c &= ~(flag))
#define should_stalk(o) flag_isset(o->stalking_options, 1 << o->current_state)
#define should_flap_detect(o) flag_isset(o->flap_detection_options, 1 << o->current_state)
#define should_notify(o) flag_isset(o->notification_options, 1 << o->current_state)
#define add_notified_on(o, f) (o->notified_on |= (1 << f))
/****************** DATA STRUCTURES *******************/
/* @todo Remove typedef's of non-opaque types in Nagios 5 */
typedef struct host host;
typedef struct service service;
typedef struct contact contact;
/* TIMED_EVENT structure */
typedef struct timed_event {
int event_type;
time_t run_time;
int recurring;
unsigned long event_interval;
int compensate_for_time_change;
void *timing_func;
void *event_data;
void *event_args;
int event_options;
unsigned int priority; /* 0 is auto, 1 is highest. n+1 < n */
struct squeue_event *sq_event;
} timed_event;
/* NOTIFY_LIST structure */
typedef struct notify_list {
struct contact *contact;
struct notify_list *next;
} notification;
/*
* *name can be "Nagios Core", "Merlin", "mod_gearman" or "DNX", fe.
* source_name gets passed the 'source' pointer from check_result
* and must return a non-free()'able string useful for printing what
* we need to determine exactly where the check was received from,
* such as "mod_gearman worker@10.11.12.13", or "Nagios Core command
* file worker" (for passive checks submitted locally), which will be
* stashed with hosts and services and used as the "CHECKSOURCE" macro.
*/
struct check_engine {
char *name; /* "Nagios Core", "Merlin", "Mod Gearman" fe */
const char *(*source_name)(void *);
void (*clean_result)(void *);
};
/* CHECK_RESULT structure */
typedef struct check_result {
int object_check_type; /* is this a service or a host check? */
char *host_name; /* host name */
char *service_description; /* service description */
int check_type; /* was this an active or passive service check? */
int check_options;
int scheduled_check; /* was this a scheduled or an on-demand check? */
int reschedule_check; /* should we reschedule the next check */
char *output_file; /* what file is the output stored in? */
FILE *output_file_fp;
double latency;
struct timeval start_time; /* time the service check was initiated */
struct timeval finish_time; /* time the service check was completed */
int early_timeout; /* did the service check timeout? */
int exited_ok; /* did the plugin check return okay? */
int return_code; /* plugin return code */
char *output; /* plugin output */
struct rusage rusage; /* resource usage by this check */
struct check_engine *engine; /* where did we get this check from? */
void *source; /* engine handles this */
} check_result;
/* SCHED_INFO structure */
typedef struct sched_info {
int total_services;
int total_scheduled_services;
int total_hosts;
int total_scheduled_hosts;
double average_services_per_host;
double average_scheduled_services_per_host;
unsigned long service_check_interval_total;
unsigned long host_check_interval_total;
double average_service_execution_time;
double average_service_check_interval;
double average_host_check_interval;
double average_service_inter_check_delay;
double average_host_inter_check_delay;
double service_inter_check_delay;
double host_inter_check_delay;
int service_interleave_factor;
int max_service_check_spread;
int max_host_check_spread;
time_t first_service_check;
time_t last_service_check;
time_t first_host_check;
time_t last_host_check;
} sched_info;
/* DBUF structure - dynamic string storage */
typedef struct dbuf {
char *buf;
unsigned long used_size;
unsigned long allocated_size;
unsigned long chunk_size;
} dbuf;
#define CHECK_STATS_BUCKETS 15
/* used for tracking host and service check statistics */
typedef struct check_stats {
int current_bucket;
int bucket[CHECK_STATS_BUCKETS];
int overflow_bucket;
int minute_stats[3];
time_t last_update;
} check_stats;
/* OBJECT LIST STRUCTURE */
typedef struct objectlist {
void *object_ptr;
struct objectlist *next;
} objectlist;
/* TIMERANGE structure */
typedef struct timerange {
unsigned long range_start;
unsigned long range_end;
struct timerange *next;
} timerange;
/* DATERANGE structure */
typedef struct daterange {
int type;
int syear; /* start year */
int smon; /* start month */
int smday; /* start day of month (may 3rd, last day in feb) */
int swday; /* start day of week (thursday) */
int swday_offset; /* start weekday offset (3rd thursday, last monday in jan) */
int eyear;
int emon;
int emday;
int ewday;
int ewday_offset;
int skip_interval;
struct timerange *times;
struct daterange *next;
} daterange;
/* TIMEPERIODEXCLUSION structure */
typedef struct timeperiodexclusion {
char *timeperiod_name;
struct timeperiod *timeperiod_ptr;
struct timeperiodexclusion *next;
} timeperiodexclusion;
/* TIMEPERIOD structure */
typedef struct timeperiod {
unsigned int id;
char *name;
char *alias;
struct timerange *days[7];
struct daterange *exceptions[DATERANGE_TYPES];
struct timeperiodexclusion *exclusions;
struct timeperiod *next;
} timeperiod;
/* CONTACTSMEMBER structure */
typedef struct contactsmember {
char *contact_name;
struct contact *contact_ptr;
struct contactsmember *next;
} contactsmember;
/* CONTACTGROUP structure */
typedef struct contactgroup {
unsigned int id;
char *group_name;
char *alias;
struct contactsmember *members;
struct contactgroup *next;
} contactgroup;
/* CONTACTGROUPSMEMBER structure */
typedef struct contactgroupsmember {
char *group_name;
struct contactgroup *group_ptr;
struct contactgroupsmember *next;
} contactgroupsmember;
/* CUSTOMVARIABLESMEMBER structure */
typedef struct customvariablesmember {
char *variable_name;
char *variable_value;
int has_been_modified;
struct customvariablesmember *next;
} customvariablesmember;
/* COMMAND structure */
typedef struct command {
unsigned int id;
char *name;
char *command_line;
struct command *next;
} command;
/* COMMANDSMEMBER structure */
typedef struct commandsmember {
char *command;
struct command *command_ptr;
struct commandsmember *next;
} commandsmember;
/* CONTACT structure */
struct contact {
unsigned int id;
char *name;
char *alias;
char *email;
char *pager;
char *address[MAX_CONTACT_ADDRESSES];
struct commandsmember *host_notification_commands;
struct commandsmember *service_notification_commands;
unsigned int host_notification_options;
unsigned int service_notification_options;
unsigned int minimum_value;
char *host_notification_period;
char *service_notification_period;
int host_notifications_enabled;
int service_notifications_enabled;
int can_submit_commands;
int retain_status_information;
int retain_nonstatus_information;
struct customvariablesmember *custom_variables;
#ifndef NSCGI
time_t last_host_notification;
time_t last_service_notification;
unsigned long modified_attributes;
unsigned long modified_host_attributes;
unsigned long modified_service_attributes;
#endif
struct timeperiod *host_notification_period_ptr;
struct timeperiod *service_notification_period_ptr;
struct objectlist *contactgroups_ptr;
struct contact *next;
};
/* SERVICESMEMBER structure */
typedef struct servicesmember {
char *host_name;
char *service_description;
struct service *service_ptr;
struct servicesmember *next;
} servicesmember;
/* HOSTSMEMBER structure */
typedef struct hostsmember {
char *host_name;
struct host *host_ptr;
struct hostsmember *next;
} hostsmember;
/* HOSTGROUP structure */
typedef struct hostgroup {
unsigned int id;
char *group_name;
char *alias;
struct hostsmember *members;
char *notes;
char *notes_url;
char *action_url;
struct hostgroup *next;
} hostgroup;
/* HOST structure */
struct host {
unsigned int id;
char *name;
char *display_name;
char *alias;
char *address;
struct hostsmember *parent_hosts;
struct hostsmember *child_hosts;
struct servicesmember *services;
char *check_command;
int initial_state;
double check_interval;
double retry_interval;
int max_attempts;
char *event_handler;
struct contactgroupsmember *contact_groups;
struct contactsmember *contacts;
double notification_interval;
double first_notification_delay;
unsigned int notification_options;
unsigned int hourly_value;
char *notification_period;
char *check_period;
int flap_detection_enabled;
double low_flap_threshold;
double high_flap_threshold;
int flap_detection_options;
unsigned int stalking_options;
int check_freshness;
int freshness_threshold;
int process_performance_data;
int checks_enabled;
const char *check_source;
int accept_passive_checks;
int event_handler_enabled;
int retain_status_information;
int retain_nonstatus_information;
int obsess;
char *notes;
char *notes_url;
char *action_url;
char *icon_image;
char *icon_image_alt;
char *statusmap_image; /* used by lots of graphing tools */
/* #ifdef NSCGI */
/*
* these are kept in ancillary storage for the daemon and
* thrown out as soon as we've created the object cache.
* The CGI's still attach them though, since they are the
* only users of this utter crap.
*/
char *vrml_image;
int have_2d_coords;
int x_2d;
int y_2d;
int have_3d_coords;
double x_3d;
double y_3d;
double z_3d;
int should_be_drawn;
/* #endif */
customvariablesmember *custom_variables;
#ifndef NSCGI
int problem_has_been_acknowledged;
int acknowledgement_type;
int check_type;
int current_state;
int last_state;
int last_hard_state;
char *plugin_output;
char *long_plugin_output;
char *perf_data;
int state_type;
int current_attempt;
unsigned long current_event_id;
unsigned long last_event_id;
unsigned long current_problem_id;
unsigned long last_problem_id;
double latency;
double execution_time;
int is_executing;
int check_options;
int notifications_enabled;
time_t last_notification;
time_t next_notification;
time_t next_check;
int should_be_scheduled;
time_t last_check;
time_t last_state_change;
time_t last_hard_state_change;
time_t last_time_up;
time_t last_time_down;
time_t last_time_unreachable;
int has_been_checked;
int is_being_freshened;
int notified_on;
int current_notification_number;
int no_more_notifications;
unsigned long current_notification_id;
int check_flapping_recovery_notification;
int scheduled_downtime_depth;
int pending_flex_downtime;
int state_history[MAX_STATE_HISTORY_ENTRIES]; /* flap detection */
int state_history_index;
time_t last_state_history_update;
int is_flapping;
unsigned long flapping_comment_id;
double percent_state_change;
int total_services;
unsigned long total_service_check_interval;
unsigned long modified_attributes;
#endif
struct command *event_handler_ptr;
struct command *check_command_ptr;
struct timeperiod *check_period_ptr;
struct timeperiod *notification_period_ptr;
struct objectlist *hostgroups_ptr;
/* objects we depend upon */
struct objectlist *exec_deps, *notify_deps;
struct objectlist *escalation_list;
struct host *next;
struct timed_event *next_check_event;
};
/* SERVICEGROUP structure */
typedef struct servicegroup {
unsigned int id;
char *group_name;
char *alias;
struct servicesmember *members;
char *notes;
char *notes_url;
char *action_url;
struct servicegroup *next;
} servicegroup;
/* SERVICE structure */
struct service {
unsigned int id;
char *host_name;
char *description;
char *display_name;
struct servicesmember *parents;
struct servicesmember *children;
char *check_command;
char *event_handler;
int initial_state;
double check_interval;
double retry_interval;
int max_attempts;
int parallelize;
struct contactgroupsmember *contact_groups;
struct contactsmember *contacts;
double notification_interval;
double first_notification_delay;
unsigned int notification_options;
unsigned int stalking_options;
unsigned int hourly_value;
int is_volatile;
char *notification_period;
char *check_period;
int flap_detection_enabled;
double low_flap_threshold;
double high_flap_threshold;
unsigned int flap_detection_options;
int process_performance_data;
int check_freshness;
int freshness_threshold;
int accept_passive_checks;
int event_handler_enabled;
int checks_enabled;
const char *check_source;
int retain_status_information;
int retain_nonstatus_information;
int notifications_enabled;
int obsess;
char *notes;
char *notes_url;
char *action_url;
char *icon_image;
char *icon_image_alt;
struct customvariablesmember *custom_variables;
#ifndef NSCGI
int problem_has_been_acknowledged;
int acknowledgement_type;
int host_problem_at_last_check;
int check_type;
int current_state;
int last_state;
int last_hard_state;
char *plugin_output;
char *long_plugin_output;
char *perf_data;
int state_type;
time_t next_check;
int should_be_scheduled;
time_t last_check;
int current_attempt;
unsigned long current_event_id;
unsigned long last_event_id;
unsigned long current_problem_id;
unsigned long last_problem_id;
time_t last_notification;
time_t next_notification;
int no_more_notifications;
int check_flapping_recovery_notification;
time_t last_state_change;
time_t last_hard_state_change;
time_t last_time_ok;
time_t last_time_warning;
time_t last_time_unknown;
time_t last_time_critical;
int has_been_checked;
int is_being_freshened;
unsigned int notified_on;
int current_notification_number;
unsigned long current_notification_id;
double latency;
double execution_time;
int is_executing;
int check_options;
int scheduled_downtime_depth;
int pending_flex_downtime;
int state_history[MAX_STATE_HISTORY_ENTRIES]; /* flap detection */
int state_history_index;
int is_flapping;
unsigned long flapping_comment_id;
double percent_state_change;
unsigned long modified_attributes;
#endif
struct host *host_ptr;
struct command *event_handler_ptr;
char *event_handler_args;
struct command *check_command_ptr;
char *check_command_args;
struct timeperiod *check_period_ptr;
struct timeperiod *notification_period_ptr;
struct objectlist *servicegroups_ptr;
struct objectlist *exec_deps, *notify_deps;
struct objectlist *escalation_list;
struct service *next;
struct timed_event *next_check_event;
};
/* SERVICE ESCALATION structure */
typedef struct serviceescalation {
unsigned int id;
char *host_name;
char *description;
int first_notification;
int last_notification;
double notification_interval;
char *escalation_period;
int escalation_options;
struct contactgroupsmember *contact_groups;
struct contactsmember *contacts;
struct service *service_ptr;
struct timeperiod *escalation_period_ptr;
} serviceescalation;
/* SERVICE DEPENDENCY structure */
typedef struct servicedependency {
unsigned int id;
int dependency_type;
char *dependent_host_name;
char *dependent_service_description;
char *host_name;
char *service_description;
char *dependency_period;
int inherits_parent;
int failure_options;
struct service *master_service_ptr;
struct service *dependent_service_ptr;
struct timeperiod *dependency_period_ptr;
} servicedependency;
/* HOST ESCALATION structure */
typedef struct hostescalation {
unsigned int id;
char *host_name;
int first_notification;
int last_notification;
double notification_interval;
char *escalation_period;
int escalation_options;
struct contactgroupsmember *contact_groups;
struct contactsmember *contacts;
struct host *host_ptr;
struct timeperiod *escalation_period_ptr;
} hostescalation;
/* HOST DEPENDENCY structure */
typedef struct hostdependency {
unsigned int id;
int dependency_type;
char *dependent_host_name;
char *host_name;
char *dependency_period;
int inherits_parent;
int failure_options;
struct host *master_host_ptr;
struct host *dependent_host_ptr;
struct timeperiod *dependency_period_ptr;
} hostdependency;
extern struct command *command_list;
extern struct timeperiod *timeperiod_list;
extern struct host *host_list;
extern struct service *service_list;
extern struct contact *contact_list;
extern struct hostgroup *hostgroup_list;
extern struct servicegroup *servicegroup_list;
extern struct contactgroup *contactgroup_list;
extern struct hostescalation *hostescalation_list;
extern struct serviceescalation *serviceescalation_list;
extern struct command **command_ary;
extern struct timeperiod **timeperiod_ary;
extern struct host **host_ary;
extern struct service **service_ary;
extern struct contact **contact_ary;
extern struct hostgroup **hostgroup_ary;
extern struct servicegroup **servicegroup_ary;
extern struct contactgroup **contactgroup_ary;
extern struct hostescalation **hostescalation_ary;
extern struct hostdependency **hostdependency_ary;
extern struct serviceescalation **serviceescalation_ary;
extern struct servicedependency **servicedependency_ary;
/********************* FUNCTIONS **********************/
/**** Top-level input functions ****/
int read_object_config_data(const char *, int); /* reads all external configuration data of specific types */
/**** Object Creation Functions ****/
struct contact *add_contact(char *name, char *alias, char *email, char *pager, char **addresses, char *svc_notification_period, char *host_notification_period, int service_notification_options, int host_notification_options, int service_notifications_enabled, int host_notifications_enabled, int can_submit_commands, int retain_status_information, int retain_nonstatus_information, unsigned int minimum_value);
struct commandsmember *add_service_notification_command_to_contact(contact *, char *); /* adds a service notification command to a contact definition */
struct commandsmember *add_host_notification_command_to_contact(contact *, char *); /* adds a host notification command to a contact definition */
struct customvariablesmember *add_custom_variable_to_contact(contact *, char *, char *); /* adds a custom variable to a service definition */
struct host *add_host(char *name, char *display_name, char *alias, char *address, char *check_period, int initial_state, double check_interval, double retry_interval, int max_attempts, int notification_options, double notification_interval, double first_notification_delay, char *notification_period, int notifications_enabled, char *check_command, int checks_enabled, int accept_passive_checks, char *event_handler, int event_handler_enabled, int flap_detection_enabled, double low_flap_threshold, double high_flap_threshold, int flap_detection_options, int stalking_options, int process_perfdata, int check_freshness, int freshness_threshold, char *notes, char *notes_url, char *action_url, char *icon_image, char *icon_image_alt, char *vrml_image, char *statusmap_image, int x_2d, int y_2d, int have_2d_coords, double x_3d, double y_3d, double z_3d, int have_3d_coords, int should_be_drawn, int retain_status_information, int retain_nonstatus_information, int obsess_over_host, unsigned int hourly_value);
struct hostsmember *add_parent_host_to_host(host *, char *); /* adds a parent host to a host definition */
struct servicesmember *add_parent_service_to_service(service *, char *host_name, char *description);
struct hostsmember *add_child_link_to_host(host *, host *); /* adds a child host to a host definition */
struct contactgroupsmember *add_contactgroup_to_host(host *, char *); /* adds a contactgroup to a host definition */
struct contactsmember *add_contact_to_host(host *, char *); /* adds a contact to a host definition */
struct customvariablesmember *add_custom_variable_to_host(host *, char *, char *); /* adds a custom variable to a host definition */
struct timeperiod *add_timeperiod(char *, char *); /* adds a timeperiod definition */
struct timeperiodexclusion *add_exclusion_to_timeperiod(timeperiod *, char *); /* adds an exclusion to a timeperiod */
struct timerange *add_timerange_to_timeperiod(timeperiod *, int, unsigned long, unsigned long); /* adds a timerange to a timeperiod definition */
struct daterange *add_exception_to_timeperiod(timeperiod *, int, int, int, int, int, int, int, int, int, int, int, int);
struct timerange *add_timerange_to_daterange(daterange *, unsigned long, unsigned long);
struct hostgroup *add_hostgroup(char *, char *, char *, char *, char *); /* adds a hostgroup definition */
struct hostsmember *add_host_to_hostgroup(hostgroup *, char *); /* adds a host to a hostgroup definition */
struct servicegroup *add_servicegroup(char *, char *, char *, char *, char *); /* adds a servicegroup definition */
struct servicesmember *add_service_to_servicegroup(servicegroup *, char *, char *); /* adds a service to a servicegroup definition */
struct contactgroup *add_contactgroup(char *, char *); /* adds a contactgroup definition */
struct contactsmember *add_contact_to_contactgroup(contactgroup *, char *); /* adds a contact to a contact group definition */
struct command *add_command(char *, char *); /* adds a command definition */
struct service *add_service(char *host_name, char *description, char *display_name, char *check_period, int initial_state, int max_attempts, int parallelize, int accept_passive_checks, double check_interval, double retry_interval, double notification_interval, double first_notification_delay, char *notification_period, int notification_options, int notifications_enabled, int is_volatile, char *event_handler, int event_handler_enabled, char *check_command, int checks_enabled, int flap_detection_enabled, double low_flap_threshold, double high_flap_threshold, int flap_detection_options, int stalking_options, int process_perfdata, int check_freshness, int freshness_threshold, char *notes, char *notes_url, char *action_url, char *icon_image, char *icon_image_alt, int retain_status_information, int retain_nonstatus_information, int obsess_over_service, unsigned int hourly_value);
struct contactgroupsmember *add_contactgroup_to_service(service *, char *); /* adds a contact group to a service definition */
struct contactsmember *add_contact_to_service(service *, char *); /* adds a contact to a host definition */
struct serviceescalation *add_serviceescalation(char *host_name, char *description, int first_notification, int last_notification, double notification_interval, char *escalation_period, int escalation_options);
struct contactgroupsmember *add_contactgroup_to_serviceescalation(serviceescalation *, char *); /* adds a contact group to a service escalation definition */
struct contactsmember *add_contact_to_serviceescalation(serviceescalation *, char *); /* adds a contact to a service escalation definition */
struct customvariablesmember *add_custom_variable_to_service(service *, char *, char *); /* adds a custom variable to a service definition */
struct servicedependency *add_service_dependency(char *dependent_host_name, char *dependent_service_description, char *host_name, char *service_description, int dependency_type, int inherits_parent, int failure_options, char *dependency_period);
struct hostdependency *add_host_dependency(char *dependent_host_name, char *host_name, int dependency_type, int inherits_parent, int failure_options, char *dependency_period);
struct hostescalation *add_hostescalation(char *host_name, int first_notification, int last_notification, double notification_interval, char *escalation_period, int escalation_options);
struct contactsmember *add_contact_to_hostescalation(hostescalation *, char *); /* adds a contact to a host escalation definition */
struct contactgroupsmember *add_contactgroup_to_hostescalation(hostescalation *, char *); /* adds a contact group to a host escalation definition */
struct contactsmember *add_contact_to_object(contactsmember **, char *); /* adds a contact to an object */
struct customvariablesmember *add_custom_variable_to_object(customvariablesmember **, char *, char *); /* adds a custom variable to an object */
struct servicesmember *add_service_link_to_host(host *, service *);
int skiplist_compare_text(const char *val1a, const char *val1b, const char *val2a, const char *val2b);
int get_host_count(void);
int get_service_count(void);
int create_object_tables(unsigned int *);
/**** Object Search Functions ****/
struct timeperiod *find_timeperiod(const char *);
struct host *find_host(const char *);
struct hostgroup *find_hostgroup(const char *);
struct servicegroup *find_servicegroup(const char *);
struct contact *find_contact(const char *);
struct contactgroup *find_contactgroup(const char *);
struct command *find_command(const char *);
struct service *find_service(const char *, const char *);
#define OBJECTLIST_DUPE 1
int add_object_to_objectlist(struct objectlist **, void *);
int prepend_object_to_objectlist(struct objectlist **, void *);
int prepend_unique_object_to_objectlist(struct objectlist **, void *, size_t size);
int free_objectlist(objectlist **);
/**** Object Query Functions ****/
unsigned int host_services_value(struct host *h);
int is_host_immediate_child_of_host(struct host *, struct host *); /* checks if a host is an immediate child of another host */
int is_host_primary_immediate_child_of_host(struct host *, struct host *); /* checks if a host is an immediate child (and primary child) of another host */
int is_host_immediate_parent_of_host(struct host *, struct host *); /* checks if a host is an immediate child of another host */
int is_host_member_of_hostgroup(struct hostgroup *, struct host *); /* tests whether or not a host is a member of a specific hostgroup */
int is_host_member_of_servicegroup(struct servicegroup *, struct host *); /* tests whether or not a service is a member of a specific servicegroup */
int is_service_member_of_servicegroup(struct servicegroup *, struct service *); /* tests whether or not a service is a member of a specific servicegroup */
int is_contact_member_of_contactgroup(struct contactgroup *, struct contact *); /* tests whether or not a contact is a member of a specific contact group */
int is_contact_for_host(struct host *, struct contact *); /* tests whether or not a contact is a contact member for a specific host */
int is_escalated_contact_for_host(struct host *, struct contact *); /* checks whether or not a contact is an escalated contact for a specific host */
int is_contact_for_service(struct service *, struct contact *); /* tests whether or not a contact is a contact member for a specific service */
int is_escalated_contact_for_service(struct service *, struct contact *); /* checks whether or not a contact is an escalated contact for a specific service */
int number_of_immediate_child_hosts(struct host *); /* counts the number of immediate child hosts for a particular host */
int number_of_total_child_hosts(struct host *); /* counts the number of total child hosts for a particular host */
int number_of_immediate_parent_hosts(struct host *); /* counts the number of immediate parents hosts for a particular host */
#ifndef NSCGI
void fcache_contactlist(FILE *fp, const char *prefix, struct contactsmember *list);
void fcache_contactgrouplist(FILE *fp, const char *prefix, struct contactgroupsmember *list);
void fcache_hostlist(FILE *fp, const char *prefix, struct hostsmember *list);
void fcache_customvars(FILE *fp, struct customvariablesmember *cvlist);
void fcache_timeperiod(FILE *fp, struct timeperiod *temp_timeperiod);
void fcache_command(FILE *fp, struct command *temp_command);
void fcache_contactgroup(FILE *fp, struct contactgroup *temp_contactgroup);
void fcache_hostgroup(FILE *fp, struct hostgroup *temp_hostgroup);
void fcache_servicegroup(FILE *fp, struct servicegroup *temp_servicegroup);
void fcache_contact(FILE *fp, struct contact *temp_contact);
void fcache_host(FILE *fp, struct host *temp_host);
void fcache_service(FILE *fp, struct service *temp_service);
void fcache_servicedependency(FILE *fp, struct servicedependency *temp_servicedependency);
void fcache_serviceescalation(FILE *fp, struct serviceescalation *temp_serviceescalation);
void fcache_hostdependency(FILE *fp, struct hostdependency *temp_hostdependency);
void fcache_hostescalation(FILE *fp, struct hostescalation *temp_hostescalation);
int fcache_objects(char *cache_file);
#endif
/**** Object Cleanup Functions ****/
int free_object_data(void); /* frees all allocated memory for the object definitions */
NAGIOS_END_DECL
#endif

38
nagios4/perfdata.h Normal file
View File

@@ -0,0 +1,38 @@
/*****************************************************************************
*
* PERFDATA.H - Include file for performance data routines
*
*
* 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.
*
*****************************************************************************/
#ifndef _PERFDATA_H
#define _PERFDATA_H
#include "common.h"
#include "objects.h"
NAGIOS_BEGIN_DECL
int initialize_performance_data(const char *); /* initializes performance data */
int cleanup_performance_data(void); /* cleans up performance data */
int update_host_performance_data(host *); /* updates host performance data */
int update_service_performance_data(service *); /* updates service performance data */
NAGIOS_END_DECL
#endif

185
nagios4/pqueue.h Normal file
View File

@@ -0,0 +1,185 @@
/*
* Copyright 2010 Volkan Yazıcı <volkan.yazici@gmail.com>
* Copyright 2006-2010 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
#ifndef LIBNAGIOS_pqueue_h__
#define LIBNAGIOS_pqueue_h__
#include <stdio.h>
/**
* @file pqueue.h
* @brief Priority Queue function declarations
*
* This priority queue library was originally written by Volkan Yazici
* <volkan.yazici@gmail.com>. It was lated adapted for Nagios by
* Andreas Ericsson <ae@op5.se>. Changes compared to the original
* version are pretty much limited to changing pqueue_pri_t to be
* an unsigned long long instead of a double, since ULL comparisons
* are 107 times faster on my 64-bit laptop.
*
* @{
*/
/** priority data type (used to be double, but ull is 107 times faster) */
typedef unsigned long long pqueue_pri_t;
/** callback functions to get/set/compare the priority of an element */
typedef pqueue_pri_t (*pqueue_get_pri_f)(void *a);
typedef void (*pqueue_set_pri_f)(void *a, pqueue_pri_t pri);
typedef int (*pqueue_cmp_pri_f)(pqueue_pri_t next, pqueue_pri_t curr);
/** callback functions to get/set the position of an element */
typedef unsigned int (*pqueue_get_pos_f)(void *a);
typedef void (*pqueue_set_pos_f)(void *a, unsigned int pos);
/** debug callback function to print a entry */
typedef void (*pqueue_print_entry_f)(FILE *out, void *a);
/** the priority queue handle */
typedef struct pqueue_t
{
unsigned int size; /**< number of elements in this queue */
unsigned int avail; /**< slots available in this queue */
unsigned int step; /**< growth stepping setting */
pqueue_cmp_pri_f cmppri; /**< callback to compare nodes */
pqueue_get_pri_f getpri; /**< callback to get priority of a node */
pqueue_set_pri_f setpri; /**< callback to set priority of a node */
pqueue_get_pos_f getpos; /**< callback to get position of a node */
pqueue_set_pos_f setpos; /**< callback to set position of a node */
void **d; /**< The actualy queue in binary heap form */
} pqueue_t;
/**
* initialize the queue
*
* @param n the initial estimate of the number of queue items for which memory
* should be preallocated
* @param cmppri The callback function to run to compare two elements
* This callback should return 0 for 'lower' and non-zero
* for 'higher', or vice versa if reverse priority is desired
* @param setpri the callback function to run to assign a score to an element
* @param getpri the callback function to run to set a score to an element
* @param getpos the callback function to get the current element's position
* @param setpos the callback function to set the current element's position
*
* @return the handle or NULL for insufficent memory
*/
pqueue_t *
pqueue_init(unsigned int n,
pqueue_cmp_pri_f cmppri,
pqueue_get_pri_f getpri,
pqueue_set_pri_f setpri,
pqueue_get_pos_f getpos,
pqueue_set_pos_f setpos);
/**
* free all memory used by the queue
* @param q the queue
*/
void pqueue_free(pqueue_t *q);
/**
* return the size of the queue.
* @param q the queue
*/
unsigned int pqueue_size(pqueue_t *q);
/**
* insert an item into the queue.
* @param q the queue
* @param d the item
* @return 0 on success
*/
int pqueue_insert(pqueue_t *q, void *d);
/**
* move an existing entry to a different priority
* @param q the queue
* @param new_pri the new priority
* @param d the entry
*/
void
pqueue_change_priority(pqueue_t *q,
pqueue_pri_t new_pri,
void *d);
/**
* pop the highest-ranking item from the queue.
* @param q the queue
* @return NULL on error, otherwise the entry
*/
void *pqueue_pop(pqueue_t *q);
/**
* remove an item from the queue.
* @param q the queue
* @param d the entry
* @return 0 on success
*/
int pqueue_remove(pqueue_t *q, void *d);
/**
* access highest-ranking item without removing it.
* @param q the queue
* @return NULL on error, otherwise the entry
*/
void *pqueue_peek(pqueue_t *q);
/**
* print the queue
* @internal
* DEBUG function only
* @param q the queue
* @param out the output handle
* @param the callback function to print the entry
*/
void
pqueue_print(pqueue_t *q, FILE *out, pqueue_print_entry_f print);
/**
* dump the queue and it's internal structure
* @internal
* debug function only
* @param q the queue
* @param out the output handle
* @param the callback function to print the entry
*/
void pqueue_dump(pqueue_t *q, FILE *out, pqueue_print_entry_f print);
/**
* checks that the pq is in the right order, etc
* @internal
* debug function only
* @param q the queue
*/
int pqueue_is_valid(pqueue_t *q);
#endif
/** @} */

96
nagios4/runcmd.h Normal file
View File

@@ -0,0 +1,96 @@
#ifndef LIBNAGIOS_runcmd_h__
#define LIBNAGIOS_runcmd_h__
#include <signal.h>
/**
* @file runcmd.h
* @brief runcmd library function declarations
*
* @note This is inherited from the nagiosplugins project, although
* I (AE) wrote the original code, and it might need refactoring
* for performance later.
* @{
*/
/** Return code bitflags for runcmd_cmd2strv() */
#define RUNCMD_HAS_REDIR (1 << 0) /**< I/O redirection */
#define RUNCMD_HAS_SUBCOMMAND (1 << 1) /**< subcommands present */
#define RUNCMD_HAS_PAREN (1 << 2) /**< parentheses present in command */
#define RUNCMD_HAS_JOBCONTROL (1 << 3) /**< job control stuff present */
#define RUNCMD_HAS_UBSQ (1 << 4) /**< unbalanced single quotes */
#define RUNCMD_HAS_UBDQ (1 << 5) /**< unbalanced double quotes */
#define RUNCMD_HAS_WILDCARD (1 << 6) /**< wildcards present */
#define RUNCMD_HAS_SHVAR (1 << 7) /**< shell variables present */
#define RUNCMD_EFD (-1) /**< Failed to pipe() or open() */
#define RUNCMD_EALLOC (-2) /**< Failed to alloc */
#define RUNCMD_ECMD (-3) /**< Bad command */
#define RUNCMD_EFORK (-4) /**< Failed to fork() */
#define RUNCMD_EINVAL (-5) /**< Invalid parameters */
#define RUNCMD_EWAIT (-6) /**< Failed to wait() */
/**
* Initialize the runcmd library.
*
* Only multi-threaded programs that might launch the first external
* program from multiple threads simultaneously need to bother with
* this.
*/
extern void runcmd_init(void);
/**
* Return pid of a command with a specific file descriptor
* @param[in] fd stdout filedescriptor of the child to get pid from
* @return pid of the child, or 0 on errors
*/
extern pid_t runcmd_pid(int fd);
/**
* Return explanation of which system call or operation failed
* @param code Error code returned by a library function
* @return A non-free()'able string explaining where the error occurred
*/
extern const char *runcmd_strerror(int code);
/**
* Start a command from a command string
* @param[in] cmdstring The command to launch
* @param[out] pfd Child's stdout filedescriptor
* @param[out] pfderr Child's stderr filedescriptor
* @param[in] env Currently ignored for portability
* @param[in] iobreg The callback function to register the iobrokers for the read ends of the pipe
* @param[in] iobregarg The "arg" value to pass to iobroker_register()
*/
extern int runcmd_open(const char *cmd, int *pfd, int *pfderr, char **env,
void (*iobreg)(int, int, void *), void *iobregarg)
__attribute__((__nonnull__(1, 2, 3, 5, 6)));
/**
* Close a command and return its exit status
* @note Don't use this. It's a retarded way to reap children suitable
* only for launching a one-shot program.
*
* @param[in] fd The child's stdout filedescriptor
* @return exit-status of the child, or -1 in case of errors
*/
extern int runcmd_close(int fd);
/**
* Convert a string to a vector of arguments like a shell would
* @note This might have bugs and is only tested to behave similar
* to how /bin/sh does things. For csh or other non bash-ish shells
* there are no guarantees.
* @note The out_argv array has to be large enough to hold all strings
* found in the command.
* @param[in] str The string to convert to an argument vector
* @param[out] out_argc The number of arguments found
* @param[out] out_argv The argument vector
* @return 0 on (great) success, or a bitmask of failure-codes
* representing f.e. unclosed quotes, job control or output redirection.
* See the RUNCMD_HAS_* and their ilk to find out about the flag.
*/
extern int runcmd_cmd2strv(const char *str, int *out_argc, char **out_argv);
#endif /* INCLUDE_runcmd_h__ */
/** @} */

55
nagios4/shared.h Normal file
View File

@@ -0,0 +1,55 @@
#ifndef INCLUDE__shared_h__
#define INCLUDE__shared_h__
#include <time.h>
#include "libnagios.h"
NAGIOS_BEGIN_DECL
/* mmapfile structure - used for reading files via mmap() */
typedef struct mmapfile_struct {
char *path;
int mode;
int fd;
unsigned long file_size;
unsigned long current_position;
unsigned long current_line;
void *mmap_buf;
} mmapfile;
/* official count of first-class objects */
struct object_count {
unsigned int commands;
unsigned int timeperiods;
unsigned int hosts;
unsigned int hostescalations;
unsigned int hostdependencies;
unsigned int services;
unsigned int serviceescalations;
unsigned int servicedependencies;
unsigned int contacts;
unsigned int contactgroups;
unsigned int hostgroups;
unsigned int servicegroups;
};
extern struct object_count num_objects;
extern void timing_point(const char *fmt, ...); /* print a message and the time since the first message */
extern char *my_strtok(char *buffer, const char *tokens);
extern char *my_strsep(char **stringp, const char *delim);
extern mmapfile *mmap_fopen(const char *filename);
extern int mmap_fclose(mmapfile *temp_mmapfile);
extern char *mmap_fgets(mmapfile *temp_mmapfile);
extern char *mmap_fgets_multiline(mmapfile * temp_mmapfile);
extern void strip(char *buffer);
extern int hashfunc(const char *name1, const char *name2, int hashslots);
extern int compare_hashdata(const char *val1a, const char *val1b, const char *val2a,
const char *val2b);
extern void get_datetime_string(time_t *raw_time, char *buffer,
int buffer_length, int type);
extern void get_time_breakdown(unsigned long raw_time, int *days, int *hours,
int *minutes, int *seconds);
NAGIOS_END_DECL
#endif

162
nagios4/skiplist.h Normal file
View File

@@ -0,0 +1,162 @@
/************************************************************************
*
* SKIPLIST.H - Skiplist data structures and functions
*
*
* 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.
************************************************************************/
#ifndef LIBNAGIOS_skiplist_h__
#define LIBNAGIOS_skiplist_h__
#include "lnag-utils.h"
/**
* @file skiplist.h
* @brief Skiplist library functions
*
* http://en.wikipedia.org/wiki/Skiplist
*
* @{
*/
#define SKIPLIST_OK 0 /**< A ok */
#define SKIPLIST_ERROR_ARGS 1 /**< Bad arguments */
#define SKIPLIST_ERROR_MEMORY 2 /**< Memory error */
#define SKIPLIST_ERROR_DUPLICATE 3 /**< Trying to insert non-unique item */
NAGIOS_BEGIN_DECL
struct skiplist_struct;
typedef struct skiplist_struct skiplist;
/**
* Return number of items currently in the skiplist
* @param list The list to investigate
* @return number of items in list
*/
unsigned long skiplist_num_items(skiplist *list);
/**
* Create a new skiplist
* @param max_levels Number of "ups" we have.
* This Should be kept close to lg2 of the number of items to store.
* @param level_probability Ignored
* @param allow_duplicates Allow duplicates in this list
* @param append_duplicates Append rather than prepend duplicates
* @param compare_function Comparison function for data entries
* @return pointer to a new skiplist on success, NULL on errors
*/
skiplist *skiplist_new(int max_levels, float level_probability, int allow_duplicates, int append_duplicates, int (*compare_function)(void *, void *));
/**
* Insert an item into a skiplist
* @param list The list to insert to
* @param data The data to insert
* @return SKIPLIST_OK on success, or an error code
*/
int skiplist_insert(skiplist *list, void *data);
/**
* Empty the skiplist of all data
* @param list The list to empty
* @return ERROR on failures. OK on success
*/
int skiplist_empty(skiplist *list);
/**
* Free all nodes (but not all data) in a skiplist
* This is similar to skiplist_empty(), but also free()'s the head node
* @param list The list to free
* @return OK on success, ERROR on failures
*/
int skiplist_free(skiplist **list);
/**
* Get the first item in the skiplist
* @param list The list to peek into
* @return The first item, or NULL if there is none
*/
void *skiplist_peek(skiplist *list);
/**
* Pop the first item from the skiplist
* @param list The list to pop from
*/
void *skiplist_pop(skiplist *list);
/**
* Get first node of skiplist
* @param list The list to search
* @param[out] node_ptr State variable for skiplist_get_next()
* @return The data-item of the first node on success, NULL on errors
*/
void *skiplist_get_first(skiplist *list, void **node_ptr);
/**
* Get next item from node_ptr
* @param[out] node_ptr State variable primed from an earlier call to
* skiplist_get_first() or skiplist_get_next()
* @return The next data-item matching node_ptr on success, NULL on errors
*/
void *skiplist_get_next(void **node_ptr);
/**
* Find first entry in skiplist matching data
* @param list The list to search
* @param data Comparison object used to search
* @param[out] node_ptr State variable for future lookups with
* skiplist_find_next()
* @return The first found data-item, of NULL if none could be found
*/
void *skiplist_find_first(skiplist *list, void *data, void **node_ptr);
/**
* Find next entry in skiplist matching data
* @param list The list to search
* @param data The data to compare against
* @param[out] node_ptr State var primed from earlier call to
* skiplist_find_next() or skiplist_find_first()
* @return The next found data-item, or NULL if none could be found
*/
void *skiplist_find_next(skiplist *list, void *data, void **node_ptr);
/**
* Delete all items matching 'data' from skiplist
* @param list The list to delete from
* @param data Comparison object used to find the real node
* @return OK on success, ERROR on errors
*/
int skiplist_delete(skiplist *list, void *data);
/**
* Delete first item matching 'data' from skiplist
* @param list The list to delete from
* @param data Comparison object used to search the list
* @return OK on success, ERROR on errors.
*/
int skiplist_delete_first(skiplist *list, void *data);
/**
* Delete a particular node from the skiplist
* @param list The list to search
* @param node_ptr The node to delete
* @return OK on success, ERROR on errors.
*/
int skiplist_delete_node(skiplist *list, void *node_ptr);
NAGIOS_END_DECL
/* @} */
#endif

7
nagios4/snprintf.h Normal file
View File

@@ -0,0 +1,7 @@
/* lib/snprintf.h. Generated from snprintf.h.in by configure. */
/* -*- C -*- */
#ifndef LIBNAGIOS_snprintf_h__
#define LIBNAGIOS_snprintf_h__
/* #undef HAVE_SNPRINTF */
/* #undef NEED_VA_LIST */
#endif

161
nagios4/squeue.h Normal file
View File

@@ -0,0 +1,161 @@
#ifndef LIBNAGIOS_squeue_h__
#define LIBNAGIOS_squeue_h__
#include <sys/time.h>
#include <time.h>
#include "pqueue.h"
/**
* @file squeue.h
* @brief Scheduling queue function declarations
*
* This library is based on the pqueue api, which implements a
* priority queue based on a binary heap, providing O(lg n) times
* for insert() and remove(), and O(1) time for peek().
* @note There is no "find". Callers must maintain pointers to their
* scheduled events if they wish to be able to remove them.
*
* @{
*/
/*
* All opaque types here.
* The pqueue library can be useful on its own though, so we
* don't block that from user view.
*/
typedef pqueue_t squeue_t;
struct squeue_event;
typedef struct squeue_event squeue_event;
/**
* Options for squeue_destroy()'s flag parameter
*/
#define SQUEUE_FREE_DATA (1 << 0) /** Call free() on all data pointers */
/**
* Get the scheduled runtime of this event
* @param[in] evt The event to get runtime of
* @return struct timeval on success, NULL on errors
*/
extern const struct timeval *squeue_event_runtime(squeue_event *evt);
/**
* Get data of an squeue_event struct
* @param[in] evt The event to operate on
* @return The data object pointed to by the event
*/
extern void *squeue_event_data(squeue_event *evt);
/**
* Creates a scheduling queue optimized for handling events within
* the given timeframe. Callers should take care to create a queue
* of a decent but not overly large size, as too small or too large
* a queue will impact performance negatively. A queue can hold any
* number of events. A good value for "horizon" would be the max
* seconds into the future one expects to schedule things, although
* with few scheduled items in that timeframe you'd be better off
* using a more narrow horizon.
*
* @param size Hint about how large this queue will get
* @return A pointer to a scheduling queue
*/
extern squeue_t *squeue_create(unsigned int size);
/**
* Destroys a scheduling queue completely
* @param[in] q The doomed queue
* @param[in] flags Flags determining the the level of destruction
*/
extern void squeue_destroy(squeue_t *q, int flags);
/**
* Enqueue an event with microsecond precision.
* It's up to the caller to keep the event pointer in case he/she
* wants to remove the event from the queue later.
*
* @param q The scheduling queue to add to
* @param tv When this event should occur
* @param data Pointer to any kind of data
* @return The complete scheduled event
*/
extern squeue_event *squeue_add_tv(squeue_t *q, struct timeval *tv, void *data);
/**
* Adds an event to the scheduling queue.
* See notes for squeue_add_tv() for details
*
* @param q The scheduling queue to add to
* @param when The unix timestamp when this event is to occur
* @param data Pointer to any kind of data
* @return The complete scheduled event
*/
extern squeue_event *squeue_add(squeue_t *q, time_t when, void *data);
/**
* Adds an event to the scheduling queue with millisecond precision
* See notes on squeue_add_tv() for details
*
* @param[in] q The scheduling queue to add to
* @param[in] when Unix timestamp when this event should occur
* @param[in] usec Millisecond of above this event should occur
* @param[in] data Pointer to any kind of data
* @return NULL on errors. squeue_event pointer on success
*/
extern squeue_event *squeue_add_usec(squeue_t *q, time_t when, time_t usec, void *data);
/**
* Adds an event to the scheduling queue with millisecond precision
* See notes on squeue_add_tv() for details
*
* @param[in] q The scheduling queue to add to
* @param[in] when Unix timestamp when this event should occur
* @param[in] msec Millisecond of above this event should occur
* @param[in] data Pointer to any kind of data
* @return NULL on errors. squeue_event pointer on success
*/
extern squeue_event *squeue_add_msec(squeue_t *q, time_t when, time_t msec, void *data);
/**
* Returns the data of the next scheduled event from the scheduling
* queue without removing it from the queue.
*
* @param q The scheduling queue to peek into
*/
extern void *squeue_peek(squeue_t *q);
/**
* Pops the next scheduled event from the scheduling queue and
* returns the data for it.
* This is equivalent to squeue_peek() + squeue_pop()
* @note This causes the squeue_event to be free()'d.
*
* @param q The scheduling queue to pop from
*/
extern void *squeue_pop(squeue_t *q);
/**
* Removes the given event from the scheduling queue
* @note This causes the associated squeue_event() to be free()'d.
* @param[in] q The scheduling queue to remove from
* @param[in] evt The event to remove
*/
extern int squeue_remove(squeue_t *q, squeue_event *evt);
/**
* Returns the number of events in the scheduling queue. This
* function never fails.
*
* @param[in] q The scheduling queue to inspect
* @return number of events in the inspected queue
*/
extern unsigned int squeue_size(squeue_t *q);
/**
* Returns true if passed timeval is after the time for the event
*
* @param[in] evt The queue event to inspect
* @param[in] reftime The reference time to compare to the queue event time
* @return 1 if reftime > event time, 0 otherwise
*/
extern int squeue_evt_when_is_after(squeue_event *evt, struct timeval *reftime);
#endif
/** @} */

31
nagios4/sretention.h Normal file
View File

@@ -0,0 +1,31 @@
/*****************************************************************************
*
* SRETENTION.H - Header for state retention routines
*
*
* 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 "common.h"
NAGIOS_BEGIN_DECL
int initialize_retention_data(const char *);
int cleanup_retention_data(void);
int save_state_information(int); /* saves all host and state information */
int read_initial_state_information(void); /* reads in initial host and state information */
NAGIOS_END_DECL

199
nagios4/statusdata.h Normal file
View File

@@ -0,0 +1,199 @@
/*****************************************************************************
*
* STATUSDATA.H - Header for external status data routines
*
*
* 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.
*
*****************************************************************************/
#ifndef _STATUSDATA_H
#define _STATUSDATA_H
#include "common.h"
#include "objects.h"
#ifdef NSCGI
#define READ_PROGRAM_STATUS 1
#define READ_HOST_STATUS 2
#define READ_SERVICE_STATUS 4
#define READ_CONTACT_STATUS 8
#define READ_ALL_STATUS_DATA READ_PROGRAM_STATUS | READ_HOST_STATUS | READ_SERVICE_STATUS | READ_CONTACT_STATUS
/*************************** CHAINED HASH LIMITS ***************************/
#define SERVICESTATUS_HASHSLOTS 1024
#define HOSTSTATUS_HASHSLOTS 1024
/**************************** DATA STRUCTURES ******************************/
NAGIOS_BEGIN_DECL
/* HOST STATUS structure */
typedef struct hoststatus_struct {
char *host_name;
char *plugin_output;
char *long_plugin_output;
char *perf_data;
int status;
time_t last_update;
int has_been_checked;
int should_be_scheduled;
int current_attempt;
int max_attempts;
time_t last_check;
time_t next_check;
int check_options;
int check_type;
time_t last_state_change;
time_t last_hard_state_change;
int last_hard_state;
time_t last_time_up;
time_t last_time_down;
time_t last_time_unreachable;
int state_type;
time_t last_notification;
time_t next_notification;
int no_more_notifications;
int notifications_enabled;
int problem_has_been_acknowledged;
int acknowledgement_type;
int current_notification_number;
int accept_passive_checks;
int event_handler_enabled;
int checks_enabled;
int flap_detection_enabled;
int is_flapping;
double percent_state_change;
double latency;
double execution_time;
int scheduled_downtime_depth;
int process_performance_data;
int obsess;
struct hoststatus_struct *next;
struct hoststatus_struct *nexthash;
} hoststatus;
/* SERVICE STATUS structure */
typedef struct servicestatus_struct {
char *host_name;
char *description;
char *plugin_output;
char *long_plugin_output;
char *perf_data;
int max_attempts;
int current_attempt;
int status;
time_t last_update;
int has_been_checked;
int should_be_scheduled;
time_t last_check;
time_t next_check;
int check_options;
int check_type;
int checks_enabled;
time_t last_state_change;
time_t last_hard_state_change;
int last_hard_state;
time_t last_time_ok;
time_t last_time_warning;
time_t last_time_unknown;
time_t last_time_critical;
int state_type;
time_t last_notification;
time_t next_notification;
int no_more_notifications;
int notifications_enabled;
int problem_has_been_acknowledged;
int acknowledgement_type;
int current_notification_number;
int accept_passive_checks;
int event_handler_enabled;
int flap_detection_enabled;
int is_flapping;
double percent_state_change;
double latency;
double execution_time;
int scheduled_downtime_depth;
int process_performance_data;
int obsess;
struct servicestatus_struct *next;
struct servicestatus_struct *nexthash;
} servicestatus;
/*************************** SERVICE STATES ***************************/
#define SERVICE_PENDING 1
#define SERVICE_OK 2
#define SERVICE_WARNING 4
#define SERVICE_UNKNOWN 8
#define SERVICE_CRITICAL 16
/**************************** HOST STATES ****************************/
#define HOST_PENDING 1
#define SD_HOST_UP 2
#define SD_HOST_DOWN 4
#define SD_HOST_UNREACHABLE 8
/* Convert the (historically ordered) host states into a notion of "urgency".
This is defined as, in ascending order:
SD_HOST_UP (business as usual)
HOST_PENDING (waiting for - supposedly first - check result)
SD_HOST_UNREACHABLE (a problem, but likely not its cause)
SD_HOST_DOWN (look here!!)
The exact values are irrelevant, so I try to make the conversion as
CPU-efficient as possible: */
#define HOST_URGENCY(hs) ((hs)|(((hs)&0x5)<<1))
/**************************** FUNCTIONS ******************************/
int read_status_data(const char *, int); /* reads all status data */
int add_host_status(hoststatus *); /* adds a host status entry to the list in memory */
int add_service_status(servicestatus *); /* adds a service status entry to the list in memory */
int add_hoststatus_to_hashlist(hoststatus *);
int add_servicestatus_to_hashlist(servicestatus *);
servicestatus *find_servicestatus(char *, char *); /* finds status information for a specific service */
hoststatus *find_hoststatus(char *); /* finds status information for a specific host */
int get_servicestatus_count(char *, int); /* gets total number of services of a certain type for a specific host */
void free_status_data(void); /* free all memory allocated to status data */
#endif
#ifndef NSCGI
int initialize_status_data(const char *); /* initializes status data at program start */
int update_all_status_data(void); /* updates all status data */
int cleanup_status_data(int); /* cleans up status data at program termination */
int update_program_status(int); /* updates program status data */
int update_host_status(host *, int); /* updates host status data */
int update_service_status(service *, int); /* updates service status data */
int update_contact_status(contact *, int); /* updates contact status data */
#endif
NAGIOS_END_DECL
#endif

132
nagios4/worker.h Normal file
View File

@@ -0,0 +1,132 @@
#ifndef LIBNAGIOS_worker_h__
#define LIBNAGIOS_worker_h__
#include <errno.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "libnagios.h"
/**
* @file worker.h
* @brief Worker implementation along with various helpers
*
* This code isn't really in the "library" category, but it's tucked
* in here to provide a good resource for writing remote workers and
* as an example on how to use the API's found here.
*/
#ifndef ETIME
#define ETIME ETIMEDOUT
#endif
typedef struct iobuf {
int fd;
unsigned int len;
char *buf;
} iobuf;
typedef struct execution_information execution_information;
typedef struct child_process {
unsigned int id, timeout;
char *cmd;
int ret;
struct kvvec *request;
iobuf outstd;
iobuf outerr;
execution_information *ei;
} child_process;
/**
* Callback for enter_worker that simply runs a command
*/
extern int start_cmd(child_process *cp);
/**
* Spawn a helper with a specific process name
* The first entry in the argv parameter will be the name of the
* new process, unless the process changes the name itself.
* @param path The path to the executable (can be $PATH relative)
* @param argv Argument vector for the helper to spawn
*/
extern int spawn_named_helper(char *path, char **argv);
/**
* Spawn any random helper process. Uses spawn_named_helper()
* @param argv The (NULL-sentinel-terminated) argument vector
* @return 0 on success, < 0 on errors
*/
extern int spawn_helper(char **argv);
/**
* To be called when a child_process has completed to ship the result to nagios
* @param cp The child_process that describes the job
* @param reason 0 if everything was OK, 1 if the job was unable to run
* @return 0 on success, non-zero otherwise
*/
extern int finish_job(child_process *cp, int reason);
/**
* Start to poll the socket and call the callback when there are new tasks
* @param sd A socket descriptor to poll
* @param cb The callback to call upon completion
*/
extern void enter_worker(int sd, int (*cb)(child_process*));
/**
* Build a buffer from a key/value vector buffer.
* The resulting kvvec-buffer is suitable for sending between
* worker and master in either direction, as it has all the
* right delimiters in all the right places.
* @param kvv The key/value vector to build the buffer from
* @return NULL on errors, a newly allocated kvvec buffer on success
*/
extern struct kvvec_buf *build_kvvec_buf(struct kvvec *kvv);
/**
* Send a key/value vector as a bytestream through a socket
* @param[in] sd The socket descriptor to send to
* @param kvv The key/value vector to send
* @return The number of bytes sent, or -1 on errors
*/
extern int worker_send_kvvec(int sd, struct kvvec *kvv);
/** @deprecated Use worker_send_kvvec() instead */
extern int send_kvvec(int sd, struct kvvec *kvv)
NAGIOS_DEPRECATED(4.1.0, "worker_send_kvvec()");
/**
* Grab a worker message from an iocache buffer
* @param[in] ioc The io cache
* @param[out] size Out buffer for buffer length
* @param[in] flags Currently unused
* @return A buffer from the iocache on succes; NULL on errors
*/
extern char *worker_ioc2msg(iocache *ioc, unsigned long *size, int flags);
/**
* Parse a worker message to a preallocated key/value vector
*
* @param[in] kvv Key/value vector to fill
* @param[in] buf The buffer to parse
* @param[in] len Length of 'buf'
* @param[in] kvv_flags Flags for buf2kvvec()
* @return 0 on success, < 0 on errors
*/
extern int worker_buf2kvvec_prealloc(struct kvvec *kvv, char *buf, unsigned long len, int kvv_flags);
/**
* Set some common socket options
* @param[in] sd The socket to set options for
* @param[in] bufsize Size to set send and receive buffers to
* @return 0 on success. < 0 on errors
*/
extern int worker_set_sockopts(int sd, int bufsize);
/** @deprecated Use worker_set_sockopts() instead */
extern int set_socket_options(int sd, int bufsize)
NAGIOS_DEPRECATED(4.1.0, "worker_set_sockopts()");
#endif /* INCLUDE_worker_h__ */