| /* |
| * Copyright (C) 2001-2011 Tildeslash Ltd. All rights reserved. |
| * |
| * This program is free software: you can redistribute it and/or modify |
| * it under the terms of the GNU Affero General Public License version 3. |
| * |
| * 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 Affero General Public License |
| * along with this program. If not, see <http://www.gnu.org/licenses/>. |
| * |
| * In addition, as a special exception, the copyright holders give |
| * permission to link the code of portions of this program with the |
| * OpenSSL library under certain conditions as described in each |
| * individual source file, and distribute linked combinations |
| * including the two. |
| * |
| * You must obey the GNU Affero General Public License in all respects |
| * for all of the code used other than OpenSSL. |
| */ |
| |
| |
| #ifndef MONIT_H |
| #define MONIT_H |
| |
| #include "config.h" |
| #include <assert.h> |
| |
| #ifdef HAVE_SYS_TYPES_H |
| #include <sys/types.h> |
| #endif |
| |
| #ifdef HAVE_SYS_STAT_H |
| #include <sys/stat.h> |
| #endif |
| |
| #ifdef HAVE_SIGNAL_H |
| #include <signal.h> |
| #endif |
| |
| #ifdef HAVE_PTHREAD_H |
| #include <pthread.h> |
| #endif |
| |
| #ifdef HAVE_STDARG_H |
| #include <stdarg.h> |
| #endif |
| |
| #ifdef HAVE_STDIO_H |
| #include <stdio.h> |
| #endif |
| |
| #ifdef HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| |
| #ifdef HAVE_REGEX_H |
| #include <regex.h> |
| #endif |
| |
| #ifdef HAVE_SYSLOG_H |
| #include <syslog.h> |
| #endif |
| |
| #ifdef HAVE_LIMITS_H |
| #include <limits.h> |
| #endif |
| |
| #ifdef HAVE_SYS_UTSNAME_H |
| #include <sys/utsname.h> |
| #endif |
| |
| #ifdef HAVE_ERRNO_H |
| #include <errno.h> |
| #endif |
| |
| #include "ssl.h" |
| #include "socket.h" |
| |
| // libmonit |
| #include "system/Command.h" |
| #include "system/Process.h" |
| #include "util/Str.h" |
| #include "util/StringBuffer.h" |
| |
| |
| #define MONITRC "monitrc" |
| #define TIMEFORMAT "%Z %b %e %T" |
| #define STRERROR strerror(errno) |
| #define STRLEN 256 |
| #ifndef USEC_PER_SEC |
| #define USEC_PER_SEC 1000000L |
| #endif |
| #define USEC_PER_MSEC 1000L |
| |
| #define ARGMAX 64 |
| #define HTTP_CONTENT_MAX (1024*1000) |
| /* Set event queue directory mode: "drwx------" */ |
| #define QUEUEMASK 0077 |
| /* Set file mode: "drw-------" */ |
| #define PRIVATEMASK 0177 |
| /* Set log file mode: "-rw-r-----" */ |
| #define LOGMASK 0137 |
| /* Set pid file mode: "-rw-r--r--" */ |
| #define MYPIDMASK 0122 |
| #define MYPIDDIR PIDDIR |
| #define MYPIDFILE "monit.pid" |
| #define MYSTATEFILE "monit.state" |
| #define MYIDFILE "monit.id" |
| #define MYEVENTLISTBASE "/var/monit" |
| |
| #define LOCALHOST "localhost" |
| |
| #define PORT_SMTP 25 |
| #define PORT_SMTPS 465 |
| #define PORT_HTTP 80 |
| #define PORT_HTTPS 443 |
| |
| #define SSL_TIMEOUT 15 |
| |
| #define START_DELAY 0 |
| #define EXEC_TIMEOUT 30 |
| |
| #define START_HTTP 1 |
| #define STOP_HTTP 2 |
| |
| #define TRUE 1 |
| #define FALSE 0 |
| |
| #define MONITOR_NOT 0x0 |
| #define MONITOR_YES 0x1 |
| #define MONITOR_INIT 0x2 |
| #define MONITOR_WAITING 0x4 |
| |
| #define EVERY_CYCLE 0 |
| #define EVERY_SKIPCYCLES 1 |
| #define EVERY_CRON 2 |
| #define EVERY_NOTINCRON 3 |
| |
| #define STATE_SUCCEEDED 0 |
| #define STATE_FAILED 1 |
| #define STATE_CHANGED 2 |
| #define STATE_CHANGEDNOT 3 |
| #define STATE_INIT 4 |
| |
| #define MODE_ACTIVE 0 |
| #define MODE_PASSIVE 1 |
| #define MODE_MANUAL 2 |
| |
| #define OPERATOR_GREATER 0 |
| #define OPERATOR_LESS 1 |
| #define OPERATOR_EQUAL 2 |
| #define OPERATOR_NOTEQUAL 3 |
| |
| #define TIME_SECOND 1 |
| #define TIME_MINUTE 60 |
| #define TIME_HOUR 3600 |
| #define TIME_DAY 86400 |
| |
| #define ACTION_IGNORE 0 |
| #define ACTION_ALERT 1 |
| #define ACTION_RESTART 2 |
| #define ACTION_STOP 3 |
| #define ACTION_EXEC 4 |
| #define ACTION_UNMONITOR 5 |
| #define ACTION_START 6 |
| #define ACTION_MONITOR 7 |
| |
| #define TYPE_FILESYSTEM 0 |
| #define TYPE_DIRECTORY 1 |
| #define TYPE_FILE 2 |
| #define TYPE_PROCESS 3 |
| #define TYPE_HOST 4 |
| #define TYPE_SYSTEM 5 |
| #define TYPE_FIFO 6 |
| #define TYPE_PROGRAM 7 |
| |
| #define RESOURCE_ID_CPU_PERCENT 1 |
| #define RESOURCE_ID_MEM_PERCENT 2 |
| #define RESOURCE_ID_MEM_KBYTE 3 |
| #define RESOURCE_ID_LOAD1 4 |
| #define RESOURCE_ID_LOAD5 5 |
| #define RESOURCE_ID_LOAD15 6 |
| #define RESOURCE_ID_CHILDREN 7 |
| #define RESOURCE_ID_TOTAL_MEM_KBYTE 8 |
| #define RESOURCE_ID_TOTAL_MEM_PERCENT 9 |
| #define RESOURCE_ID_INODE 10 |
| #define RESOURCE_ID_SPACE 11 |
| #define RESOURCE_ID_CPUUSER 12 |
| #define RESOURCE_ID_CPUSYSTEM 13 |
| #define RESOURCE_ID_CPUWAIT 14 |
| #define RESOURCE_ID_TOTAL_CPU_PERCENT 15 |
| #define RESOURCE_ID_SWAP_PERCENT 16 |
| #define RESOURCE_ID_SWAP_KBYTE 17 |
| |
| #define DIGEST_CLEARTEXT 1 |
| #define DIGEST_CRYPT 2 |
| #define DIGEST_MD5 3 |
| #define DIGEST_PAM 4 |
| |
| #define UNIT_BYTE 1 |
| #define UNIT_KILOBYTE 1024 |
| #define UNIT_MEGABYTE 1048580 |
| #define UNIT_GIGABYTE 1073740000 |
| |
| #define HASH_UNKNOWN 0 |
| #define HASH_MD5 1 |
| #define HASH_SHA1 2 |
| #define DEFAULT_HASH HASH_MD5 |
| /* Length of the longest message digest in bytes */ |
| #define MD_SIZE 65 |
| |
| #define PROTOCOL_NULL 0 |
| #define PROTOCOL_HTTP 1 |
| #define PROTOCOL_HTTPS 2 |
| |
| #define LEVEL_FULL 0 |
| #define LEVEL_SUMMARY 1 |
| |
| #define LEVEL_NAME_FULL "full" |
| #define LEVEL_NAME_SUMMARY "summary" |
| |
| #define HANDLER_SUCCEEDED 0x0 |
| #define HANDLER_ALERT 0x1 |
| #define HANDLER_MMONIT 0x2 |
| #define HANDLER_MAX HANDLER_MMONIT |
| |
| #define ICMP_ATTEMPT_COUNT 3 |
| |
| |
| /** ------------------------------------------------- Special purpose macros */ |
| |
| |
| /* Replace the standard signal function with a more reliable using |
| * sigaction. Taken from Stevens APUE book. */ |
| typedef void Sigfunc(int); |
| Sigfunc *signal(int signo, Sigfunc * func); |
| #if defined(SIG_IGN) && !defined(SIG_ERR) |
| #define SIG_ERR ((Sigfunc *)-1) |
| #endif |
| |
| |
| /** ------------------------------------------------- General purpose macros */ |
| |
| |
| #undef MAX |
| #define MAX(x,y) ((x) > (y) ? (x) : (y)) |
| #undef MIN |
| #define MIN(x,y) ((x) < (y) ? (x) : (y)) |
| #define IS(a,b) ((a&&b)?!strcasecmp(a, b):0) |
| #define DEBUG if(Run.debug) LogDebug |
| #define FLAG(x, y) (x & y) == y |
| #define NVLSTR(x) (x?x:"") |
| |
| |
| /** ------------------------------------------------- Synchronization macros */ |
| |
| |
| #define LOCK(mutex) do { pthread_mutex_t *_yymutex = &(mutex); \ |
| assert(pthread_mutex_lock(_yymutex)==0); |
| #define END_LOCK assert(pthread_mutex_unlock(_yymutex)==0); } while (0) |
| |
| |
| /** ------------------------------------------ Simple Assert Exception macro */ |
| |
| |
| #define ASSERT(e) do { if(!(e)) { LogCritical("AssertException: " #e \ |
| " at %s:%d\naborting..\n", __FILE__, __LINE__); abort(); } } while(0) |
| |
| |
| /* --------------------------------------------------------- Data structures */ |
| |
| |
| /** Message Digest type with size for the longest digest we will compute */ |
| typedef char MD_T[MD_SIZE]; |
| |
| |
| /** |
| * Defines a Command with ARGMAX optional arguments. The arguments |
| * array must be NULL terminated and the first entry is the program |
| * itself. In addition, a user and group may be set for the Command |
| * which means that the Command should run as a certain user and with |
| * certain group. |
| */ |
| typedef struct mycommand { |
| char *arg[ARGMAX]; /**< Program with arguments */ |
| int length; /**< The length of the arguments array */ |
| int has_uid; /**< TRUE if a new uid is defined for this Command */ |
| uid_t uid; /**< The user id to switch to when running this Command */ |
| int has_gid; /**< TRUE if a new gid is defined for this Command */ |
| gid_t gid; /**< The group id to switch to when running this Command */ |
| unsigned timeout; /**< Max seconds which we wait for method to execute */ |
| } *command_t; |
| |
| |
| /** Defines an event action object */ |
| typedef struct myaction { |
| int id; /**< Action to be done */ |
| command_t exec; /**< Optional command to be executed */ |
| unsigned count; /**< Event count needed to trigger the action */ |
| unsigned cycles; /**< Cycles during which count limit can be reached */ |
| } *Action_T; |
| |
| |
| /** Defines event's up and down actions */ |
| typedef struct myeventaction { |
| Action_T failed; /**< Action in the case of failure down */ |
| Action_T succeeded; /**< Action in the case of failure up */ |
| } *EventAction_T; |
| |
| |
| /** Defines an url object */ |
| typedef struct myurl { |
| char *url; /**< Full URL */ |
| char *protocol; /**< URL protocol type */ |
| char *user; /**< URL user part */ |
| char *password; /**< URL password part */ |
| char *hostname; /**< URL hostname part */ |
| int port; /**< URL port part */ |
| char *path; /**< URL path part */ |
| char *query; /**< URL query part */ |
| } *URL_T; |
| |
| |
| /** Defines a HTTP client request object */ |
| typedef struct myrequest { |
| URL_T url; /**< URL request */ |
| int operator; /**< Response content comparison operator */ |
| #ifdef HAVE_REGEX_H |
| regex_t *regex; /* regex used to test the response body */ |
| #else |
| char *regex; /* string to search for in the response body */ |
| #endif |
| } *Request_T; |
| |
| |
| /** Defines an event notification and status receiver object */ |
| typedef struct mymmonit { |
| URL_T url; /**< URL definition */ |
| Ssl_T ssl; /**< SSL definition */ |
| int timeout; /**< The timeout to wait for connection or i/o */ |
| |
| /** For internal use */ |
| struct mymmonit *next; /**< next receiver in chain */ |
| } *Mmonit_T; |
| |
| |
| /** Defines a mailinglist object */ |
| typedef struct mymail { |
| char *to; /**< Mail address for alert notification */ |
| char *from; /**< The mail from address */ |
| char *replyto; /**< Optional reply-to address */ |
| char *subject; /**< The mail subject */ |
| char *message; /**< The mail message */ |
| unsigned int events; /*< Events for which this mail object should be sent */ |
| unsigned int reminder; /*< Send error reminder each Xth cycle */ |
| |
| /** For internal use */ |
| struct mymail *next; /**< next recipient in chain */ |
| } *Mail_T; |
| |
| |
| /** Defines a mail server address */ |
| typedef struct mymailserver { |
| char *host; /**< Server host address, may be a IP or a hostname string */ |
| int port; /**< Server port */ |
| char *username; /** < Username for SMTP_AUTH */ |
| char *password; /** < Password for SMTP_AUTH */ |
| Ssl_T ssl; /**< SSL definition */ |
| |
| /** For internal use */ |
| struct mymailserver *next; /**< Next server to try on connect error */ |
| } *MailServer_T; |
| |
| |
| typedef struct myauthentication { |
| char *uname; /**< User allowed to connect to monit httpd */ |
| char *passwd; /**< The users password data */ |
| char *groupname; /**< PAM group name */ |
| int digesttype; /**< How did we store the password */ |
| int is_readonly; /**< TRUE if this is a read-only authenticated user*/ |
| struct myauthentication *next; /**< Next credential or NULL if last */ |
| } *Auth_T; |
| |
| |
| /** Defines process tree - data storage backend*/ |
| typedef struct myprocesstree { |
| int pid; |
| int ppid; |
| int status_flag; |
| time_t starttime; |
| char *cmdline; |
| |
| int visited; |
| int children_num; |
| int children_sum; |
| int cpu_percent; |
| int cpu_percent_sum; |
| unsigned long mem_kbyte; |
| unsigned long mem_kbyte_sum; |
| |
| /** For internal use */ |
| double time; /**< 1/10 seconds */ |
| double time_prev; /**< 1/10 seconds */ |
| long cputime; /**< 1/10 seconds */ |
| long cputime_prev; /**< 1/10 seconds */ |
| |
| int parent; |
| int *children; |
| } ProcessTree_T; |
| |
| |
| /** Defines data for systemwide statistic */ |
| typedef struct mysysteminfo { |
| struct timeval collected; /**< When were data collected */ |
| int cpus; /**< Number of CPUs */ |
| double loadavg[3]; /**< Load average triple */ |
| unsigned long mem_kbyte_max; /**< Maximal system real memory */ |
| unsigned long swap_kbyte_max; /**< Swap size */ |
| unsigned long total_mem_kbyte; /**< Total real memory in use in the system */ |
| unsigned long total_swap_kbyte; /**< Total swap in use in the system */ |
| int total_mem_percent; /**< Total real memory in use in the system */ |
| int total_swap_percent; /**< Total swap in use in the system */ |
| int total_cpu_user_percent; /**< Total CPU in use in user space (pct.)*/ |
| int total_cpu_syst_percent; /**< Total CPU in use in kernel space (pct.)*/ |
| int total_cpu_wait_percent; /**< Total CPU in use in waiting (pct.)*/ |
| struct utsname uname; /**< Platform information provided by uname() */ |
| } SystemInfo_T; |
| |
| |
| /** Defines a protocol object with protocol functions */ |
| typedef struct Protocol_T { |
| const char *name; /**< Protocol name */ |
| int(*check)(Socket_T); /**< Protocol verification function */ |
| } *Protocol_T; |
| |
| |
| /** Defines a send/expect object used for generic protocol tests */ |
| typedef struct mygenericproto { |
| char *send; /* string to send, or NULL if expect */ |
| #ifdef HAVE_REGEX_H |
| regex_t *expect; /* regex code to expect, or NULL if send */ |
| #else |
| char *expect; /* string to expect, or NULL if send */ |
| #endif |
| /** For internal use */ |
| struct mygenericproto *next; |
| } *Generic_T; |
| |
| /** Defines a port object */ |
| typedef struct myport { |
| volatile int socket; /**< Socket used for connection */ |
| int type; /**< Socket type used for connection (UDP/TCP) */ |
| int family; /**< Socket family used for connection (INET/UNIX) */ |
| char *hostname; /**< Hostname to check */ |
| int port; /**< Portnumber */ |
| char *request; /**< Specific protocol request */ |
| char *request_checksum; /**< The optional checksum for a req. document */ |
| char *request_hostheader; /**< The optional Host: header to use */ |
| int request_hashtype; /**< The optional type of hash for a req. document */ |
| char *pathname; /**< Pathname, in case of an UNIX socket */ |
| int maxforward; /**< Optional max forward for protocol checking */ |
| Generic_T generic; /**< Generic test handle */ |
| int timeout; /**< The timeout in seconds to wait for connect or read i/o */ |
| int retry; /**< Number of connection retry before reporting an error */ |
| int is_available; /**< TRUE if the server/port is available */ |
| double response; /**< Socket connection response time */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| /** Apache-status specific parameters */ |
| struct apache_status { |
| int loglimit; /**< Max percentatge of logging processes */ |
| int loglimitOP; /**< loglimit operator */ |
| int closelimit; /**< Max percentatge of closinging processes */ |
| int closelimitOP; /**< closelimit operator */ |
| int dnslimit; /**< Max percentatge of processes doing DNS lookup */ |
| int dnslimitOP; /**< dnslimit operator */ |
| int keepalivelimit; /**< Max percentatge of keepalive processes */ |
| int keepalivelimitOP; /**< keepalivelimit operator */ |
| int replylimit; /**< Max percentatge of replying processes */ |
| int replylimitOP; /**< replylimit operator */ |
| int requestlimit; /**< Max percentatge of processes reading requests */ |
| int requestlimitOP; /**< requestlimit operator */ |
| int startlimit; /**< Max percentatge of processes starting up */ |
| int startlimitOP; /**< startlimit operator */ |
| int waitlimit; /**< Min percentatge of processes waiting for connection */ |
| int waitlimitOP; /**< waitlimit operator */ |
| int gracefullimit;/**< Max percentatge of processes gracefully finishing */ |
| int gracefullimitOP; /**< gracefullimit operator */ |
| int cleanuplimit; /**< Max percentatge of processes in idle cleanup */ |
| int cleanuplimitOP; /**< cleanuplimit operator */ |
| } ApacheStatus; |
| |
| Ssl_T SSL; /**< SSL definition */ |
| Protocol_T protocol; /**< Protocol object for testing a port's service */ |
| Request_T url_request; /**< Optional url client request object */ |
| |
| /** For internal use */ |
| struct myport *next; /**< next port in chain */ |
| } *Port_T; |
| |
| |
| /** Defines a ICMP object */ |
| typedef struct myicmp { |
| int type; /**< ICMP type used */ |
| int count; /**< ICMP echo requests count */ |
| int timeout; /**< The timeout in seconds to wait for response */ |
| int is_available; /**< TRUE if the server is available */ |
| double response; /**< ICMP ECHO response time */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| |
| /** For internal use */ |
| struct myicmp *next; /**< next icmp in chain */ |
| } *Icmp_T; |
| |
| |
| typedef struct myservicegroupmember { |
| char *name; /**< name of service */ |
| |
| /** For internal use */ |
| struct myservicegroupmember *next; /**< next service in chain */ |
| } *ServiceGroupMember_T; |
| |
| |
| typedef struct myservicegroup { |
| char *name; /**< name of service group */ |
| struct myservicegroupmember *members; /**< Service group members */ |
| |
| /** For internal use */ |
| struct myservicegroup *next; /**< next service group in chain */ |
| } *ServiceGroup_T; |
| |
| |
| typedef struct mydependant { |
| char *dependant; /**< name of dependant service */ |
| |
| /** For internal use */ |
| struct mydependant *next; /**< next dependant service in chain */ |
| } *Dependant_T; |
| |
| |
| /** Defines resource data */ |
| typedef struct myresource { |
| int resource_id; /**< Which value is checked */ |
| long limit; /**< Limit of the resource */ |
| int operator; /**< Comparison operator */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| |
| /** For internal use */ |
| struct myresource *next; /**< next resource in chain */ |
| } *Resource_T; |
| |
| |
| /** Defines timestamp object */ |
| typedef struct mytimestamp { |
| int operator; /**< Comparison operator */ |
| int time; /**< Timestamp watermark */ |
| int test_changes; /**< TRUE if we only should test for changes */ |
| time_t timestamp; /**< The original last modified timestamp for this object*/ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| |
| /** For internal use */ |
| struct mytimestamp *next; /**< next timestamp in chain */ |
| } *Timestamp_T; |
| |
| |
| /** Defines action rate object */ |
| typedef struct myactionrate { |
| int count; /**< Action counter */ |
| int cycle; /**< Cycle counter */ |
| EventAction_T action; /**< Description of the action upon matching rate */ |
| |
| /** For internal use */ |
| struct myactionrate *next; /**< next actionrate in chain */ |
| } *ActionRate_T; |
| |
| |
| /** Defines when to run a check for a service. This type suports both the old |
| cycle based every statement and the new cronformat version */ |
| typedef struct myevery { |
| int type; /**< 0 = not set, 1 = cycle, 2 = cron, 3 = negated cron */ |
| union { |
| struct { |
| int number; /**< Check this program at a given cycles */ |
| int counter; /**< Counter for number. When counter == number, check */ |
| } cycle; /**< Old cycle based every check */ |
| char *cron; /* A crontab format string */ |
| } spec; |
| } Every_T; |
| |
| typedef struct myprogram { |
| int return_value; /**< Return value of the program to check */ |
| int operator; /**< Comparison operator */ |
| int timeout; /**< How long the program may run until it is killed */ |
| time_t started; /**< When the sub-process was started */ |
| int exitStatus; /**< Sub-process exit status for reporting */ |
| Process_T P; /**< A Process_T object representing the sub-process */ |
| Command_T C; /**< A Command_T object for building the sub-process */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| } *Program_T; |
| |
| |
| /** Defines size object */ |
| typedef struct mysize { |
| int operator; /**< Comparison operator */ |
| unsigned long long size; /**< Size watermark */ |
| int test_changes; /**< TRUE if we only should test for changes */ |
| int test_changes_ok; /**< TRUE if size was initialized for changes test */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| |
| /** For internal use */ |
| struct mysize *next; /**< next size in chain */ |
| } *Size_T; |
| |
| |
| /** Defines uptime object */ |
| typedef struct myuptime { |
| int operator; /**< Comparison operator */ |
| unsigned long long uptime; /**< Uptime watermark */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| |
| /** For internal use */ |
| struct myuptime *next; /**< next uptime in chain */ |
| } *Uptime_T; |
| |
| |
| /** Defines checksum object */ |
| typedef struct mychecksum { |
| MD_T hash; /**< A checksum hash computed for the path */ |
| int type; /**< The type of hash (e.g. md5 or sha1) */ |
| int length; /**< Length of the hash */ |
| int test_changes; /**< TRUE if we only should test for changes */ |
| int test_changes_ok; /**< TRUE if cksum was initialized for changes test */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| } *Checksum_T; |
| |
| |
| /** Defines permission object */ |
| typedef struct myperm { |
| int perm; /**< Access permission */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| } *Perm_T; |
| |
| /** Defines match object */ |
| typedef struct mymatch { |
| int ignore; /**< Ignore match */ |
| int not; /**< Invert match */ |
| char *match_string; /**< Match string */ |
| char *match_path; /**< File with matching rules */ |
| #ifdef HAVE_REGEX_H |
| regex_t *regex_comp; /**< Match compile */ |
| #endif |
| StringBuffer_T log; /**< The temporary buffer used to record the matches */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| |
| /** For internal use */ |
| struct mymatch *next; /**< next match in chain */ |
| } *Match_T; |
| |
| |
| /** Defines uid object */ |
| typedef struct myuid { |
| uid_t uid; /**< Owner's uid */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| } *Uid_T; |
| |
| |
| /** Defines gid object */ |
| typedef struct mygid { |
| gid_t gid; /**< Owner's gid */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| } *Gid_T; |
| |
| |
| /** Defines filesystem configuration */ |
| typedef struct myfilesystem { |
| int resource; /**< Whether to check inode or space */ |
| int operator; /**< Comparison operator */ |
| long limit_absolute; /**< Watermark - blocks */ |
| int limit_percent; /**< Watermark - percent */ |
| EventAction_T action; /**< Description of the action upon event occurence */ |
| |
| /** For internal use */ |
| struct myfilesystem *next; /**< next filesystem in chain */ |
| } *Filesystem_T; |
| |
| |
| /** Defines service data */ |
| typedef struct myinfo { |
| /* Shared */ |
| mode_t st_mode; /**< Permission */ |
| uid_t st_uid; /**< Owner's uid */ |
| gid_t st_gid; /**< Owner's gid */ |
| time_t timestamp; /**< Timestamp */ |
| |
| union { |
| struct { |
| long f_bsize; /**< Transfer block size */ |
| long f_blocks; /**< Total data blocks in filesystem */ |
| long f_blocksfree; /**< Free blocks available to non-superuser */ |
| long f_blocksfreetotal; /**< Free blocks in filesystem */ |
| long f_files; /**< Total file nodes in filesystem */ |
| long f_filesfree; /**< Free file nodes in filesystem */ |
| char *mntpath; /**< Filesystem file, directory or mountpoint */ |
| int inode_percent; /**< Used inode percentage * 10 */ |
| long inode_total; /**< Used inode total objects */ |
| int space_percent; /**< Used space percentage * 10 */ |
| long space_total; /**< Used space total blocks */ |
| int _flags; /**< Filesystem flags from last cycle */ |
| int flags; /**< Filesystem flags from actual cycle */ |
| } filesystem; |
| |
| struct { |
| off_t st_size; /**< Size */ |
| off_t readpos; /**< Position for regex matching */ |
| ino_t st_ino; /**< Inode */ |
| ino_t st_ino_prev; /**< Previous inode for regex matching */ |
| MD_T cs_sum; /**< Checksum */ |
| } file; |
| |
| struct { |
| int _pid; /**< Process PID from last cycle */ |
| int _ppid; /**< Process parent PID from last cycle */ |
| int pid; /**< Process PID from actual cycle */ |
| int ppid; /**< Process parent PID from actual cycle */ |
| int status_flag; |
| int children; |
| long mem_kbyte; |
| long total_mem_kbyte; |
| int mem_percent; /**< percentage * 10 */ |
| int total_mem_percent; /**< percentage * 10 */ |
| int cpu_percent; /**< percentage * 10 */ |
| int total_cpu_percent; /**< percentage * 10 */ |
| time_t uptime; /**< Process uptime */ |
| } process; |
| } priv; |
| } *Info_T; |
| |
| |
| /** Defines service data */ |
| typedef struct myservice { |
| |
| /** Common parameters */ |
| char *name; /**< Service descriptive name */ |
| int (*check)(struct myservice *); /**< Service verification function */ |
| int type; /**< Monitored service type */ |
| int monitor; /**< Monitor state flag */ |
| int mode; /**< Monitoring mode for the service */ |
| int ncycle; /**< The number of the current cycle */ |
| int nstart; /**< The number of current starts with this service */ |
| int visited; /**< Service visited flag, set if dependencies are used */ |
| int depend_visited;/**< Depend visited flag, set if dependencies are used */ |
| Every_T every; /**< Timespec for when to run check of service */ |
| command_t start; /**< The start command for the service */ |
| command_t stop; /**< The stop command for the service */ |
| command_t restart; |
| |
| Dependant_T dependantlist; /**< Dependant service list */ |
| Mail_T maillist; /**< Alert notification mailinglist */ |
| |
| /** Test rules and event handlers */ |
| ActionRate_T actionratelist; /**< ActionRate check list */ |
| Checksum_T checksum; /**< Checksum check */ |
| Filesystem_T filesystemlist; /**< Filesystem check list */ |
| Gid_T gid; /**< Gid check */ |
| Icmp_T icmplist; /**< ICMP check list */ |
| Perm_T perm; /**< Permission check */ |
| Port_T portlist; /**< Portnumbers to check, either local or at a host */ |
| Resource_T resourcelist; /**< Resouce check list */ |
| Size_T sizelist; /**< Size check list */ |
| Uptime_T uptimelist; /**< Uptime check list */ |
| Match_T matchlist; /**< Content Match list */ |
| Match_T matchignorelist; /**< Content Match ignore list */ |
| Timestamp_T timestamplist; /**< Timestamp check list */ |
| Uid_T uid; /**< Uid check */ |
| Program_T program; /**< Status (of program execution) check */ |
| |
| |
| EventAction_T action_PID; /**< Action upon pid change */ |
| EventAction_T action_PPID; /**< Action upon ppid change */ |
| EventAction_T action_FSFLAG; /**< Action upon filesystem flags change */ |
| |
| /** General event handlers */ |
| EventAction_T action_DATA; /**< Description of the action upon event */ |
| EventAction_T action_EXEC; /**< Description of the action upon event */ |
| EventAction_T action_INVALID; /**< Description of the action upon event */ |
| EventAction_T action_NONEXIST; /**< Description of the action upon event */ |
| |
| /** Internal monit events */ |
| EventAction_T action_MONIT_START; /**< Monit instance start action */ |
| EventAction_T action_MONIT_STOP; /**< Monit instance stop action */ |
| EventAction_T action_MONIT_RELOAD; /**< Monit instance reload action */ |
| EventAction_T action_ACTION; /**< Action requested by CLI or GUI */ |
| |
| /** Runtime parameters */ |
| int error; /**< Error flags bitmap */ |
| int error_hint; /**< Failed/Changed hint for error bitmap */ |
| Info_T inf; /**< Service check result */ |
| struct timeval collected; /**< When were data collected */ |
| int doaction; /**< Action scheduled by http thread */ |
| char *token; /**< Action token */ |
| |
| /** Events */ |
| struct myevent { |
| #define EVENT_VERSION 3 /**< The event structure version */ |
| long id; /**< The event identification */ |
| struct timeval collected; /**< When the event occured */ |
| char *source; /**< Event source service name */ |
| int mode; /**< Monitoring mode for the service */ |
| int type; /**< Monitored service type */ |
| short state; /**< TRUE if failed, FALSE if succeeded */ |
| short state_changed; /**< TRUE if state changed */ |
| long long state_map; /**< Event bitmap for last cycles */ |
| unsigned int count; /**< The event rate */ |
| unsigned int flag; /**< The handlers state flag */ |
| char *message; /**< Optional message describing the event */ |
| EventAction_T action; /**< Description of the event action */ |
| /** For internal use */ |
| struct myevent *next; /**< next event in chain */ |
| struct myevent *previous; /**< previous event in chain */ |
| } *eventlist; /**< Pending events list */ |
| |
| /** Context specific parameters */ |
| char *path; /**< Path to the filesys, file, directory or process pid file */ |
| |
| /** For internal use */ |
| pthread_mutex_t mutex; /**< Mutex used for action synchronization */ |
| struct myservice *next; /**< next service in chain */ |
| struct myservice *next_conf; /**< next service according to conf file */ |
| struct myservice *next_depend; /**< next depend service in chain */ |
| } *Service_T; |
| |
| |
| typedef struct myevent *Event_T; |
| |
| |
| /** Defines data for application runtime */ |
| struct myrun { |
| volatile int stopped;/**< TRUE if monit was stopped. Flag used by threads */ |
| char *controlfile; /**< The file to read configuration from */ |
| char *logfile; /**< The file to write logdata into */ |
| char *localhostname; /**< The host name for localhost */ |
| char *pidfile; /**< This programs pidfile */ |
| char *idfile; /**< The file with unique monit id */ |
| char id[STRLEN]; /**< Unique monit id */ |
| char *statefile; /**< The file with the saved runtime state */ |
| char *mygroup; /**< Group Name of the Service */ |
| int debug; /**< Write debug information - TRUE or FALSE */ |
| int use_syslog; /**< If TRUE write log to syslog */ |
| int dolog; /**< TRUE if program should log actions, otherwise FALSE */ |
| int isdaemon; /**< TRUE if program should run as a daemon */ |
| int polltime; /**< In deamon mode, the sleeptime (sec) between run */ |
| int startdelay; /**< the sleeptime (sec) after startup */ |
| int dohttpd; /**< TRUE if monit HTTP server should run */ |
| int httpdssl; /**< TRUE if monit HTTP server uses ssl */ |
| char *httpsslpem; /**< PEM file for the HTTPS server */ |
| int clientssl; /**< TRUE if monit HTTP server uses ssl with client auth */ |
| char *httpsslclientpem; /**< PEM file/dir to check against at connect */ |
| int allowselfcert; /**< TRUE if self certified client certs are allowed */ |
| int httpdsig; /**< TRUE if monit HTTP server presents version signature */ |
| int httpdport; /**< The monit http server's portnumber */ |
| int once; /**< TRUE - run only once */ |
| int init; /**< TRUE - don't background to run from init */ |
| int facility; /** The facility to use when running openlog() */ |
| int doprocess; /**< TRUE if process status engine is used */ |
| char *bind_addr; /**< The address monit http will bind to */ |
| volatile int doreload; /**< TRUE if a monit daemon should reinitialize */ |
| volatile int dowakeup; /**< TRUE if a monit daemon was wake up by signal */ |
| int doaction; /**< TRUE if some service(s) has action pending */ |
| mode_t umask; /**< The initial umask monit was started with */ |
| int testing; /**< Running in configuration testing mode - TRUE or FALSE */ |
| time_t incarnation; /**< Unique ID for running monit instance */ |
| int handler_init; /**< The handlers queue initialization */ |
| int handler_flag; /**< The handlers state flag */ |
| int handler_queue[HANDLER_MAX+1]; /**< The handlers queue counter */ |
| Service_T system; /**< The general system service */ |
| char *eventlist_dir; /**< The event queue base directory */ |
| int eventlist_slots; /**< The event queue size - number of slots */ |
| int expectbuffer; /**< Generic protocol expect buffer - STRLEN by default */ |
| |
| /** An object holding program relevant "environment" data, see; env.c */ |
| struct myenvironment { |
| char *user; /**< The the effective user running this program */ |
| char *home; /**< Users home directory */ |
| char *cwd; /**< Current working directory */ |
| } Env; |
| |
| char *mail_hostname; /**< Used in HELO/EHLO/MessageID when sending mail */ |
| int mailserver_timeout; /**< Connect and read timeout for a SMTP server */ |
| Mail_T maillist; /**< Global alert notification mailinglist */ |
| MailServer_T mailservers; /**< List of MTAs used for alert notification */ |
| Mmonit_T mmonits; /**< Event notification and status receivers list */ |
| Auth_T credentials; /** A list holding Basic Authentication information */ |
| int dommonitcredentials; /**< TRUE if M/Monit should receive credentials */ |
| Auth_T mmonitcredentials; /**< Pointer to selected credentials or NULL */ |
| Event_T eventlist; /** A list holding partialy handled events */ |
| /** User selected standard mail format */ |
| struct myformat { |
| char *from; /**< The standard mail from address */ |
| char *replyto; /**< Optional reply-to header */ |
| char *subject; /**< The standard mail subject */ |
| char *message; /**< The standard mail message */ |
| } MailFormat; |
| |
| pthread_mutex_t mutex; /**< Mutex used for service data synchronization */ |
| #ifdef OPENSSL_FIPS |
| int fipsEnabled; /** TRUE if monit should use FIPS-140 mode */ |
| #endif |
| }; |
| |
| |
| /* -------------------------------------------------------- Global variables */ |
| |
| extern const char *prog; |
| extern struct myrun Run; |
| extern Service_T servicelist; |
| extern Service_T servicelist_conf; |
| extern ServiceGroup_T servicegrouplist; |
| extern SystemInfo_T systeminfo; |
| extern ProcessTree_T *ptree; |
| extern int ptreesize; |
| extern ProcessTree_T *oldptree; |
| extern int oldptreesize; |
| |
| extern char *actionnames[]; |
| extern char *modenames[]; |
| extern char *checksumnames[]; |
| extern char *operatornames[]; |
| extern char *operatorshortnames[]; |
| extern char *statusnames[]; |
| extern char *servicetypes[]; |
| extern char *pathnames[]; |
| extern char *icmpnames[]; |
| extern char *sslnames[]; |
| |
| /* ------------------------------------------------------- Public prototypes */ |
| |
| #include "util.h" |
| #include "file.h" |
| |
| // libmonit |
| #include "system/Mem.h" |
| |
| |
| /* FIXME: move remaining prototypes into seperate header-files */ |
| |
| int parse(char *); |
| int control_service(const char *, int); |
| int control_service_string(const char *, const char *); |
| int control_service_daemon(const char *, const char *); |
| void setup_dependants(); |
| void reset_depend(); |
| void spawn(Service_T, command_t, Event_T); |
| int status(char *); |
| int log_init(); |
| void LogEmergency(const char *, ...); |
| void LogAlert(const char *, ...); |
| void LogCritical(const char *, ...); |
| void LogError(const char *, ...); |
| void vLogError(const char *s, va_list ap); |
| void vLogAbortHandler(const char *s, va_list ap); |
| void LogWarning(const char *, ...); |
| void LogNotice(const char *, ...); |
| void LogInfo(const char *, ...); |
| void LogDebug(const char *, ...); |
| void log_close(); |
| #ifndef HAVE_VSYSLOG |
| #ifdef HAVE_SYSLOG |
| void vsyslog (int, const char *, va_list); |
| #endif /* HAVE_SYSLOG */ |
| #endif /* HAVE_VSYSLOG */ |
| int validate(); |
| void daemonize(); |
| void gc(); |
| void gc_mail_list(Mail_T *); |
| void gccmd(command_t *); |
| void gc_event(Event_T *e); |
| int kill_daemon(int); |
| int exist_daemon(); |
| int sendmail(Mail_T); |
| int sock_msg(int, char *, ...); |
| void init_env(); |
| void monit_http(int); |
| int can_http(); |
| char *format(const char *, va_list, long *); |
| void redirect_stdfd(); |
| void fd_close(); |
| pid_t getpgid(pid_t); |
| void unset_signal_block(sigset_t *); |
| void set_signal_block(sigset_t *, sigset_t *); |
| int check_process(Service_T); |
| int check_filesystem(Service_T); |
| int check_file(Service_T); |
| int check_directory(Service_T); |
| int check_remote_host(Service_T); |
| int check_system(Service_T); |
| int check_fifo(Service_T); |
| int check_program(Service_T); |
| int check_URL(Service_T s); |
| int sha_md5_stream (FILE *, void *, void *); |
| void reset_procinfo(Service_T); |
| int check_service_status(Service_T); |
| void printhash(char *); |
| void status_xml(StringBuffer_T, Event_T, short, int, const char *); |
| int handle_mmonit(Event_T); |
| int do_wakeupcall(); |
| |
| #endif |
