diff options
author | RincewindsHat <12514511+RincewindsHat@users.noreply.github.com> | 2021-12-02 15:11:21 +0100 |
---|---|---|
committer | GitHub <noreply@github.com> | 2021-12-02 15:11:21 +0100 |
commit | df1e9e975f69c8f7965bab91684870fe509739c6 (patch) | |
tree | 526b0c77c524b2219d5a48fd78b8302f055a4a5b /plugins | |
parent | 6246b8f1830e8a375bc656deafd28aab715b4fd9 (diff) | |
parent | 1a3a715702a5b6709fed2a1eb53ec644c9968057 (diff) | |
download | monitoring-plugins-df1e9e975f69c8f7965bab91684870fe509739c6.tar.gz |
Merge branch 'master' into mailq-add-config-dir
Diffstat (limited to 'plugins')
62 files changed, 5362 insertions, 1007 deletions
diff --git a/plugins/Makefile.am b/plugins/Makefile.am index 0ddf9bd1..3fde54d6 100644 --- a/plugins/Makefile.am +++ b/plugins/Makefile.am | |||
@@ -38,7 +38,9 @@ check_tcp_programs = check_ftp check_imap check_nntp check_pop \ | |||
38 | EXTRA_PROGRAMS = check_mysql check_radius check_pgsql check_snmp check_hpjd \ | 38 | EXTRA_PROGRAMS = check_mysql check_radius check_pgsql check_snmp check_hpjd \ |
39 | check_swap check_fping check_ldap check_game check_dig \ | 39 | check_swap check_fping check_ldap check_game check_dig \ |
40 | check_nagios check_by_ssh check_dns check_nt check_ide_smart \ | 40 | check_nagios check_by_ssh check_dns check_nt check_ide_smart \ |
41 | check_procs check_mysql_query check_apt check_dbi | 41 | check_procs check_mysql_query check_apt check_dbi check_curl |
42 | |||
43 | SUBDIRS = picohttpparser | ||
42 | 44 | ||
43 | EXTRA_DIST = t tests | 45 | EXTRA_DIST = t tests |
44 | 46 | ||
@@ -69,6 +71,9 @@ test-debug: | |||
69 | 71 | ||
70 | check_apt_LDADD = $(BASEOBJS) | 72 | check_apt_LDADD = $(BASEOBJS) |
71 | check_cluster_LDADD = $(BASEOBJS) | 73 | check_cluster_LDADD = $(BASEOBJS) |
74 | check_curl_CFLAGS = $(AM_CFLAGS) $(LIBCURLCFLAGS) $(URIPARSERCFLAGS) $(LIBCURLINCLUDE) $(URIPARSERINCLUDE) -Ipicohttpparser | ||
75 | check_curl_CPPFLAGS = $(AM_CPPFLAGS) $(LIBCURLCFLAGS) $(URIPARSERCFLAGS) $(LIBCURLINCLUDE) $(URIPARSERINCLUDE) -Ipicohttpparser | ||
76 | check_curl_LDADD = $(NETLIBS) $(LIBCURLLIBS) $(SSLOBJS) $(URIPARSERLIBS) picohttpparser/libpicohttpparser.a | ||
72 | check_dbi_LDADD = $(NETLIBS) $(DBILIBS) | 77 | check_dbi_LDADD = $(NETLIBS) $(DBILIBS) |
73 | check_dig_LDADD = $(NETLIBS) | 78 | check_dig_LDADD = $(NETLIBS) |
74 | check_disk_LDADD = $(BASEOBJS) | 79 | check_disk_LDADD = $(BASEOBJS) |
@@ -89,7 +94,7 @@ check_mysql_query_CFLAGS = $(AM_CFLAGS) $(MYSQLCFLAGS) | |||
89 | check_mysql_query_CPPFLAGS = $(AM_CPPFLAGS) $(MYSQLINCLUDE) | 94 | check_mysql_query_CPPFLAGS = $(AM_CPPFLAGS) $(MYSQLINCLUDE) |
90 | check_mysql_query_LDADD = $(NETLIBS) $(MYSQLLIBS) | 95 | check_mysql_query_LDADD = $(NETLIBS) $(MYSQLLIBS) |
91 | check_nagios_LDADD = $(BASEOBJS) | 96 | check_nagios_LDADD = $(BASEOBJS) |
92 | check_nt_LDADD = $(NETLIBS) | 97 | check_nt_LDADD = $(NETLIBS) |
93 | check_ntp_LDADD = $(NETLIBS) $(MATHLIBS) | 98 | check_ntp_LDADD = $(NETLIBS) $(MATHLIBS) |
94 | check_ntp_peer_LDADD = $(NETLIBS) $(MATHLIBS) | 99 | check_ntp_peer_LDADD = $(NETLIBS) $(MATHLIBS) |
95 | check_nwstat_LDADD = $(NETLIBS) | 100 | check_nwstat_LDADD = $(NETLIBS) |
diff --git a/plugins/check_apt.c b/plugins/check_apt.c index b69680c2..d7be5750 100644 --- a/plugins/check_apt.c +++ b/plugins/check_apt.c | |||
@@ -86,6 +86,8 @@ static char *do_include = NULL; /* regexp to only include certain packages */ | |||
86 | static char *do_exclude = NULL; /* regexp to only exclude certain packages */ | 86 | static char *do_exclude = NULL; /* regexp to only exclude certain packages */ |
87 | static char *do_critical = NULL; /* regexp specifying critical packages */ | 87 | static char *do_critical = NULL; /* regexp specifying critical packages */ |
88 | static char *input_filename = NULL; /* input filename for testing */ | 88 | static char *input_filename = NULL; /* input filename for testing */ |
89 | /* number of packages available for upgrade to return WARNING status */ | ||
90 | static int packages_warning = 1; | ||
89 | 91 | ||
90 | /* other global variables */ | 92 | /* other global variables */ |
91 | static int stderr_warning = 0; /* if a cmd issued output on stderr */ | 93 | static int stderr_warning = 0; /* if a cmd issued output on stderr */ |
@@ -117,7 +119,7 @@ int main (int argc, char **argv) { | |||
117 | 119 | ||
118 | if(sec_count > 0){ | 120 | if(sec_count > 0){ |
119 | result = max_state(result, STATE_CRITICAL); | 121 | result = max_state(result, STATE_CRITICAL); |
120 | } else if(packages_available > 0 && only_critical == 0){ | 122 | } else if(packages_available >= packages_warning && only_critical == 0){ |
121 | result = max_state(result, STATE_WARNING); | 123 | result = max_state(result, STATE_WARNING); |
122 | } else if(result > STATE_UNKNOWN){ | 124 | } else if(result > STATE_UNKNOWN){ |
123 | result = STATE_UNKNOWN; | 125 | result = STATE_UNKNOWN; |
@@ -170,11 +172,12 @@ int process_arguments (int argc, char **argv) { | |||
170 | {"critical", required_argument, 0, 'c'}, | 172 | {"critical", required_argument, 0, 'c'}, |
171 | {"only-critical", no_argument, 0, 'o'}, | 173 | {"only-critical", no_argument, 0, 'o'}, |
172 | {"input-file", required_argument, 0, INPUT_FILE_OPT}, | 174 | {"input-file", required_argument, 0, INPUT_FILE_OPT}, |
175 | {"packages-warning", required_argument, 0, 'w'}, | ||
173 | {0, 0, 0, 0} | 176 | {0, 0, 0, 0} |
174 | }; | 177 | }; |
175 | 178 | ||
176 | while(1) { | 179 | while(1) { |
177 | c = getopt_long(argc, argv, "hVvt:u::U::d::nli:e:c:o", longopts, NULL); | 180 | c = getopt_long(argc, argv, "hVvt:u::U::d::nli:e:c:ow:", longopts, NULL); |
178 | 181 | ||
179 | if(c == -1 || c == EOF || c == 1) break; | 182 | if(c == -1 || c == EOF || c == 1) break; |
180 | 183 | ||
@@ -233,6 +236,9 @@ int process_arguments (int argc, char **argv) { | |||
233 | case INPUT_FILE_OPT: | 236 | case INPUT_FILE_OPT: |
234 | input_filename = optarg; | 237 | input_filename = optarg; |
235 | break; | 238 | break; |
239 | case 'w': | ||
240 | packages_warning = atoi(optarg); | ||
241 | break; | ||
236 | default: | 242 | default: |
237 | /* print short usage statement if args not parsable */ | 243 | /* print short usage statement if args not parsable */ |
238 | usage5(); | 244 | usage5(); |
@@ -530,7 +536,10 @@ print_help (void) | |||
530 | printf (" %s\n", "-o, --only-critical"); | 536 | printf (" %s\n", "-o, --only-critical"); |
531 | printf (" %s\n", _("Only warn about upgrades matching the critical list. The total number")); | 537 | printf (" %s\n", _("Only warn about upgrades matching the critical list. The total number")); |
532 | printf (" %s\n", _("of upgrades will be printed, but any non-critical upgrades will not cause")); | 538 | printf (" %s\n", _("of upgrades will be printed, but any non-critical upgrades will not cause")); |
533 | printf (" %s\n\n", _("the plugin to return WARNING status.")); | 539 | printf (" %s\n", _("the plugin to return WARNING status.")); |
540 | printf (" %s\n", "-w, --packages-warning"); | ||
541 | printf (" %s\n", _("Minumum number of packages available for upgrade to return WARNING status.")); | ||
542 | printf (" %s\n\n", _("Default is 1 package.")); | ||
534 | 543 | ||
535 | printf ("%s\n\n", _("The following options require root privileges and should be used with care:")); | 544 | printf ("%s\n\n", _("The following options require root privileges and should be used with care:")); |
536 | printf (" %s\n", "-u, --update=OPTS"); | 545 | printf (" %s\n", "-u, --update=OPTS"); |
@@ -548,5 +557,5 @@ void | |||
548 | print_usage(void) | 557 | print_usage(void) |
549 | { | 558 | { |
550 | printf ("%s\n", _("Usage:")); | 559 | printf ("%s\n", _("Usage:")); |
551 | printf ("%s [[-d|-u|-U]opts] [-n] [-l] [-t timeout]\n", progname); | 560 | printf ("%s [[-d|-u|-U]opts] [-n] [-l] [-t timeout] [-w packages-warning]\n", progname); |
552 | } | 561 | } |
diff --git a/plugins/check_by_ssh.c b/plugins/check_by_ssh.c index 13d8bc3b..485bf3be 100644 --- a/plugins/check_by_ssh.c +++ b/plugins/check_by_ssh.c | |||
@@ -230,7 +230,6 @@ process_arguments (int argc, char **argv) | |||
230 | timeout_interval = atoi (optarg); | 230 | timeout_interval = atoi (optarg); |
231 | break; | 231 | break; |
232 | case 'H': /* host */ | 232 | case 'H': /* host */ |
233 | host_or_die(optarg); | ||
234 | hostname = optarg; | 233 | hostname = optarg; |
235 | break; | 234 | break; |
236 | case 'p': /* port number */ | 235 | case 'p': /* port number */ |
@@ -329,7 +328,6 @@ process_arguments (int argc, char **argv) | |||
329 | if (c <= argc) { | 328 | if (c <= argc) { |
330 | die (STATE_UNKNOWN, _("%s: You must provide a host name\n"), progname); | 329 | die (STATE_UNKNOWN, _("%s: You must provide a host name\n"), progname); |
331 | } | 330 | } |
332 | host_or_die(argv[c]); | ||
333 | hostname = argv[c++]; | 331 | hostname = argv[c++]; |
334 | } | 332 | } |
335 | 333 | ||
diff --git a/plugins/check_cluster.c b/plugins/check_cluster.c index b86e501d..e1ede9f7 100644 --- a/plugins/check_cluster.c +++ b/plugins/check_cluster.c | |||
@@ -143,6 +143,7 @@ int main(int argc, char **argv){ | |||
143 | 143 | ||
144 | int process_arguments(int argc, char **argv){ | 144 | int process_arguments(int argc, char **argv){ |
145 | int c; | 145 | int c; |
146 | char *ptr; | ||
146 | int option=0; | 147 | int option=0; |
147 | static struct option longopts[]={ | 148 | static struct option longopts[]={ |
148 | {"data", required_argument,0,'d'}, | 149 | {"data", required_argument,0,'d'}, |
@@ -188,6 +189,15 @@ int process_arguments(int argc, char **argv){ | |||
188 | 189 | ||
189 | case 'd': /* data values */ | 190 | case 'd': /* data values */ |
190 | data_vals=(char *)strdup(optarg); | 191 | data_vals=(char *)strdup(optarg); |
192 | /* validate data */ | ||
193 | for (ptr=data_vals;ptr!=NULL;ptr+=2){ | ||
194 | if (ptr[0]<'0' || ptr[0]>'3') | ||
195 | return ERROR; | ||
196 | if (ptr[1]=='\0') | ||
197 | break; | ||
198 | if (ptr[1]!=',') | ||
199 | return ERROR; | ||
200 | } | ||
191 | break; | 201 | break; |
192 | 202 | ||
193 | case 'l': /* text label */ | 203 | case 'l': /* text label */ |
diff --git a/plugins/check_curl.c b/plugins/check_curl.c new file mode 100644 index 00000000..14cc8463 --- /dev/null +++ b/plugins/check_curl.c | |||
@@ -0,0 +1,2467 @@ | |||
1 | /***************************************************************************** | ||
2 | * | ||
3 | * Monitoring check_curl plugin | ||
4 | * | ||
5 | * License: GPL | ||
6 | * Copyright (c) 1999-2019 Monitoring Plugins Development Team | ||
7 | * | ||
8 | * Description: | ||
9 | * | ||
10 | * This file contains the check_curl plugin | ||
11 | * | ||
12 | * This plugin tests the HTTP service on the specified host. It can test | ||
13 | * normal (http) and secure (https) servers, follow redirects, search for | ||
14 | * strings and regular expressions, check connection times, and report on | ||
15 | * certificate expiration times. | ||
16 | * | ||
17 | * This plugin uses functions from the curl library, see | ||
18 | * http://curl.haxx.se | ||
19 | * | ||
20 | * This program is free software: you can redistribute it and/or modify | ||
21 | * it under the terms of the GNU General Public License as published by | ||
22 | * the Free Software Foundation, either version 3 of the License, or | ||
23 | * (at your option) any later version. | ||
24 | * | ||
25 | * This program is distributed in the hope that it will be useful, | ||
26 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
27 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
28 | * GNU General Public License for more details. | ||
29 | * | ||
30 | * You should have received a copy of the GNU General Public License | ||
31 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
32 | * | ||
33 | * | ||
34 | *****************************************************************************/ | ||
35 | const char *progname = "check_curl"; | ||
36 | |||
37 | const char *copyright = "2006-2019"; | ||
38 | const char *email = "devel@monitoring-plugins.org"; | ||
39 | |||
40 | #include <ctype.h> | ||
41 | |||
42 | #include "common.h" | ||
43 | #include "utils.h" | ||
44 | |||
45 | #ifndef LIBCURL_PROTOCOL_HTTP | ||
46 | #error libcurl compiled without HTTP support, compiling check_curl plugin does not makes a lot of sense | ||
47 | #endif | ||
48 | |||
49 | #include "curl/curl.h" | ||
50 | #include "curl/easy.h" | ||
51 | |||
52 | #include "picohttpparser.h" | ||
53 | |||
54 | #include "uriparser/Uri.h" | ||
55 | |||
56 | #include <arpa/inet.h> | ||
57 | |||
58 | #if defined(HAVE_SSL) && defined(USE_OPENSSL) | ||
59 | #include <openssl/opensslv.h> | ||
60 | #endif | ||
61 | |||
62 | #include <netdb.h> | ||
63 | |||
64 | #define MAKE_LIBCURL_VERSION(major, minor, patch) ((major)*0x10000 + (minor)*0x100 + (patch)) | ||
65 | |||
66 | #define DEFAULT_BUFFER_SIZE 2048 | ||
67 | #define DEFAULT_SERVER_URL "/" | ||
68 | #define HTTP_EXPECT "HTTP/" | ||
69 | #define DEFAULT_MAX_REDIRS 15 | ||
70 | #define INET_ADDR_MAX_SIZE INET6_ADDRSTRLEN | ||
71 | enum { | ||
72 | MAX_IPV4_HOSTLENGTH = 255, | ||
73 | HTTP_PORT = 80, | ||
74 | HTTPS_PORT = 443, | ||
75 | MAX_PORT = 65535 | ||
76 | }; | ||
77 | |||
78 | enum { | ||
79 | STICKY_NONE = 0, | ||
80 | STICKY_HOST = 1, | ||
81 | STICKY_PORT = 2 | ||
82 | }; | ||
83 | |||
84 | enum { | ||
85 | FOLLOW_HTTP_CURL = 0, | ||
86 | FOLLOW_LIBCURL = 1 | ||
87 | }; | ||
88 | |||
89 | /* for buffers for header and body */ | ||
90 | typedef struct { | ||
91 | char *buf; | ||
92 | size_t buflen; | ||
93 | size_t bufsize; | ||
94 | } curlhelp_write_curlbuf; | ||
95 | |||
96 | /* for buffering the data sent in PUT */ | ||
97 | typedef struct { | ||
98 | char *buf; | ||
99 | size_t buflen; | ||
100 | off_t pos; | ||
101 | } curlhelp_read_curlbuf; | ||
102 | |||
103 | /* for parsing the HTTP status line */ | ||
104 | typedef struct { | ||
105 | int http_major; /* major version of the protocol, always 1 (HTTP/0.9 | ||
106 | * never reached the big internet most likely) */ | ||
107 | int http_minor; /* minor version of the protocol, usually 0 or 1 */ | ||
108 | int http_code; /* HTTP return code as in RFC 2145 */ | ||
109 | int http_subcode; /* Microsoft IIS extension, HTTP subcodes, see | ||
110 | * http://support.microsoft.com/kb/318380/en-us */ | ||
111 | const char *msg; /* the human readable message */ | ||
112 | char *first_line; /* a copy of the first line */ | ||
113 | } curlhelp_statusline; | ||
114 | |||
115 | /* to know the underlying SSL library used by libcurl */ | ||
116 | typedef enum curlhelp_ssl_library { | ||
117 | CURLHELP_SSL_LIBRARY_UNKNOWN, | ||
118 | CURLHELP_SSL_LIBRARY_OPENSSL, | ||
119 | CURLHELP_SSL_LIBRARY_LIBRESSL, | ||
120 | CURLHELP_SSL_LIBRARY_GNUTLS, | ||
121 | CURLHELP_SSL_LIBRARY_NSS | ||
122 | } curlhelp_ssl_library; | ||
123 | |||
124 | enum { | ||
125 | REGS = 2, | ||
126 | MAX_RE_SIZE = 1024 | ||
127 | }; | ||
128 | #include "regex.h" | ||
129 | regex_t preg; | ||
130 | regmatch_t pmatch[REGS]; | ||
131 | char regexp[MAX_RE_SIZE]; | ||
132 | int cflags = REG_NOSUB | REG_EXTENDED | REG_NEWLINE; | ||
133 | int errcode; | ||
134 | int invert_regex = 0; | ||
135 | |||
136 | char *server_address = NULL; | ||
137 | char *host_name = NULL; | ||
138 | char *server_url = 0; | ||
139 | char server_ip[DEFAULT_BUFFER_SIZE]; | ||
140 | struct curl_slist *server_ips = NULL; | ||
141 | int specify_port = FALSE; | ||
142 | unsigned short server_port = HTTP_PORT; | ||
143 | unsigned short virtual_port = 0; | ||
144 | int host_name_length; | ||
145 | char output_header_search[30] = ""; | ||
146 | char output_string_search[30] = ""; | ||
147 | char *warning_thresholds = NULL; | ||
148 | char *critical_thresholds = NULL; | ||
149 | int days_till_exp_warn, days_till_exp_crit; | ||
150 | thresholds *thlds; | ||
151 | char user_agent[DEFAULT_BUFFER_SIZE]; | ||
152 | int verbose = 0; | ||
153 | int show_extended_perfdata = FALSE; | ||
154 | int show_body = FALSE; | ||
155 | int min_page_len = 0; | ||
156 | int max_page_len = 0; | ||
157 | int redir_depth = 0; | ||
158 | int max_depth = DEFAULT_MAX_REDIRS; | ||
159 | char *http_method = NULL; | ||
160 | char *http_post_data = NULL; | ||
161 | char *http_content_type = NULL; | ||
162 | CURL *curl; | ||
163 | struct curl_slist *header_list = NULL; | ||
164 | curlhelp_write_curlbuf body_buf; | ||
165 | curlhelp_write_curlbuf header_buf; | ||
166 | curlhelp_statusline status_line; | ||
167 | curlhelp_read_curlbuf put_buf; | ||
168 | char http_header[DEFAULT_BUFFER_SIZE]; | ||
169 | long code; | ||
170 | long socket_timeout = DEFAULT_SOCKET_TIMEOUT; | ||
171 | double total_time; | ||
172 | double time_connect; | ||
173 | double time_appconnect; | ||
174 | double time_headers; | ||
175 | double time_firstbyte; | ||
176 | char errbuf[CURL_ERROR_SIZE+1]; | ||
177 | CURLcode res; | ||
178 | char url[DEFAULT_BUFFER_SIZE]; | ||
179 | char msg[DEFAULT_BUFFER_SIZE]; | ||
180 | char perfstring[DEFAULT_BUFFER_SIZE]; | ||
181 | char header_expect[MAX_INPUT_BUFFER] = ""; | ||
182 | char string_expect[MAX_INPUT_BUFFER] = ""; | ||
183 | char server_expect[MAX_INPUT_BUFFER] = HTTP_EXPECT; | ||
184 | int server_expect_yn = 0; | ||
185 | char user_auth[MAX_INPUT_BUFFER] = ""; | ||
186 | char proxy_auth[MAX_INPUT_BUFFER] = ""; | ||
187 | char **http_opt_headers; | ||
188 | int http_opt_headers_count = 0; | ||
189 | int display_html = FALSE; | ||
190 | int onredirect = STATE_OK; | ||
191 | int followmethod = FOLLOW_HTTP_CURL; | ||
192 | int followsticky = STICKY_NONE; | ||
193 | int use_ssl = FALSE; | ||
194 | int use_sni = TRUE; | ||
195 | int check_cert = FALSE; | ||
196 | typedef union { | ||
197 | struct curl_slist* to_info; | ||
198 | struct curl_certinfo* to_certinfo; | ||
199 | } cert_ptr_union; | ||
200 | cert_ptr_union cert_ptr; | ||
201 | int ssl_version = CURL_SSLVERSION_DEFAULT; | ||
202 | char *client_cert = NULL; | ||
203 | char *client_privkey = NULL; | ||
204 | char *ca_cert = NULL; | ||
205 | int verify_peer_and_host = FALSE; | ||
206 | int is_openssl_callback = FALSE; | ||
207 | #if defined(HAVE_SSL) && defined(USE_OPENSSL) | ||
208 | X509 *cert = NULL; | ||
209 | #endif /* defined(HAVE_SSL) && defined(USE_OPENSSL) */ | ||
210 | int no_body = FALSE; | ||
211 | int maximum_age = -1; | ||
212 | int address_family = AF_UNSPEC; | ||
213 | curlhelp_ssl_library ssl_library = CURLHELP_SSL_LIBRARY_UNKNOWN; | ||
214 | int curl_http_version = CURL_HTTP_VERSION_NONE; | ||
215 | int automatic_decompression = FALSE; | ||
216 | |||
217 | int process_arguments (int, char**); | ||
218 | void handle_curl_option_return_code (CURLcode res, const char* option); | ||
219 | int check_http (void); | ||
220 | void redir (curlhelp_write_curlbuf*); | ||
221 | char *perfd_time (double microsec); | ||
222 | char *perfd_time_connect (double microsec); | ||
223 | char *perfd_time_ssl (double microsec); | ||
224 | char *perfd_time_firstbyte (double microsec); | ||
225 | char *perfd_time_headers (double microsec); | ||
226 | char *perfd_time_transfer (double microsec); | ||
227 | char *perfd_size (int page_len); | ||
228 | void print_help (void); | ||
229 | void print_usage (void); | ||
230 | void print_curl_version (void); | ||
231 | int curlhelp_initwritebuffer (curlhelp_write_curlbuf*); | ||
232 | int curlhelp_buffer_write_callback (void*, size_t , size_t , void*); | ||
233 | void curlhelp_freewritebuffer (curlhelp_write_curlbuf*); | ||
234 | int curlhelp_initreadbuffer (curlhelp_read_curlbuf *, const char *, size_t); | ||
235 | int curlhelp_buffer_read_callback (void *, size_t , size_t , void *); | ||
236 | void curlhelp_freereadbuffer (curlhelp_read_curlbuf *); | ||
237 | curlhelp_ssl_library curlhelp_get_ssl_library (CURL*); | ||
238 | const char* curlhelp_get_ssl_library_string (curlhelp_ssl_library); | ||
239 | int net_noopenssl_check_certificate (cert_ptr_union*, int, int); | ||
240 | |||
241 | int curlhelp_parse_statusline (const char*, curlhelp_statusline *); | ||
242 | void curlhelp_free_statusline (curlhelp_statusline *); | ||
243 | char *get_header_value (const struct phr_header* headers, const size_t nof_headers, const char* header); | ||
244 | int check_document_dates (const curlhelp_write_curlbuf *, char (*msg)[DEFAULT_BUFFER_SIZE]); | ||
245 | int get_content_length (const curlhelp_write_curlbuf* header_buf, const curlhelp_write_curlbuf* body_buf); | ||
246 | |||
247 | #if defined(HAVE_SSL) && defined(USE_OPENSSL) | ||
248 | int np_net_ssl_check_certificate(X509 *certificate, int days_till_exp_warn, int days_till_exp_crit); | ||
249 | #endif /* defined(HAVE_SSL) && defined(USE_OPENSSL) */ | ||
250 | |||
251 | void remove_newlines (char *); | ||
252 | void test_file (char *); | ||
253 | |||
254 | int | ||
255 | main (int argc, char **argv) | ||
256 | { | ||
257 | int result = STATE_UNKNOWN; | ||
258 | |||
259 | setlocale (LC_ALL, ""); | ||
260 | bindtextdomain (PACKAGE, LOCALEDIR); | ||
261 | textdomain (PACKAGE); | ||
262 | |||
263 | /* Parse extra opts if any */ | ||
264 | argv = np_extra_opts (&argc, argv, progname); | ||
265 | |||
266 | /* set defaults */ | ||
267 | snprintf( user_agent, DEFAULT_BUFFER_SIZE, "%s/v%s (monitoring-plugins %s, %s)", | ||
268 | progname, NP_VERSION, VERSION, curl_version()); | ||
269 | |||
270 | /* parse arguments */ | ||
271 | if (process_arguments (argc, argv) == ERROR) | ||
272 | usage4 (_("Could not parse arguments")); | ||
273 | |||
274 | if (display_html == TRUE) | ||
275 | printf ("<A HREF=\"%s://%s:%d%s\" target=\"_blank\">", | ||
276 | use_ssl ? "https" : "http", | ||
277 | host_name ? host_name : server_address, | ||
278 | virtual_port ? virtual_port : server_port, | ||
279 | server_url); | ||
280 | |||
281 | result = check_http (); | ||
282 | return result; | ||
283 | } | ||
284 | |||
285 | #ifdef HAVE_SSL | ||
286 | #ifdef USE_OPENSSL | ||
287 | |||
288 | int verify_callback(int preverify_ok, X509_STORE_CTX *x509_ctx) | ||
289 | { | ||
290 | /* TODO: we get all certificates of the chain, so which ones | ||
291 | * should we test? | ||
292 | * TODO: is the last certificate always the server certificate? | ||
293 | */ | ||
294 | cert = X509_STORE_CTX_get_current_cert(x509_ctx); | ||
295 | #if OPENSSL_VERSION_NUMBER >= 0x10100000L | ||
296 | X509_up_ref(cert); | ||
297 | #endif | ||
298 | if (verbose>=2) { | ||
299 | puts("* SSL verify callback with certificate:"); | ||
300 | X509_NAME *subject, *issuer; | ||
301 | printf("* issuer:\n"); | ||
302 | issuer = X509_get_issuer_name( cert ); | ||
303 | X509_NAME_print_ex_fp(stdout, issuer, 5, XN_FLAG_MULTILINE); | ||
304 | printf("* curl verify_callback:\n* subject:\n"); | ||
305 | subject = X509_get_subject_name( cert ); | ||
306 | X509_NAME_print_ex_fp(stdout, subject, 5, XN_FLAG_MULTILINE); | ||
307 | puts(""); | ||
308 | } | ||
309 | return 1; | ||
310 | } | ||
311 | |||
312 | CURLcode sslctxfun(CURL *curl, SSL_CTX *sslctx, void *parm) | ||
313 | { | ||
314 | SSL_CTX_set_verify(sslctx, SSL_VERIFY_PEER, verify_callback); | ||
315 | |||
316 | return CURLE_OK; | ||
317 | } | ||
318 | |||
319 | #endif /* USE_OPENSSL */ | ||
320 | #endif /* HAVE_SSL */ | ||
321 | |||
322 | /* returns a string "HTTP/1.x" or "HTTP/2" */ | ||
323 | static char *string_statuscode (int major, int minor) | ||
324 | { | ||
325 | static char buf[10]; | ||
326 | |||
327 | switch (major) { | ||
328 | case 1: | ||
329 | snprintf (buf, sizeof (buf), "HTTP/%d.%d", major, minor); | ||
330 | break; | ||
331 | case 2: | ||
332 | case 3: | ||
333 | snprintf (buf, sizeof (buf), "HTTP/%d", major); | ||
334 | break; | ||
335 | default: | ||
336 | /* assuming here HTTP/N with N>=4 */ | ||
337 | snprintf (buf, sizeof (buf), "HTTP/%d", major); | ||
338 | break; | ||
339 | } | ||
340 | |||
341 | return buf; | ||
342 | } | ||
343 | |||
344 | /* Checks if the server 'reply' is one of the expected 'statuscodes' */ | ||
345 | static int | ||
346 | expected_statuscode (const char *reply, const char *statuscodes) | ||
347 | { | ||
348 | char *expected, *code; | ||
349 | int result = 0; | ||
350 | |||
351 | if ((expected = strdup (statuscodes)) == NULL) | ||
352 | die (STATE_UNKNOWN, _("HTTP UNKNOWN - Memory allocation error\n")); | ||
353 | |||
354 | for (code = strtok (expected, ","); code != NULL; code = strtok (NULL, ",")) | ||
355 | if (strstr (reply, code) != NULL) { | ||
356 | result = 1; | ||
357 | break; | ||
358 | } | ||
359 | |||
360 | free (expected); | ||
361 | return result; | ||
362 | } | ||
363 | |||
364 | void | ||
365 | handle_curl_option_return_code (CURLcode res, const char* option) | ||
366 | { | ||
367 | if (res != CURLE_OK) { | ||
368 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("Error while setting cURL option '%s': cURL returned %d - %s"), | ||
369 | option, res, curl_easy_strerror(res)); | ||
370 | die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg); | ||
371 | } | ||
372 | } | ||
373 | |||
374 | int | ||
375 | lookup_host (const char *host, char *buf, size_t buflen) | ||
376 | { | ||
377 | struct addrinfo hints, *res, *result; | ||
378 | int errcode; | ||
379 | void *ptr; | ||
380 | |||
381 | memset (&hints, 0, sizeof (hints)); | ||
382 | hints.ai_family = address_family; | ||
383 | hints.ai_socktype = SOCK_STREAM; | ||
384 | hints.ai_flags |= AI_CANONNAME; | ||
385 | |||
386 | errcode = getaddrinfo (host, NULL, &hints, &result); | ||
387 | if (errcode != 0) | ||
388 | return errcode; | ||
389 | |||
390 | res = result; | ||
391 | |||
392 | while (res) { | ||
393 | inet_ntop (res->ai_family, res->ai_addr->sa_data, buf, buflen); | ||
394 | switch (res->ai_family) { | ||
395 | case AF_INET: | ||
396 | ptr = &((struct sockaddr_in *) res->ai_addr)->sin_addr; | ||
397 | break; | ||
398 | case AF_INET6: | ||
399 | ptr = &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr; | ||
400 | break; | ||
401 | } | ||
402 | inet_ntop (res->ai_family, ptr, buf, buflen); | ||
403 | if (verbose >= 1) | ||
404 | printf ("* getaddrinfo IPv%d address: %s\n", | ||
405 | res->ai_family == PF_INET6 ? 6 : 4, buf); | ||
406 | res = res->ai_next; | ||
407 | } | ||
408 | |||
409 | freeaddrinfo(result); | ||
410 | |||
411 | return 0; | ||
412 | } | ||
413 | |||
414 | int | ||
415 | check_http (void) | ||
416 | { | ||
417 | int result = STATE_OK; | ||
418 | int page_len = 0; | ||
419 | int i; | ||
420 | char *force_host_header = NULL; | ||
421 | struct curl_slist *host = NULL; | ||
422 | char addrstr[100]; | ||
423 | char dnscache[DEFAULT_BUFFER_SIZE]; | ||
424 | |||
425 | /* initialize curl */ | ||
426 | if (curl_global_init (CURL_GLOBAL_DEFAULT) != CURLE_OK) | ||
427 | die (STATE_UNKNOWN, "HTTP UNKNOWN - curl_global_init failed\n"); | ||
428 | |||
429 | if ((curl = curl_easy_init()) == NULL) | ||
430 | die (STATE_UNKNOWN, "HTTP UNKNOWN - curl_easy_init failed\n"); | ||
431 | |||
432 | if (verbose >= 1) | ||
433 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_VERBOSE, TRUE), "CURLOPT_VERBOSE"); | ||
434 | |||
435 | /* print everything on stdout like check_http would do */ | ||
436 | handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_STDERR, stdout), "CURLOPT_STDERR"); | ||
437 | |||
438 | if (automatic_decompression) | ||
439 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 21, 6) | ||
440 | handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, ""), "CURLOPT_ACCEPT_ENCODING"); | ||
441 | #else | ||
442 | handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_ENCODING, ""), "CURLOPT_ENCODING"); | ||
443 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 21, 6) */ | ||
444 | |||
445 | /* initialize buffer for body of the answer */ | ||
446 | if (curlhelp_initwritebuffer(&body_buf) < 0) | ||
447 | die (STATE_UNKNOWN, "HTTP CRITICAL - out of memory allocating buffer for body\n"); | ||
448 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)curlhelp_buffer_write_callback), "CURLOPT_WRITEFUNCTION"); | ||
449 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_WRITEDATA, (void *)&body_buf), "CURLOPT_WRITEDATA"); | ||
450 | |||
451 | /* initialize buffer for header of the answer */ | ||
452 | if (curlhelp_initwritebuffer( &header_buf ) < 0) | ||
453 | die (STATE_UNKNOWN, "HTTP CRITICAL - out of memory allocating buffer for header\n" ); | ||
454 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)curlhelp_buffer_write_callback), "CURLOPT_HEADERFUNCTION"); | ||
455 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_WRITEHEADER, (void *)&header_buf), "CURLOPT_WRITEHEADER"); | ||
456 | |||
457 | /* set the error buffer */ | ||
458 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_ERRORBUFFER, errbuf), "CURLOPT_ERRORBUFFER"); | ||
459 | |||
460 | /* set timeouts */ | ||
461 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CONNECTTIMEOUT, socket_timeout), "CURLOPT_CONNECTTIMEOUT"); | ||
462 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_TIMEOUT, socket_timeout), "CURLOPT_TIMEOUT"); | ||
463 | |||
464 | // fill dns resolve cache to make curl connect to the given server_address instead of the host_name, only required for ssl, because we use the host_name later on to make SNI happy | ||
465 | if(use_ssl && host_name != NULL) { | ||
466 | if ( (res=lookup_host (server_address, addrstr, 100)) != 0) { | ||
467 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("Unable to lookup IP address for '%s': getaddrinfo returned %d - %s"), | ||
468 | server_address, res, gai_strerror (res)); | ||
469 | die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg); | ||
470 | } | ||
471 | snprintf (dnscache, DEFAULT_BUFFER_SIZE, "%s:%d:%s", host_name, server_port, addrstr); | ||
472 | host = curl_slist_append(NULL, dnscache); | ||
473 | curl_easy_setopt(curl, CURLOPT_RESOLVE, host); | ||
474 | if (verbose>=1) | ||
475 | printf ("* curl CURLOPT_RESOLVE: %s\n", dnscache); | ||
476 | } | ||
477 | |||
478 | /* compose URL: use the address we want to connect to, set Host: header later */ | ||
479 | snprintf (url, DEFAULT_BUFFER_SIZE, "%s://%s:%d%s", | ||
480 | use_ssl ? "https" : "http", | ||
481 | use_ssl & host_name != NULL ? host_name : server_address, | ||
482 | server_port, | ||
483 | server_url | ||
484 | ); | ||
485 | |||
486 | if (verbose>=1) | ||
487 | printf ("* curl CURLOPT_URL: %s\n", url); | ||
488 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_URL, url), "CURLOPT_URL"); | ||
489 | |||
490 | /* extract proxy information for legacy proxy https requests */ | ||
491 | if (!strcmp(http_method, "CONNECT") || strstr(server_url, "http") == server_url) { | ||
492 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_PROXY, server_address), "CURLOPT_PROXY"); | ||
493 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_PROXYPORT, (long)server_port), "CURLOPT_PROXYPORT"); | ||
494 | if (verbose>=2) | ||
495 | printf ("* curl CURLOPT_PROXY: %s:%d\n", server_address, server_port); | ||
496 | http_method = "GET"; | ||
497 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_URL, server_url), "CURLOPT_URL"); | ||
498 | } | ||
499 | |||
500 | /* disable body for HEAD request */ | ||
501 | if (http_method && !strcmp (http_method, "HEAD" )) { | ||
502 | no_body = TRUE; | ||
503 | } | ||
504 | |||
505 | /* set HTTP protocol version */ | ||
506 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_HTTP_VERSION, curl_http_version), "CURLOPT_HTTP_VERSION"); | ||
507 | |||
508 | /* set HTTP method */ | ||
509 | if (http_method) { | ||
510 | if (!strcmp(http_method, "POST")) | ||
511 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_POST, 1), "CURLOPT_POST"); | ||
512 | else if (!strcmp(http_method, "PUT")) | ||
513 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_UPLOAD, 1), "CURLOPT_UPLOAD"); | ||
514 | else | ||
515 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CUSTOMREQUEST, http_method), "CURLOPT_CUSTOMREQUEST"); | ||
516 | } | ||
517 | |||
518 | /* check if Host header is explicitly set in options */ | ||
519 | if (http_opt_headers_count) { | ||
520 | for (i = 0; i < http_opt_headers_count ; i++) { | ||
521 | if (strncmp(http_opt_headers[i], "Host:", 5) == 0) { | ||
522 | force_host_header = http_opt_headers[i]; | ||
523 | } | ||
524 | } | ||
525 | } | ||
526 | |||
527 | /* set hostname (virtual hosts), not needed if CURLOPT_CONNECT_TO is used, but left in anyway */ | ||
528 | if(host_name != NULL && force_host_header == NULL) { | ||
529 | if((virtual_port != HTTP_PORT && !use_ssl) || (virtual_port != HTTPS_PORT && use_ssl)) { | ||
530 | snprintf(http_header, DEFAULT_BUFFER_SIZE, "Host: %s:%d", host_name, virtual_port); | ||
531 | } else { | ||
532 | snprintf(http_header, DEFAULT_BUFFER_SIZE, "Host: %s", host_name); | ||
533 | } | ||
534 | header_list = curl_slist_append (header_list, http_header); | ||
535 | } | ||
536 | |||
537 | /* always close connection, be nice to servers */ | ||
538 | snprintf (http_header, DEFAULT_BUFFER_SIZE, "Connection: close"); | ||
539 | header_list = curl_slist_append (header_list, http_header); | ||
540 | |||
541 | /* attach additional headers supplied by the user */ | ||
542 | /* optionally send any other header tag */ | ||
543 | if (http_opt_headers_count) { | ||
544 | for (i = 0; i < http_opt_headers_count ; i++) { | ||
545 | header_list = curl_slist_append (header_list, http_opt_headers[i]); | ||
546 | } | ||
547 | /* This cannot be free'd here because a redirection will then try to access this and segfault */ | ||
548 | /* Covered in a testcase in tests/check_http.t */ | ||
549 | /* free(http_opt_headers); */ | ||
550 | } | ||
551 | |||
552 | /* set HTTP headers */ | ||
553 | handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_HTTPHEADER, header_list ), "CURLOPT_HTTPHEADER"); | ||
554 | |||
555 | #ifdef LIBCURL_FEATURE_SSL | ||
556 | |||
557 | /* set SSL version, warn about unsecure or unsupported versions */ | ||
558 | if (use_ssl) { | ||
559 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSLVERSION, ssl_version), "CURLOPT_SSLVERSION"); | ||
560 | } | ||
561 | |||
562 | /* client certificate and key to present to server (SSL) */ | ||
563 | if (client_cert) | ||
564 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSLCERT, client_cert), "CURLOPT_SSLCERT"); | ||
565 | if (client_privkey) | ||
566 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSLKEY, client_privkey), "CURLOPT_SSLKEY"); | ||
567 | if (ca_cert) { | ||
568 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CAINFO, ca_cert), "CURLOPT_CAINFO"); | ||
569 | } | ||
570 | if (ca_cert || verify_peer_and_host) { | ||
571 | /* per default if we have a CA verify both the peer and the | ||
572 | * hostname in the certificate, can be switched off later */ | ||
573 | handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_SSL_VERIFYPEER, 1), "CURLOPT_SSL_VERIFYPEER"); | ||
574 | handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_SSL_VERIFYHOST, 2), "CURLOPT_SSL_VERIFYHOST"); | ||
575 | } else { | ||
576 | /* backward-compatible behaviour, be tolerant in checks | ||
577 | * TODO: depending on more options have aspects we want | ||
578 | * to be less tolerant about ssl verfications | ||
579 | */ | ||
580 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 0), "CURLOPT_SSL_VERIFYPEER"); | ||
581 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 0), "CURLOPT_SSL_VERIFYHOST"); | ||
582 | } | ||
583 | |||
584 | /* detect SSL library used by libcurl */ | ||
585 | ssl_library = curlhelp_get_ssl_library (curl); | ||
586 | |||
587 | /* try hard to get a stack of certificates to verify against */ | ||
588 | if (check_cert) { | ||
589 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 1) | ||
590 | /* inform curl to report back certificates */ | ||
591 | switch (ssl_library) { | ||
592 | case CURLHELP_SSL_LIBRARY_OPENSSL: | ||
593 | case CURLHELP_SSL_LIBRARY_LIBRESSL: | ||
594 | /* set callback to extract certificate with OpenSSL context function (works with | ||
595 | * OpenSSL-style libraries only!) */ | ||
596 | #ifdef USE_OPENSSL | ||
597 | /* libcurl and monitoring plugins built with OpenSSL, good */ | ||
598 | handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfun), "CURLOPT_SSL_CTX_FUNCTION"); | ||
599 | is_openssl_callback = TRUE; | ||
600 | #else /* USE_OPENSSL */ | ||
601 | #endif /* USE_OPENSSL */ | ||
602 | /* libcurl is built with OpenSSL, monitoring plugins, so falling | ||
603 | * back to manually extracting certificate information */ | ||
604 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CERTINFO, 1L), "CURLOPT_CERTINFO"); | ||
605 | break; | ||
606 | |||
607 | case CURLHELP_SSL_LIBRARY_NSS: | ||
608 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) | ||
609 | /* NSS: support for CERTINFO is implemented since 7.34.0 */ | ||
610 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CERTINFO, 1L), "CURLOPT_CERTINFO"); | ||
611 | #else /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */ | ||
612 | die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates (libcurl linked with SSL library '%s' is too old)\n", curlhelp_get_ssl_library_string (ssl_library)); | ||
613 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */ | ||
614 | break; | ||
615 | |||
616 | case CURLHELP_SSL_LIBRARY_GNUTLS: | ||
617 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 42, 0) | ||
618 | /* GnuTLS: support for CERTINFO is implemented since 7.42.0 */ | ||
619 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CERTINFO, 1L), "CURLOPT_CERTINFO"); | ||
620 | #else /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 42, 0) */ | ||
621 | die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates (libcurl linked with SSL library '%s' is too old)\n", curlhelp_get_ssl_library_string (ssl_library)); | ||
622 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 42, 0) */ | ||
623 | break; | ||
624 | |||
625 | case CURLHELP_SSL_LIBRARY_UNKNOWN: | ||
626 | default: | ||
627 | die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates (unknown SSL library '%s', must implement first)\n", curlhelp_get_ssl_library_string (ssl_library)); | ||
628 | break; | ||
629 | } | ||
630 | #else /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 1) */ | ||
631 | /* old libcurl, our only hope is OpenSSL, otherwise we are out of luck */ | ||
632 | if (ssl_library == CURLHELP_SSL_LIBRARY_OPENSSL || ssl_library == CURLHELP_SSL_LIBRARY_LIBRESSL) | ||
633 | handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfun), "CURLOPT_SSL_CTX_FUNCTION"); | ||
634 | else | ||
635 | die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates (no CURLOPT_SSL_CTX_FUNCTION, no OpenSSL library or libcurl too old and has no CURLOPT_CERTINFO)\n"); | ||
636 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 1) */ | ||
637 | } | ||
638 | |||
639 | #endif /* LIBCURL_FEATURE_SSL */ | ||
640 | |||
641 | /* set default or user-given user agent identification */ | ||
642 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_USERAGENT, user_agent), "CURLOPT_USERAGENT"); | ||
643 | |||
644 | /* proxy-authentication */ | ||
645 | if (strcmp(proxy_auth, "")) | ||
646 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_PROXYUSERPWD, proxy_auth), "CURLOPT_PROXYUSERPWD"); | ||
647 | |||
648 | /* authentication */ | ||
649 | if (strcmp(user_auth, "")) | ||
650 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_USERPWD, user_auth), "CURLOPT_USERPWD"); | ||
651 | |||
652 | /* TODO: parameter auth method, bitfield of following methods: | ||
653 | * CURLAUTH_BASIC (default) | ||
654 | * CURLAUTH_DIGEST | ||
655 | * CURLAUTH_DIGEST_IE | ||
656 | * CURLAUTH_NEGOTIATE | ||
657 | * CURLAUTH_NTLM | ||
658 | * CURLAUTH_NTLM_WB | ||
659 | * | ||
660 | * convenience tokens for typical sets of methods: | ||
661 | * CURLAUTH_ANYSAFE: most secure, without BASIC | ||
662 | * or CURLAUTH_ANY: most secure, even BASIC if necessary | ||
663 | * | ||
664 | * handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_DIGEST ), "CURLOPT_HTTPAUTH"); | ||
665 | */ | ||
666 | |||
667 | /* handle redirections */ | ||
668 | if (onredirect == STATE_DEPENDENT) { | ||
669 | if( followmethod == FOLLOW_LIBCURL ) { | ||
670 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_FOLLOWLOCATION, 1), "CURLOPT_FOLLOWLOCATION"); | ||
671 | |||
672 | /* default -1 is infinite, not good, could lead to zombie plugins! | ||
673 | Setting it to one bigger than maximal limit to handle errors nicely below | ||
674 | */ | ||
675 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_MAXREDIRS, max_depth+1), "CURLOPT_MAXREDIRS"); | ||
676 | |||
677 | /* for now allow only http and https (we are a http(s) check plugin in the end) */ | ||
678 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 4) | ||
679 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS), "CURLOPT_REDIRECT_PROTOCOLS"); | ||
680 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 4) */ | ||
681 | |||
682 | /* TODO: handle the following aspects of redirection, make them | ||
683 | * command line options too later: | ||
684 | CURLOPT_POSTREDIR: method switch | ||
685 | CURLINFO_REDIRECT_URL: custom redirect option | ||
686 | CURLOPT_REDIRECT_PROTOCOLS: allow people to step outside safe protocols | ||
687 | CURLINFO_REDIRECT_COUNT: get the number of redirects, print it, maybe a range option here is nice like for expected page size? | ||
688 | */ | ||
689 | } else { | ||
690 | /* old style redirection is handled below */ | ||
691 | } | ||
692 | } | ||
693 | |||
694 | /* no-body */ | ||
695 | if (no_body) | ||
696 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_NOBODY, 1), "CURLOPT_NOBODY"); | ||
697 | |||
698 | /* IPv4 or IPv6 forced DNS resolution */ | ||
699 | if (address_family == AF_UNSPEC) | ||
700 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_WHATEVER), "CURLOPT_IPRESOLVE(CURL_IPRESOLVE_WHATEVER)"); | ||
701 | else if (address_family == AF_INET) | ||
702 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4), "CURLOPT_IPRESOLVE(CURL_IPRESOLVE_V4)"); | ||
703 | #if defined (USE_IPV6) && defined (LIBCURL_FEATURE_IPV6) | ||
704 | else if (address_family == AF_INET6) | ||
705 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6), "CURLOPT_IPRESOLVE(CURL_IPRESOLVE_V6)"); | ||
706 | #endif | ||
707 | |||
708 | /* either send http POST data (any data, not only POST)*/ | ||
709 | if (!strcmp(http_method, "POST") ||!strcmp(http_method, "PUT")) { | ||
710 | /* set content of payload for POST and PUT */ | ||
711 | if (http_content_type) { | ||
712 | snprintf (http_header, DEFAULT_BUFFER_SIZE, "Content-Type: %s", http_content_type); | ||
713 | header_list = curl_slist_append (header_list, http_header); | ||
714 | } | ||
715 | /* NULL indicates "HTTP Continue" in libcurl, provide an empty string | ||
716 | * in case of no POST/PUT data */ | ||
717 | if (!http_post_data) | ||
718 | http_post_data = ""; | ||
719 | if (!strcmp(http_method, "POST")) { | ||
720 | /* POST method, set payload with CURLOPT_POSTFIELDS */ | ||
721 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_POSTFIELDS, http_post_data), "CURLOPT_POSTFIELDS"); | ||
722 | } else if (!strcmp(http_method, "PUT")) { | ||
723 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_READFUNCTION, (curl_read_callback)curlhelp_buffer_read_callback), "CURLOPT_READFUNCTION"); | ||
724 | curlhelp_initreadbuffer (&put_buf, http_post_data, strlen (http_post_data)); | ||
725 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_READDATA, (void *)&put_buf), "CURLOPT_READDATA"); | ||
726 | handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_INFILESIZE, (curl_off_t)strlen (http_post_data)), "CURLOPT_INFILESIZE"); | ||
727 | } | ||
728 | } | ||
729 | |||
730 | /* do the request */ | ||
731 | res = curl_easy_perform(curl); | ||
732 | |||
733 | if (verbose>=2 && http_post_data) | ||
734 | printf ("**** REQUEST CONTENT ****\n%s\n", http_post_data); | ||
735 | |||
736 | /* free header and server IP resolve lists, we don't need it anymore */ | ||
737 | curl_slist_free_all (header_list); header_list = NULL; | ||
738 | curl_slist_free_all (server_ips); server_ips = NULL; | ||
739 | |||
740 | /* Curl errors, result in critical Nagios state */ | ||
741 | if (res != CURLE_OK) { | ||
742 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("Invalid HTTP response received from host on port %d: cURL returned %d - %s"), | ||
743 | server_port, res, errbuf[0] ? errbuf : curl_easy_strerror(res)); | ||
744 | die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg); | ||
745 | } | ||
746 | |||
747 | /* certificate checks */ | ||
748 | #ifdef LIBCURL_FEATURE_SSL | ||
749 | if (use_ssl == TRUE) { | ||
750 | if (check_cert == TRUE) { | ||
751 | if (is_openssl_callback) { | ||
752 | #ifdef USE_OPENSSL | ||
753 | /* check certificate with OpenSSL functions, curl has been built against OpenSSL | ||
754 | * and we actually have OpenSSL in the monitoring tools | ||
755 | */ | ||
756 | result = np_net_ssl_check_certificate(cert, days_till_exp_warn, days_till_exp_crit); | ||
757 | return result; | ||
758 | #else /* USE_OPENSSL */ | ||
759 | die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates - OpenSSL callback used and not linked against OpenSSL\n"); | ||
760 | #endif /* USE_OPENSSL */ | ||
761 | } else { | ||
762 | int i; | ||
763 | struct curl_slist *slist; | ||
764 | |||
765 | cert_ptr.to_info = NULL; | ||
766 | res = curl_easy_getinfo (curl, CURLINFO_CERTINFO, &cert_ptr.to_info); | ||
767 | if (!res && cert_ptr.to_info) { | ||
768 | #ifdef USE_OPENSSL | ||
769 | /* We have no OpenSSL in libcurl, but we can use OpenSSL for X509 cert parsing | ||
770 | * We only check the first certificate and assume it's the one of the server | ||
771 | */ | ||
772 | const char* raw_cert = NULL; | ||
773 | for (i = 0; i < cert_ptr.to_certinfo->num_of_certs; i++) { | ||
774 | for (slist = cert_ptr.to_certinfo->certinfo[i]; slist; slist = slist->next) { | ||
775 | if (verbose >= 2) | ||
776 | printf ("%d ** %s\n", i, slist->data); | ||
777 | if (strncmp (slist->data, "Cert:", 5) == 0) { | ||
778 | raw_cert = &slist->data[5]; | ||
779 | goto GOT_FIRST_CERT; | ||
780 | } | ||
781 | } | ||
782 | } | ||
783 | GOT_FIRST_CERT: | ||
784 | if (!raw_cert) { | ||
785 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("Cannot retrieve certificates from CERTINFO information - certificate data was empty")); | ||
786 | die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg); | ||
787 | } | ||
788 | BIO* cert_BIO = BIO_new (BIO_s_mem()); | ||
789 | BIO_write (cert_BIO, raw_cert, strlen(raw_cert)); | ||
790 | cert = PEM_read_bio_X509 (cert_BIO, NULL, NULL, NULL); | ||
791 | if (!cert) { | ||
792 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("Cannot read certificate from CERTINFO information - BIO error")); | ||
793 | die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg); | ||
794 | } | ||
795 | BIO_free (cert_BIO); | ||
796 | result = np_net_ssl_check_certificate(cert, days_till_exp_warn, days_till_exp_crit); | ||
797 | return result; | ||
798 | #else /* USE_OPENSSL */ | ||
799 | /* We assume we don't have OpenSSL and np_net_ssl_check_certificate at our disposal, | ||
800 | * so we use the libcurl CURLINFO data | ||
801 | */ | ||
802 | result = net_noopenssl_check_certificate(&cert_ptr, days_till_exp_warn, days_till_exp_crit); | ||
803 | return result; | ||
804 | #endif /* USE_OPENSSL */ | ||
805 | } else { | ||
806 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("Cannot retrieve certificates - cURL returned %d - %s"), | ||
807 | res, curl_easy_strerror(res)); | ||
808 | die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg); | ||
809 | } | ||
810 | } | ||
811 | } | ||
812 | } | ||
813 | #endif /* LIBCURL_FEATURE_SSL */ | ||
814 | |||
815 | /* we got the data and we executed the request in a given time, so we can append | ||
816 | * performance data to the answer always | ||
817 | */ | ||
818 | handle_curl_option_return_code (curl_easy_getinfo (curl, CURLINFO_TOTAL_TIME, &total_time), "CURLINFO_TOTAL_TIME"); | ||
819 | page_len = get_content_length(&header_buf, &body_buf); | ||
820 | if(show_extended_perfdata) { | ||
821 | handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME, &time_connect), "CURLINFO_CONNECT_TIME"); | ||
822 | handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_APPCONNECT_TIME, &time_appconnect), "CURLINFO_APPCONNECT_TIME"); | ||
823 | handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_PRETRANSFER_TIME, &time_headers), "CURLINFO_PRETRANSFER_TIME"); | ||
824 | handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_STARTTRANSFER_TIME, &time_firstbyte), "CURLINFO_STARTTRANSFER_TIME"); | ||
825 | snprintf(perfstring, DEFAULT_BUFFER_SIZE, "%s %s %s %s %s %s %s", | ||
826 | perfd_time(total_time), | ||
827 | perfd_size(page_len), | ||
828 | perfd_time_connect(time_connect), | ||
829 | use_ssl == TRUE ? perfd_time_ssl (time_appconnect-time_connect) : "", | ||
830 | perfd_time_headers(time_headers - time_appconnect), | ||
831 | perfd_time_firstbyte(time_firstbyte - time_headers), | ||
832 | perfd_time_transfer(total_time-time_firstbyte) | ||
833 | ); | ||
834 | } else { | ||
835 | snprintf(perfstring, DEFAULT_BUFFER_SIZE, "%s %s", | ||
836 | perfd_time(total_time), | ||
837 | perfd_size(page_len) | ||
838 | ); | ||
839 | } | ||
840 | |||
841 | /* return a CRITICAL status if we couldn't read any data */ | ||
842 | if (strlen(header_buf.buf) == 0 && strlen(body_buf.buf) == 0) | ||
843 | die (STATE_CRITICAL, _("HTTP CRITICAL - No header received from host\n")); | ||
844 | |||
845 | /* get status line of answer, check sanity of HTTP code */ | ||
846 | if (curlhelp_parse_statusline (header_buf.buf, &status_line) < 0) { | ||
847 | snprintf (msg, DEFAULT_BUFFER_SIZE, "Unparsable status line in %.3g seconds response time|%s\n", | ||
848 | total_time, perfstring); | ||
849 | /* we cannot know the major/minor version here for sure as we cannot parse the first line */ | ||
850 | die (STATE_CRITICAL, "HTTP CRITICAL HTTP/x.x %ld unknown - %s", code, msg); | ||
851 | } | ||
852 | |||
853 | /* get result code from cURL */ | ||
854 | handle_curl_option_return_code (curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &code), "CURLINFO_RESPONSE_CODE"); | ||
855 | if (verbose>=2) | ||
856 | printf ("* curl CURLINFO_RESPONSE_CODE is %ld\n", code); | ||
857 | |||
858 | /* print status line, header, body if verbose */ | ||
859 | if (verbose >= 2) { | ||
860 | printf ("**** HEADER ****\n%s\n**** CONTENT ****\n%s\n", header_buf.buf, | ||
861 | (no_body ? " [[ skipped ]]" : body_buf.buf)); | ||
862 | } | ||
863 | |||
864 | /* make sure the status line matches the response we are looking for */ | ||
865 | if (!expected_statuscode(status_line.first_line, server_expect)) { | ||
866 | if (server_port == HTTP_PORT) | ||
867 | snprintf(msg, DEFAULT_BUFFER_SIZE, _("Invalid HTTP response received from host: %s\n"), status_line.first_line); | ||
868 | else | ||
869 | snprintf(msg, DEFAULT_BUFFER_SIZE, _("Invalid HTTP response received from host on port %d: %s\n"), server_port, status_line.first_line); | ||
870 | die (STATE_CRITICAL, "HTTP CRITICAL - %s%s%s", msg, | ||
871 | show_body ? "\n" : "", | ||
872 | show_body ? body_buf.buf : ""); | ||
873 | } | ||
874 | |||
875 | if( server_expect_yn ) { | ||
876 | snprintf(msg, DEFAULT_BUFFER_SIZE, _("Status line output matched \"%s\" - "), server_expect); | ||
877 | if (verbose) | ||
878 | printf ("%s\n",msg); | ||
879 | result = STATE_OK; | ||
880 | } | ||
881 | else { | ||
882 | /* illegal return codes result in a critical state */ | ||
883 | if (code >= 600 || code < 100) { | ||
884 | die (STATE_CRITICAL, _("HTTP CRITICAL: Invalid Status (%d, %.40s)\n"), status_line.http_code, status_line.msg); | ||
885 | /* server errors result in a critical state */ | ||
886 | } else if (code >= 500) { | ||
887 | result = STATE_CRITICAL; | ||
888 | /* client errors result in a warning state */ | ||
889 | } else if (code >= 400) { | ||
890 | result = STATE_WARNING; | ||
891 | /* check redirected page if specified */ | ||
892 | } else if (code >= 300) { | ||
893 | if (onredirect == STATE_DEPENDENT) { | ||
894 | if( followmethod == FOLLOW_LIBCURL ) { | ||
895 | code = status_line.http_code; | ||
896 | } else { | ||
897 | /* old check_http style redirection, if we come | ||
898 | * back here, we are in the same status as with | ||
899 | * the libcurl method | ||
900 | */ | ||
901 | redir (&header_buf); | ||
902 | } | ||
903 | } else { | ||
904 | /* this is a specific code in the command line to | ||
905 | * be returned when a redirection is encoutered | ||
906 | */ | ||
907 | } | ||
908 | result = max_state_alt (onredirect, result); | ||
909 | /* all other codes are considered ok */ | ||
910 | } else { | ||
911 | result = STATE_OK; | ||
912 | } | ||
913 | } | ||
914 | |||
915 | /* libcurl redirection internally, handle error states here */ | ||
916 | if( followmethod == FOLLOW_LIBCURL ) { | ||
917 | handle_curl_option_return_code (curl_easy_getinfo (curl, CURLINFO_REDIRECT_COUNT, &redir_depth), "CURLINFO_REDIRECT_COUNT"); | ||
918 | if (verbose >= 2) | ||
919 | printf(_("* curl LIBINFO_REDIRECT_COUNT is %d\n"), redir_depth); | ||
920 | if (redir_depth > max_depth) { | ||
921 | snprintf (msg, DEFAULT_BUFFER_SIZE, "maximum redirection depth %d exceeded in libcurl", | ||
922 | max_depth); | ||
923 | die (STATE_WARNING, "HTTP WARNING - %s", msg); | ||
924 | } | ||
925 | } | ||
926 | |||
927 | /* check status codes, set exit status accordingly */ | ||
928 | if( status_line.http_code != code ) { | ||
929 | die (STATE_CRITICAL, _("HTTP CRITICAL %s %d %s - different HTTP codes (cUrl has %ld)\n"), | ||
930 | string_statuscode (status_line.http_major, status_line.http_minor), | ||
931 | status_line.http_code, status_line.msg, code); | ||
932 | } | ||
933 | |||
934 | if (maximum_age >= 0) { | ||
935 | result = max_state_alt(check_document_dates(&header_buf, &msg), result); | ||
936 | } | ||
937 | |||
938 | /* Page and Header content checks go here */ | ||
939 | |||
940 | if (strlen (header_expect)) { | ||
941 | if (!strstr (header_buf.buf, header_expect)) { | ||
942 | strncpy(&output_header_search[0],header_expect,sizeof(output_header_search)); | ||
943 | if(output_header_search[sizeof(output_header_search)-1]!='\0') { | ||
944 | bcopy("...",&output_header_search[sizeof(output_header_search)-4],4); | ||
945 | } | ||
946 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("%sheader '%s' not found on '%s://%s:%d%s', "), msg, output_header_search, use_ssl ? "https" : "http", host_name ? host_name : server_address, server_port, server_url); | ||
947 | result = STATE_CRITICAL; | ||
948 | } | ||
949 | } | ||
950 | |||
951 | if (strlen (string_expect)) { | ||
952 | if (!strstr (body_buf.buf, string_expect)) { | ||
953 | strncpy(&output_string_search[0],string_expect,sizeof(output_string_search)); | ||
954 | if(output_string_search[sizeof(output_string_search)-1]!='\0') { | ||
955 | bcopy("...",&output_string_search[sizeof(output_string_search)-4],4); | ||
956 | } | ||
957 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("%sstring '%s' not found on '%s://%s:%d%s', "), msg, output_string_search, use_ssl ? "https" : "http", host_name ? host_name : server_address, server_port, server_url); | ||
958 | result = STATE_CRITICAL; | ||
959 | } | ||
960 | } | ||
961 | |||
962 | if (strlen (regexp)) { | ||
963 | errcode = regexec (&preg, body_buf.buf, REGS, pmatch, 0); | ||
964 | if ((errcode == 0 && invert_regex == 0) || (errcode == REG_NOMATCH && invert_regex == 1)) { | ||
965 | /* OK - No-op to avoid changing the logic around it */ | ||
966 | result = max_state_alt(STATE_OK, result); | ||
967 | } | ||
968 | else if ((errcode == REG_NOMATCH && invert_regex == 0) || (errcode == 0 && invert_regex == 1)) { | ||
969 | if (invert_regex == 0) | ||
970 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spattern not found, "), msg); | ||
971 | else | ||
972 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spattern found, "), msg); | ||
973 | result = STATE_CRITICAL; | ||
974 | } | ||
975 | else { | ||
976 | regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER); | ||
977 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("%sExecute Error: %s, "), msg, errbuf); | ||
978 | result = STATE_UNKNOWN; | ||
979 | } | ||
980 | } | ||
981 | |||
982 | /* make sure the page is of an appropriate size */ | ||
983 | if ((max_page_len > 0) && (page_len > max_page_len)) { | ||
984 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spage size %d too large, "), msg, page_len); | ||
985 | result = max_state_alt(STATE_WARNING, result); | ||
986 | } else if ((min_page_len > 0) && (page_len < min_page_len)) { | ||
987 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spage size %d too small, "), msg, page_len); | ||
988 | result = max_state_alt(STATE_WARNING, result); | ||
989 | } | ||
990 | |||
991 | /* -w, -c: check warning and critical level */ | ||
992 | result = max_state_alt(get_status(total_time, thlds), result); | ||
993 | |||
994 | /* Cut-off trailing characters */ | ||
995 | if(msg[strlen(msg)-2] == ',') | ||
996 | msg[strlen(msg)-2] = '\0'; | ||
997 | else | ||
998 | msg[strlen(msg)-3] = '\0'; | ||
999 | |||
1000 | /* TODO: separate _() msg and status code: die (result, "HTTP %s: %s\n", state_text(result), msg); */ | ||
1001 | die (result, "HTTP %s: %s %d %s%s%s - %d bytes in %.3f second response time %s|%s\n%s%s", | ||
1002 | state_text(result), string_statuscode (status_line.http_major, status_line.http_minor), | ||
1003 | status_line.http_code, status_line.msg, | ||
1004 | strlen(msg) > 0 ? " - " : "", | ||
1005 | msg, page_len, total_time, | ||
1006 | (display_html ? "</A>" : ""), | ||
1007 | perfstring, | ||
1008 | (show_body ? body_buf.buf : ""), | ||
1009 | (show_body ? "\n" : "") ); | ||
1010 | |||
1011 | /* proper cleanup after die? */ | ||
1012 | curlhelp_free_statusline(&status_line); | ||
1013 | curl_easy_cleanup (curl); | ||
1014 | curl_global_cleanup (); | ||
1015 | curlhelp_freewritebuffer (&body_buf); | ||
1016 | curlhelp_freewritebuffer (&header_buf); | ||
1017 | if (!strcmp (http_method, "PUT")) { | ||
1018 | curlhelp_freereadbuffer (&put_buf); | ||
1019 | } | ||
1020 | |||
1021 | return result; | ||
1022 | } | ||
1023 | |||
1024 | int | ||
1025 | uri_strcmp (const UriTextRangeA range, const char* s) | ||
1026 | { | ||
1027 | if (!range.first) return -1; | ||
1028 | if (range.afterLast - range.first < strlen (s)) return -1; | ||
1029 | return strncmp (s, range.first, min( range.afterLast - range.first, strlen (s))); | ||
1030 | } | ||
1031 | |||
1032 | char* | ||
1033 | uri_string (const UriTextRangeA range, char* buf, size_t buflen) | ||
1034 | { | ||
1035 | if (!range.first) return "(null)"; | ||
1036 | strncpy (buf, range.first, max (buflen-1, range.afterLast - range.first)); | ||
1037 | buf[max (buflen-1, range.afterLast - range.first)] = '\0'; | ||
1038 | buf[range.afterLast - range.first] = '\0'; | ||
1039 | return buf; | ||
1040 | } | ||
1041 | |||
1042 | void | ||
1043 | redir (curlhelp_write_curlbuf* header_buf) | ||
1044 | { | ||
1045 | char *location = NULL; | ||
1046 | curlhelp_statusline status_line; | ||
1047 | struct phr_header headers[255]; | ||
1048 | size_t nof_headers = 255; | ||
1049 | size_t msglen; | ||
1050 | char buf[DEFAULT_BUFFER_SIZE]; | ||
1051 | char ipstr[INET_ADDR_MAX_SIZE]; | ||
1052 | int new_port; | ||
1053 | char *new_host; | ||
1054 | char *new_url; | ||
1055 | |||
1056 | int res = phr_parse_response (header_buf->buf, header_buf->buflen, | ||
1057 | &status_line.http_minor, &status_line.http_code, &status_line.msg, &msglen, | ||
1058 | headers, &nof_headers, 0); | ||
1059 | |||
1060 | location = get_header_value (headers, nof_headers, "location"); | ||
1061 | |||
1062 | if (verbose >= 2) | ||
1063 | printf(_("* Seen redirect location %s\n"), location); | ||
1064 | |||
1065 | if (++redir_depth > max_depth) | ||
1066 | die (STATE_WARNING, | ||
1067 | _("HTTP WARNING - maximum redirection depth %d exceeded - %s%s\n"), | ||
1068 | max_depth, location, (display_html ? "</A>" : "")); | ||
1069 | |||
1070 | UriParserStateA state; | ||
1071 | UriUriA uri; | ||
1072 | state.uri = &uri; | ||
1073 | if (uriParseUriA (&state, location) != URI_SUCCESS) { | ||
1074 | if (state.errorCode == URI_ERROR_SYNTAX) { | ||
1075 | die (STATE_UNKNOWN, | ||
1076 | _("HTTP UNKNOWN - Could not parse redirect location '%s'%s\n"), | ||
1077 | location, (display_html ? "</A>" : "")); | ||
1078 | } else if (state.errorCode == URI_ERROR_MALLOC) { | ||
1079 | die (STATE_UNKNOWN, _("HTTP UNKNOWN - Could not allocate URL\n")); | ||
1080 | } | ||
1081 | } | ||
1082 | |||
1083 | if (verbose >= 2) { | ||
1084 | printf (_("** scheme: %s\n"), | ||
1085 | uri_string (uri.scheme, buf, DEFAULT_BUFFER_SIZE)); | ||
1086 | printf (_("** host: %s\n"), | ||
1087 | uri_string (uri.hostText, buf, DEFAULT_BUFFER_SIZE)); | ||
1088 | printf (_("** port: %s\n"), | ||
1089 | uri_string (uri.portText, buf, DEFAULT_BUFFER_SIZE)); | ||
1090 | if (uri.hostData.ip4) { | ||
1091 | inet_ntop (AF_INET, uri.hostData.ip4->data, ipstr, sizeof (ipstr)); | ||
1092 | printf (_("** IPv4: %s\n"), ipstr); | ||
1093 | } | ||
1094 | if (uri.hostData.ip6) { | ||
1095 | inet_ntop (AF_INET, uri.hostData.ip6->data, ipstr, sizeof (ipstr)); | ||
1096 | printf (_("** IPv6: %s\n"), ipstr); | ||
1097 | } | ||
1098 | if (uri.pathHead) { | ||
1099 | printf (_("** path: ")); | ||
1100 | const UriPathSegmentA* p = uri.pathHead; | ||
1101 | for (; p; p = p->next) { | ||
1102 | printf ("/%s", uri_string (p->text, buf, DEFAULT_BUFFER_SIZE)); | ||
1103 | } | ||
1104 | puts (""); | ||
1105 | } | ||
1106 | if (uri.query.first) { | ||
1107 | printf (_("** query: %s\n"), | ||
1108 | uri_string (uri.query, buf, DEFAULT_BUFFER_SIZE)); | ||
1109 | } | ||
1110 | if (uri.fragment.first) { | ||
1111 | printf (_("** fragment: %s\n"), | ||
1112 | uri_string (uri.fragment, buf, DEFAULT_BUFFER_SIZE)); | ||
1113 | } | ||
1114 | } | ||
1115 | |||
1116 | use_ssl = !uri_strcmp (uri.scheme, "https"); | ||
1117 | |||
1118 | /* we do a sloppy test here only, because uriparser would have failed | ||
1119 | * above, if the port would be invalid, we just check for MAX_PORT | ||
1120 | */ | ||
1121 | if (uri.portText.first) { | ||
1122 | new_port = atoi (uri_string (uri.portText, buf, DEFAULT_BUFFER_SIZE)); | ||
1123 | } else { | ||
1124 | new_port = HTTP_PORT; | ||
1125 | if (use_ssl) | ||
1126 | new_port = HTTPS_PORT; | ||
1127 | } | ||
1128 | if (new_port > MAX_PORT) | ||
1129 | die (STATE_UNKNOWN, | ||
1130 | _("HTTP UNKNOWN - Redirection to port above %d - %s%s\n"), | ||
1131 | MAX_PORT, location, display_html ? "</A>" : ""); | ||
1132 | |||
1133 | /* by RFC 7231 relative URLs in Location should be taken relative to | ||
1134 | * the original URL, so wy try to form a new absolute URL here | ||
1135 | */ | ||
1136 | if (!uri.scheme.first && !uri.hostText.first) { | ||
1137 | new_host = strdup (host_name ? host_name : server_address); | ||
1138 | } else { | ||
1139 | new_host = strdup (uri_string (uri.hostText, buf, DEFAULT_BUFFER_SIZE)); | ||
1140 | } | ||
1141 | |||
1142 | /* compose new path */ | ||
1143 | /* TODO: handle fragments and query part of URL */ | ||
1144 | new_url = (char *)calloc( 1, DEFAULT_BUFFER_SIZE); | ||
1145 | if (uri.pathHead) { | ||
1146 | const UriPathSegmentA* p = uri.pathHead; | ||
1147 | for (; p; p = p->next) { | ||
1148 | strncat (new_url, "/", DEFAULT_BUFFER_SIZE); | ||
1149 | strncat (new_url, uri_string (p->text, buf, DEFAULT_BUFFER_SIZE), DEFAULT_BUFFER_SIZE-1); | ||
1150 | } | ||
1151 | } | ||
1152 | |||
1153 | if (server_port==new_port && | ||
1154 | !strncmp(server_address, new_host, MAX_IPV4_HOSTLENGTH) && | ||
1155 | (host_name && !strncmp(host_name, new_host, MAX_IPV4_HOSTLENGTH)) && | ||
1156 | !strcmp(server_url, new_url)) | ||
1157 | die (STATE_CRITICAL, | ||
1158 | _("HTTP CRITICAL - redirection creates an infinite loop - %s://%s:%d%s%s\n"), | ||
1159 | use_ssl ? "https" : "http", new_host, new_port, new_url, (display_html ? "</A>" : "")); | ||
1160 | |||
1161 | /* set new values for redirected request */ | ||
1162 | |||
1163 | if (!(followsticky & STICKY_HOST)) { | ||
1164 | free (server_address); | ||
1165 | server_address = strndup (new_host, MAX_IPV4_HOSTLENGTH); | ||
1166 | } | ||
1167 | if (!(followsticky & STICKY_PORT)) { | ||
1168 | server_port = (unsigned short)new_port; | ||
1169 | } | ||
1170 | |||
1171 | free (host_name); | ||
1172 | host_name = strndup (new_host, MAX_IPV4_HOSTLENGTH); | ||
1173 | |||
1174 | /* reset virtual port */ | ||
1175 | virtual_port = server_port; | ||
1176 | |||
1177 | free(new_host); | ||
1178 | free (server_url); | ||
1179 | server_url = new_url; | ||
1180 | |||
1181 | uriFreeUriMembersA (&uri); | ||
1182 | |||
1183 | if (verbose) | ||
1184 | printf (_("Redirection to %s://%s:%d%s\n"), use_ssl ? "https" : "http", | ||
1185 | host_name ? host_name : server_address, server_port, server_url); | ||
1186 | |||
1187 | /* TODO: the hash component MUST be taken from the original URL and | ||
1188 | * attached to the URL in Location | ||
1189 | */ | ||
1190 | |||
1191 | check_http (); | ||
1192 | } | ||
1193 | |||
1194 | /* check whether a file exists */ | ||
1195 | void | ||
1196 | test_file (char *path) | ||
1197 | { | ||
1198 | if (access(path, R_OK) == 0) | ||
1199 | return; | ||
1200 | usage2 (_("file does not exist or is not readable"), path); | ||
1201 | } | ||
1202 | |||
1203 | int | ||
1204 | process_arguments (int argc, char **argv) | ||
1205 | { | ||
1206 | char *p; | ||
1207 | int c = 1; | ||
1208 | char *temp; | ||
1209 | |||
1210 | enum { | ||
1211 | INVERT_REGEX = CHAR_MAX + 1, | ||
1212 | SNI_OPTION, | ||
1213 | CA_CERT_OPTION, | ||
1214 | HTTP_VERSION_OPTION, | ||
1215 | AUTOMATIC_DECOMPRESSION | ||
1216 | }; | ||
1217 | |||
1218 | int option = 0; | ||
1219 | int got_plus = 0; | ||
1220 | static struct option longopts[] = { | ||
1221 | STD_LONG_OPTS, | ||
1222 | {"link", no_argument, 0, 'L'}, | ||
1223 | {"nohtml", no_argument, 0, 'n'}, | ||
1224 | {"ssl", optional_argument, 0, 'S'}, | ||
1225 | {"sni", no_argument, 0, SNI_OPTION}, | ||
1226 | {"post", required_argument, 0, 'P'}, | ||
1227 | {"method", required_argument, 0, 'j'}, | ||
1228 | {"IP-address", required_argument, 0, 'I'}, | ||
1229 | {"url", required_argument, 0, 'u'}, | ||
1230 | {"port", required_argument, 0, 'p'}, | ||
1231 | {"authorization", required_argument, 0, 'a'}, | ||
1232 | {"proxy-authorization", required_argument, 0, 'b'}, | ||
1233 | {"header-string", required_argument, 0, 'd'}, | ||
1234 | {"string", required_argument, 0, 's'}, | ||
1235 | {"expect", required_argument, 0, 'e'}, | ||
1236 | {"regex", required_argument, 0, 'r'}, | ||
1237 | {"ereg", required_argument, 0, 'r'}, | ||
1238 | {"eregi", required_argument, 0, 'R'}, | ||
1239 | {"linespan", no_argument, 0, 'l'}, | ||
1240 | {"onredirect", required_argument, 0, 'f'}, | ||
1241 | {"certificate", required_argument, 0, 'C'}, | ||
1242 | {"client-cert", required_argument, 0, 'J'}, | ||
1243 | {"private-key", required_argument, 0, 'K'}, | ||
1244 | {"ca-cert", required_argument, 0, CA_CERT_OPTION}, | ||
1245 | {"verify-cert", no_argument, 0, 'D'}, | ||
1246 | {"useragent", required_argument, 0, 'A'}, | ||
1247 | {"header", required_argument, 0, 'k'}, | ||
1248 | {"no-body", no_argument, 0, 'N'}, | ||
1249 | {"max-age", required_argument, 0, 'M'}, | ||
1250 | {"content-type", required_argument, 0, 'T'}, | ||
1251 | {"pagesize", required_argument, 0, 'm'}, | ||
1252 | {"invert-regex", no_argument, NULL, INVERT_REGEX}, | ||
1253 | {"use-ipv4", no_argument, 0, '4'}, | ||
1254 | {"use-ipv6", no_argument, 0, '6'}, | ||
1255 | {"extended-perfdata", no_argument, 0, 'E'}, | ||
1256 | {"show-body", no_argument, 0, 'B'}, | ||
1257 | {"http-version", required_argument, 0, HTTP_VERSION_OPTION}, | ||
1258 | {"enable-automatic-decompression", no_argument, 0, AUTOMATIC_DECOMPRESSION}, | ||
1259 | {0, 0, 0, 0} | ||
1260 | }; | ||
1261 | |||
1262 | if (argc < 2) | ||
1263 | return ERROR; | ||
1264 | |||
1265 | /* support check_http compatible arguments */ | ||
1266 | for (c = 1; c < argc; c++) { | ||
1267 | if (strcmp ("-to", argv[c]) == 0) | ||
1268 | strcpy (argv[c], "-t"); | ||
1269 | if (strcmp ("-hn", argv[c]) == 0) | ||
1270 | strcpy (argv[c], "-H"); | ||
1271 | if (strcmp ("-wt", argv[c]) == 0) | ||
1272 | strcpy (argv[c], "-w"); | ||
1273 | if (strcmp ("-ct", argv[c]) == 0) | ||
1274 | strcpy (argv[c], "-c"); | ||
1275 | if (strcmp ("-nohtml", argv[c]) == 0) | ||
1276 | strcpy (argv[c], "-n"); | ||
1277 | } | ||
1278 | |||
1279 | server_url = strdup(DEFAULT_SERVER_URL); | ||
1280 | |||
1281 | while (1) { | ||
1282 | c = getopt_long (argc, argv, "Vvh46t:c:w:A:k:H:P:j:T:I:a:b:d:e:p:s:R:r:u:f:C:J:K:DnlLS::m:M:NEB", longopts, &option); | ||
1283 | if (c == -1 || c == EOF || c == 1) | ||
1284 | break; | ||
1285 | |||
1286 | switch (c) { | ||
1287 | case 'h': | ||
1288 | print_help(); | ||
1289 | exit(STATE_UNKNOWN); | ||
1290 | break; | ||
1291 | case 'V': | ||
1292 | print_revision(progname, NP_VERSION); | ||
1293 | print_curl_version(); | ||
1294 | exit(STATE_UNKNOWN); | ||
1295 | break; | ||
1296 | case 'v': | ||
1297 | verbose++; | ||
1298 | break; | ||
1299 | case 't': /* timeout period */ | ||
1300 | if (!is_intnonneg (optarg)) | ||
1301 | usage2 (_("Timeout interval must be a positive integer"), optarg); | ||
1302 | else | ||
1303 | socket_timeout = (int)strtol (optarg, NULL, 10); | ||
1304 | break; | ||
1305 | case 'c': /* critical time threshold */ | ||
1306 | critical_thresholds = optarg; | ||
1307 | break; | ||
1308 | case 'w': /* warning time threshold */ | ||
1309 | warning_thresholds = optarg; | ||
1310 | break; | ||
1311 | case 'H': /* virtual host */ | ||
1312 | host_name = strdup (optarg); | ||
1313 | if (host_name[0] == '[') { | ||
1314 | if ((p = strstr (host_name, "]:")) != NULL) { /* [IPv6]:port */ | ||
1315 | virtual_port = atoi (p + 2); | ||
1316 | /* cut off the port */ | ||
1317 | host_name_length = strlen (host_name) - strlen (p) - 1; | ||
1318 | free (host_name); | ||
1319 | host_name = strndup (optarg, host_name_length); | ||
1320 | } | ||
1321 | } else if ((p = strchr (host_name, ':')) != NULL | ||
1322 | && strchr (++p, ':') == NULL) { /* IPv4:port or host:port */ | ||
1323 | virtual_port = atoi (p); | ||
1324 | /* cut off the port */ | ||
1325 | host_name_length = strlen (host_name) - strlen (p) - 1; | ||
1326 | free (host_name); | ||
1327 | host_name = strndup (optarg, host_name_length); | ||
1328 | } | ||
1329 | break; | ||
1330 | case 'I': /* internet address */ | ||
1331 | server_address = strdup (optarg); | ||
1332 | break; | ||
1333 | case 'u': /* URL path */ | ||
1334 | server_url = strdup (optarg); | ||
1335 | break; | ||
1336 | case 'p': /* Server port */ | ||
1337 | if (!is_intnonneg (optarg)) | ||
1338 | usage2 (_("Invalid port number, expecting a non-negative number"), optarg); | ||
1339 | else { | ||
1340 | if( strtol(optarg, NULL, 10) > MAX_PORT) | ||
1341 | usage2 (_("Invalid port number, supplied port number is too big"), optarg); | ||
1342 | server_port = (unsigned short)strtol(optarg, NULL, 10); | ||
1343 | specify_port = TRUE; | ||
1344 | } | ||
1345 | break; | ||
1346 | case 'a': /* authorization info */ | ||
1347 | strncpy (user_auth, optarg, MAX_INPUT_BUFFER - 1); | ||
1348 | user_auth[MAX_INPUT_BUFFER - 1] = 0; | ||
1349 | break; | ||
1350 | case 'b': /* proxy-authorization info */ | ||
1351 | strncpy (proxy_auth, optarg, MAX_INPUT_BUFFER - 1); | ||
1352 | proxy_auth[MAX_INPUT_BUFFER - 1] = 0; | ||
1353 | break; | ||
1354 | case 'P': /* HTTP POST data in URL encoded format; ignored if settings already */ | ||
1355 | if (! http_post_data) | ||
1356 | http_post_data = strdup (optarg); | ||
1357 | if (! http_method) | ||
1358 | http_method = strdup("POST"); | ||
1359 | break; | ||
1360 | case 'j': /* Set HTTP method */ | ||
1361 | if (http_method) | ||
1362 | free(http_method); | ||
1363 | http_method = strdup (optarg); | ||
1364 | break; | ||
1365 | case 'A': /* useragent */ | ||
1366 | strncpy (user_agent, optarg, DEFAULT_BUFFER_SIZE); | ||
1367 | user_agent[DEFAULT_BUFFER_SIZE-1] = '\0'; | ||
1368 | break; | ||
1369 | case 'k': /* Additional headers */ | ||
1370 | if (http_opt_headers_count == 0) | ||
1371 | http_opt_headers = malloc (sizeof (char *) * (++http_opt_headers_count)); | ||
1372 | else | ||
1373 | http_opt_headers = realloc (http_opt_headers, sizeof (char *) * (++http_opt_headers_count)); | ||
1374 | http_opt_headers[http_opt_headers_count - 1] = optarg; | ||
1375 | break; | ||
1376 | case 'L': /* show html link */ | ||
1377 | display_html = TRUE; | ||
1378 | break; | ||
1379 | case 'n': /* do not show html link */ | ||
1380 | display_html = FALSE; | ||
1381 | break; | ||
1382 | case 'C': /* Check SSL cert validity */ | ||
1383 | #ifdef LIBCURL_FEATURE_SSL | ||
1384 | if ((temp=strchr(optarg,','))!=NULL) { | ||
1385 | *temp='\0'; | ||
1386 | if (!is_intnonneg (optarg)) | ||
1387 | usage2 (_("Invalid certificate expiration period"), optarg); | ||
1388 | days_till_exp_warn = atoi(optarg); | ||
1389 | *temp=','; | ||
1390 | temp++; | ||
1391 | if (!is_intnonneg (temp)) | ||
1392 | usage2 (_("Invalid certificate expiration period"), temp); | ||
1393 | days_till_exp_crit = atoi (temp); | ||
1394 | } | ||
1395 | else { | ||
1396 | days_till_exp_crit=0; | ||
1397 | if (!is_intnonneg (optarg)) | ||
1398 | usage2 (_("Invalid certificate expiration period"), optarg); | ||
1399 | days_till_exp_warn = atoi (optarg); | ||
1400 | } | ||
1401 | check_cert = TRUE; | ||
1402 | goto enable_ssl; | ||
1403 | #endif | ||
1404 | case 'J': /* use client certificate */ | ||
1405 | #ifdef LIBCURL_FEATURE_SSL | ||
1406 | test_file(optarg); | ||
1407 | client_cert = optarg; | ||
1408 | goto enable_ssl; | ||
1409 | #endif | ||
1410 | case 'K': /* use client private key */ | ||
1411 | #ifdef LIBCURL_FEATURE_SSL | ||
1412 | test_file(optarg); | ||
1413 | client_privkey = optarg; | ||
1414 | goto enable_ssl; | ||
1415 | #endif | ||
1416 | #ifdef LIBCURL_FEATURE_SSL | ||
1417 | case CA_CERT_OPTION: /* use CA chain file */ | ||
1418 | test_file(optarg); | ||
1419 | ca_cert = optarg; | ||
1420 | goto enable_ssl; | ||
1421 | #endif | ||
1422 | #ifdef LIBCURL_FEATURE_SSL | ||
1423 | case 'D': /* verify peer certificate & host */ | ||
1424 | verify_peer_and_host = TRUE; | ||
1425 | break; | ||
1426 | #endif | ||
1427 | case 'S': /* use SSL */ | ||
1428 | #ifdef LIBCURL_FEATURE_SSL | ||
1429 | enable_ssl: | ||
1430 | use_ssl = TRUE; | ||
1431 | /* ssl_version initialized to CURL_SSLVERSION_DEFAULT as a default. | ||
1432 | * Only set if it's non-zero. This helps when we include multiple | ||
1433 | * parameters, like -S and -C combinations */ | ||
1434 | ssl_version = CURL_SSLVERSION_DEFAULT; | ||
1435 | if (c=='S' && optarg != NULL) { | ||
1436 | char *plus_ptr = strchr(optarg, '+'); | ||
1437 | if (plus_ptr) { | ||
1438 | got_plus = 1; | ||
1439 | *plus_ptr = '\0'; | ||
1440 | } | ||
1441 | |||
1442 | if (optarg[0] == '2') | ||
1443 | ssl_version = CURL_SSLVERSION_SSLv2; | ||
1444 | else if (optarg[0] == '3') | ||
1445 | ssl_version = CURL_SSLVERSION_SSLv3; | ||
1446 | else if (!strcmp (optarg, "1") || !strcmp (optarg, "1.0")) | ||
1447 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) | ||
1448 | ssl_version = CURL_SSLVERSION_TLSv1_0; | ||
1449 | #else | ||
1450 | ssl_version = CURL_SSLVERSION_DEFAULT; | ||
1451 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */ | ||
1452 | else if (!strcmp (optarg, "1.1")) | ||
1453 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) | ||
1454 | ssl_version = CURL_SSLVERSION_TLSv1_1; | ||
1455 | #else | ||
1456 | ssl_version = CURL_SSLVERSION_DEFAULT; | ||
1457 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */ | ||
1458 | else if (!strcmp (optarg, "1.2")) | ||
1459 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) | ||
1460 | ssl_version = CURL_SSLVERSION_TLSv1_2; | ||
1461 | #else | ||
1462 | ssl_version = CURL_SSLVERSION_DEFAULT; | ||
1463 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */ | ||
1464 | else if (!strcmp (optarg, "1.3")) | ||
1465 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 52, 0) | ||
1466 | ssl_version = CURL_SSLVERSION_TLSv1_3; | ||
1467 | #else | ||
1468 | ssl_version = CURL_SSLVERSION_DEFAULT; | ||
1469 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 52, 0) */ | ||
1470 | else | ||
1471 | usage4 (_("Invalid option - Valid SSL/TLS versions: 2, 3, 1, 1.1, 1.2, 1.3 (with optional '+' suffix)")); | ||
1472 | } | ||
1473 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 54, 0) | ||
1474 | if (got_plus) { | ||
1475 | switch (ssl_version) { | ||
1476 | case CURL_SSLVERSION_TLSv1_3: | ||
1477 | ssl_version |= CURL_SSLVERSION_MAX_TLSv1_3; | ||
1478 | break; | ||
1479 | case CURL_SSLVERSION_TLSv1_2: | ||
1480 | case CURL_SSLVERSION_TLSv1_1: | ||
1481 | case CURL_SSLVERSION_TLSv1_0: | ||
1482 | ssl_version |= CURL_SSLVERSION_MAX_DEFAULT; | ||
1483 | break; | ||
1484 | } | ||
1485 | } else { | ||
1486 | switch (ssl_version) { | ||
1487 | case CURL_SSLVERSION_TLSv1_3: | ||
1488 | ssl_version |= CURL_SSLVERSION_MAX_TLSv1_3; | ||
1489 | break; | ||
1490 | case CURL_SSLVERSION_TLSv1_2: | ||
1491 | ssl_version |= CURL_SSLVERSION_MAX_TLSv1_2; | ||
1492 | break; | ||
1493 | case CURL_SSLVERSION_TLSv1_1: | ||
1494 | ssl_version |= CURL_SSLVERSION_MAX_TLSv1_1; | ||
1495 | break; | ||
1496 | case CURL_SSLVERSION_TLSv1_0: | ||
1497 | ssl_version |= CURL_SSLVERSION_MAX_TLSv1_0; | ||
1498 | break; | ||
1499 | } | ||
1500 | } | ||
1501 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 54, 0) */ | ||
1502 | if (verbose >= 2) | ||
1503 | printf(_("* Set SSL/TLS version to %d\n"), ssl_version); | ||
1504 | if (specify_port == FALSE) | ||
1505 | server_port = HTTPS_PORT; | ||
1506 | break; | ||
1507 | #else /* LIBCURL_FEATURE_SSL */ | ||
1508 | /* -C -J and -K fall through to here without SSL */ | ||
1509 | usage4 (_("Invalid option - SSL is not available")); | ||
1510 | break; | ||
1511 | case SNI_OPTION: /* --sni is parsed, but ignored, the default is TRUE with libcurl */ | ||
1512 | use_sni = TRUE; | ||
1513 | break; | ||
1514 | #endif /* LIBCURL_FEATURE_SSL */ | ||
1515 | case 'f': /* onredirect */ | ||
1516 | if (!strcmp (optarg, "ok")) | ||
1517 | onredirect = STATE_OK; | ||
1518 | else if (!strcmp (optarg, "warning")) | ||
1519 | onredirect = STATE_WARNING; | ||
1520 | else if (!strcmp (optarg, "critical")) | ||
1521 | onredirect = STATE_CRITICAL; | ||
1522 | else if (!strcmp (optarg, "unknown")) | ||
1523 | onredirect = STATE_UNKNOWN; | ||
1524 | else if (!strcmp (optarg, "follow")) | ||
1525 | onredirect = STATE_DEPENDENT; | ||
1526 | else if (!strcmp (optarg, "stickyport")) | ||
1527 | onredirect = STATE_DEPENDENT, followmethod = FOLLOW_HTTP_CURL, followsticky = STICKY_HOST|STICKY_PORT; | ||
1528 | else if (!strcmp (optarg, "sticky")) | ||
1529 | onredirect = STATE_DEPENDENT, followmethod = FOLLOW_HTTP_CURL, followsticky = STICKY_HOST; | ||
1530 | else if (!strcmp (optarg, "follow")) | ||
1531 | onredirect = STATE_DEPENDENT, followmethod = FOLLOW_HTTP_CURL, followsticky = STICKY_NONE; | ||
1532 | else if (!strcmp (optarg, "curl")) | ||
1533 | onredirect = STATE_DEPENDENT, followmethod = FOLLOW_LIBCURL; | ||
1534 | else usage2 (_("Invalid onredirect option"), optarg); | ||
1535 | if (verbose >= 2) | ||
1536 | printf(_("* Following redirects set to %s\n"), state_text(onredirect)); | ||
1537 | break; | ||
1538 | case 'd': /* string or substring */ | ||
1539 | strncpy (header_expect, optarg, MAX_INPUT_BUFFER - 1); | ||
1540 | header_expect[MAX_INPUT_BUFFER - 1] = 0; | ||
1541 | break; | ||
1542 | case 's': /* string or substring */ | ||
1543 | strncpy (string_expect, optarg, MAX_INPUT_BUFFER - 1); | ||
1544 | string_expect[MAX_INPUT_BUFFER - 1] = 0; | ||
1545 | break; | ||
1546 | case 'e': /* string or substring */ | ||
1547 | strncpy (server_expect, optarg, MAX_INPUT_BUFFER - 1); | ||
1548 | server_expect[MAX_INPUT_BUFFER - 1] = 0; | ||
1549 | server_expect_yn = 1; | ||
1550 | break; | ||
1551 | case 'T': /* Content-type */ | ||
1552 | http_content_type = strdup (optarg); | ||
1553 | break; | ||
1554 | case 'l': /* linespan */ | ||
1555 | cflags &= ~REG_NEWLINE; | ||
1556 | break; | ||
1557 | case 'R': /* regex */ | ||
1558 | cflags |= REG_ICASE; | ||
1559 | case 'r': /* regex */ | ||
1560 | strncpy (regexp, optarg, MAX_RE_SIZE - 1); | ||
1561 | regexp[MAX_RE_SIZE - 1] = 0; | ||
1562 | errcode = regcomp (&preg, regexp, cflags); | ||
1563 | if (errcode != 0) { | ||
1564 | (void) regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER); | ||
1565 | printf (_("Could Not Compile Regular Expression: %s"), errbuf); | ||
1566 | return ERROR; | ||
1567 | } | ||
1568 | break; | ||
1569 | case INVERT_REGEX: | ||
1570 | invert_regex = 1; | ||
1571 | break; | ||
1572 | case '4': | ||
1573 | address_family = AF_INET; | ||
1574 | break; | ||
1575 | case '6': | ||
1576 | #if defined (USE_IPV6) && defined (LIBCURL_FEATURE_IPV6) | ||
1577 | address_family = AF_INET6; | ||
1578 | #else | ||
1579 | usage4 (_("IPv6 support not available")); | ||
1580 | #endif | ||
1581 | break; | ||
1582 | case 'm': /* min_page_length */ | ||
1583 | { | ||
1584 | char *tmp; | ||
1585 | if (strchr(optarg, ':') != (char *)NULL) { | ||
1586 | /* range, so get two values, min:max */ | ||
1587 | tmp = strtok(optarg, ":"); | ||
1588 | if (tmp == NULL) { | ||
1589 | printf("Bad format: try \"-m min:max\"\n"); | ||
1590 | exit (STATE_WARNING); | ||
1591 | } else | ||
1592 | min_page_len = atoi(tmp); | ||
1593 | |||
1594 | tmp = strtok(NULL, ":"); | ||
1595 | if (tmp == NULL) { | ||
1596 | printf("Bad format: try \"-m min:max\"\n"); | ||
1597 | exit (STATE_WARNING); | ||
1598 | } else | ||
1599 | max_page_len = atoi(tmp); | ||
1600 | } else | ||
1601 | min_page_len = atoi (optarg); | ||
1602 | break; | ||
1603 | } | ||
1604 | case 'N': /* no-body */ | ||
1605 | no_body = TRUE; | ||
1606 | break; | ||
1607 | case 'M': /* max-age */ | ||
1608 | { | ||
1609 | int L = strlen(optarg); | ||
1610 | if (L && optarg[L-1] == 'm') | ||
1611 | maximum_age = atoi (optarg) * 60; | ||
1612 | else if (L && optarg[L-1] == 'h') | ||
1613 | maximum_age = atoi (optarg) * 60 * 60; | ||
1614 | else if (L && optarg[L-1] == 'd') | ||
1615 | maximum_age = atoi (optarg) * 60 * 60 * 24; | ||
1616 | else if (L && (optarg[L-1] == 's' || | ||
1617 | isdigit (optarg[L-1]))) | ||
1618 | maximum_age = atoi (optarg); | ||
1619 | else { | ||
1620 | fprintf (stderr, "unparsable max-age: %s\n", optarg); | ||
1621 | exit (STATE_WARNING); | ||
1622 | } | ||
1623 | if (verbose >= 2) | ||
1624 | printf ("* Maximal age of document set to %d seconds\n", maximum_age); | ||
1625 | } | ||
1626 | break; | ||
1627 | case 'E': /* show extended perfdata */ | ||
1628 | show_extended_perfdata = TRUE; | ||
1629 | break; | ||
1630 | case 'B': /* print body content after status line */ | ||
1631 | show_body = TRUE; | ||
1632 | break; | ||
1633 | case HTTP_VERSION_OPTION: | ||
1634 | curl_http_version = CURL_HTTP_VERSION_NONE; | ||
1635 | if (strcmp (optarg, "1.0") == 0) { | ||
1636 | curl_http_version = CURL_HTTP_VERSION_1_0; | ||
1637 | } else if (strcmp (optarg, "1.1") == 0) { | ||
1638 | curl_http_version = CURL_HTTP_VERSION_1_1; | ||
1639 | } else if ((strcmp (optarg, "2.0") == 0) || (strcmp (optarg, "2") == 0)) { | ||
1640 | #if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 33, 0) | ||
1641 | curl_http_version = CURL_HTTP_VERSION_2_0; | ||
1642 | #else | ||
1643 | curl_http_version = CURL_HTTP_VERSION_NONE; | ||
1644 | #endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 33, 0) */ | ||
1645 | } else { | ||
1646 | fprintf (stderr, "unkown http-version parameter: %s\n", optarg); | ||
1647 | exit (STATE_WARNING); | ||
1648 | } | ||
1649 | break; | ||
1650 | case AUTOMATIC_DECOMPRESSION: | ||
1651 | automatic_decompression = TRUE; | ||
1652 | break; | ||
1653 | case '?': | ||
1654 | /* print short usage statement if args not parsable */ | ||
1655 | usage5 (); | ||
1656 | break; | ||
1657 | } | ||
1658 | } | ||
1659 | |||
1660 | c = optind; | ||
1661 | |||
1662 | if (server_address == NULL && c < argc) | ||
1663 | server_address = strdup (argv[c++]); | ||
1664 | |||
1665 | if (host_name == NULL && c < argc) | ||
1666 | host_name = strdup (argv[c++]); | ||
1667 | |||
1668 | if (server_address == NULL) { | ||
1669 | if (host_name == NULL) | ||
1670 | usage4 (_("You must specify a server address or host name")); | ||
1671 | else | ||
1672 | server_address = strdup (host_name); | ||
1673 | } | ||
1674 | |||
1675 | set_thresholds(&thlds, warning_thresholds, critical_thresholds); | ||
1676 | |||
1677 | if (critical_thresholds && thlds->critical->end>(double)socket_timeout) | ||
1678 | socket_timeout = (int)thlds->critical->end + 1; | ||
1679 | if (verbose >= 2) | ||
1680 | printf ("* Socket timeout set to %ld seconds\n", socket_timeout); | ||
1681 | |||
1682 | if (http_method == NULL) | ||
1683 | http_method = strdup ("GET"); | ||
1684 | |||
1685 | if (client_cert && !client_privkey) | ||
1686 | usage4 (_("If you use a client certificate you must also specify a private key file")); | ||
1687 | |||
1688 | if (virtual_port == 0) | ||
1689 | virtual_port = server_port; | ||
1690 | else { | ||
1691 | if ((use_ssl && server_port == HTTPS_PORT) || (!use_ssl && server_port == HTTP_PORT)) | ||
1692 | if(specify_port == FALSE) | ||
1693 | server_port = virtual_port; | ||
1694 | } | ||
1695 | |||
1696 | return TRUE; | ||
1697 | } | ||
1698 | |||
1699 | char *perfd_time (double elapsed_time) | ||
1700 | { | ||
1701 | return fperfdata ("time", elapsed_time, "s", | ||
1702 | thlds->warning?TRUE:FALSE, thlds->warning?thlds->warning->end:0, | ||
1703 | thlds->critical?TRUE:FALSE, thlds->critical?thlds->critical->end:0, | ||
1704 | TRUE, 0, TRUE, socket_timeout); | ||
1705 | } | ||
1706 | |||
1707 | char *perfd_time_connect (double elapsed_time_connect) | ||
1708 | { | ||
1709 | return fperfdata ("time_connect", elapsed_time_connect, "s", FALSE, 0, FALSE, 0, FALSE, 0, TRUE, socket_timeout); | ||
1710 | } | ||
1711 | |||
1712 | char *perfd_time_ssl (double elapsed_time_ssl) | ||
1713 | { | ||
1714 | return fperfdata ("time_ssl", elapsed_time_ssl, "s", FALSE, 0, FALSE, 0, FALSE, 0, TRUE, socket_timeout); | ||
1715 | } | ||
1716 | |||
1717 | char *perfd_time_headers (double elapsed_time_headers) | ||
1718 | { | ||
1719 | return fperfdata ("time_headers", elapsed_time_headers, "s", FALSE, 0, FALSE, 0, FALSE, 0, TRUE, socket_timeout); | ||
1720 | } | ||
1721 | |||
1722 | char *perfd_time_firstbyte (double elapsed_time_firstbyte) | ||
1723 | { | ||
1724 | return fperfdata ("time_firstbyte", elapsed_time_firstbyte, "s", FALSE, 0, FALSE, 0, FALSE, 0, TRUE, socket_timeout); | ||
1725 | } | ||
1726 | |||
1727 | char *perfd_time_transfer (double elapsed_time_transfer) | ||
1728 | { | ||
1729 | return fperfdata ("time_transfer", elapsed_time_transfer, "s", FALSE, 0, FALSE, 0, FALSE, 0, TRUE, socket_timeout); | ||
1730 | } | ||
1731 | |||
1732 | char *perfd_size (int page_len) | ||
1733 | { | ||
1734 | return perfdata ("size", page_len, "B", | ||
1735 | (min_page_len>0?TRUE:FALSE), min_page_len, | ||
1736 | (min_page_len>0?TRUE:FALSE), 0, | ||
1737 | TRUE, 0, FALSE, 0); | ||
1738 | } | ||
1739 | |||
1740 | void | ||
1741 | print_help (void) | ||
1742 | { | ||
1743 | print_revision (progname, NP_VERSION); | ||
1744 | |||
1745 | printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n"); | ||
1746 | printf (COPYRIGHT, copyright, email); | ||
1747 | |||
1748 | printf ("%s\n", _("This plugin tests the HTTP service on the specified host. It can test")); | ||
1749 | printf ("%s\n", _("normal (http) and secure (https) servers, follow redirects, search for")); | ||
1750 | printf ("%s\n", _("strings and regular expressions, check connection times, and report on")); | ||
1751 | printf ("%s\n", _("certificate expiration times.")); | ||
1752 | printf ("\n"); | ||
1753 | printf ("%s\n", _("It makes use of libcurl to do so. It tries to be as compatible to check_http")); | ||
1754 | printf ("%s\n", _("as possible.")); | ||
1755 | |||
1756 | printf ("\n\n"); | ||
1757 | |||
1758 | print_usage (); | ||
1759 | |||
1760 | printf (_("NOTE: One or both of -H and -I must be specified")); | ||
1761 | |||
1762 | printf ("\n"); | ||
1763 | |||
1764 | printf (UT_HELP_VRSN); | ||
1765 | printf (UT_EXTRA_OPTS); | ||
1766 | |||
1767 | printf (" %s\n", "-H, --hostname=ADDRESS"); | ||
1768 | printf (" %s\n", _("Host name argument for servers using host headers (virtual host)")); | ||
1769 | printf (" %s\n", _("Append a port to include it in the header (eg: example.com:5000)")); | ||
1770 | printf (" %s\n", "-I, --IP-address=ADDRESS"); | ||
1771 | printf (" %s\n", _("IP address or name (use numeric address if possible to bypass DNS lookup).")); | ||
1772 | printf (" %s\n", "-p, --port=INTEGER"); | ||
1773 | printf (" %s", _("Port number (default: ")); | ||
1774 | printf ("%d)\n", HTTP_PORT); | ||
1775 | |||
1776 | printf (UT_IPv46); | ||
1777 | |||
1778 | #ifdef LIBCURL_FEATURE_SSL | ||
1779 | printf (" %s\n", "-S, --ssl=VERSION[+]"); | ||
1780 | printf (" %s\n", _("Connect via SSL. Port defaults to 443. VERSION is optional, and prevents")); | ||
1781 | printf (" %s\n", _("auto-negotiation (2 = SSLv2, 3 = SSLv3, 1 = TLSv1, 1.1 = TLSv1.1,")); | ||
1782 | printf (" %s\n", _("1.2 = TLSv1.2, 1.3 = TLSv1.3). With a '+' suffix, newer versions are also accepted.")); | ||
1783 | printf (" %s\n", _("Note: SSLv2 and SSLv3 are deprecated and are usually disabled in libcurl")); | ||
1784 | printf (" %s\n", "--sni"); | ||
1785 | printf (" %s\n", _("Enable SSL/TLS hostname extension support (SNI)")); | ||
1786 | #if LIBCURL_VERSION_NUM >= 0x071801 | ||
1787 | printf (" %s\n", _("Note: --sni is the default in libcurl as SSLv2 and SSLV3 are deprecated and")); | ||
1788 | printf (" %s\n", _(" SNI only really works since TLSv1.0")); | ||
1789 | #else | ||
1790 | printf (" %s\n", _("Note: SNI is not supported in libcurl before 7.18.1")); | ||
1791 | #endif | ||
1792 | printf (" %s\n", "-C, --certificate=INTEGER[,INTEGER]"); | ||
1793 | printf (" %s\n", _("Minimum number of days a certificate has to be valid. Port defaults to 443")); | ||
1794 | printf (" %s\n", _("(when this option is used the URL is not checked.)")); | ||
1795 | printf (" %s\n", "-J, --client-cert=FILE"); | ||
1796 | printf (" %s\n", _("Name of file that contains the client certificate (PEM format)")); | ||
1797 | printf (" %s\n", _("to be used in establishing the SSL session")); | ||
1798 | printf (" %s\n", "-K, --private-key=FILE"); | ||
1799 | printf (" %s\n", _("Name of file containing the private key (PEM format)")); | ||
1800 | printf (" %s\n", _("matching the client certificate")); | ||
1801 | printf (" %s\n", "--ca-cert=FILE"); | ||
1802 | printf (" %s\n", _("CA certificate file to verify peer against")); | ||
1803 | printf (" %s\n", "-D, --verify-cert"); | ||
1804 | printf (" %s\n", _("Verify the peer's SSL certificate and hostname")); | ||
1805 | #endif | ||
1806 | |||
1807 | printf (" %s\n", "-e, --expect=STRING"); | ||
1808 | printf (" %s\n", _("Comma-delimited list of strings, at least one of them is expected in")); | ||
1809 | printf (" %s", _("the first (status) line of the server response (default: ")); | ||
1810 | printf ("%s)\n", HTTP_EXPECT); | ||
1811 | printf (" %s\n", _("If specified skips all other status line logic (ex: 3xx, 4xx, 5xx processing)")); | ||
1812 | printf (" %s\n", "-d, --header-string=STRING"); | ||
1813 | printf (" %s\n", _("String to expect in the response headers")); | ||
1814 | printf (" %s\n", "-s, --string=STRING"); | ||
1815 | printf (" %s\n", _("String to expect in the content")); | ||
1816 | printf (" %s\n", "-u, --url=PATH"); | ||
1817 | printf (" %s\n", _("URL to GET or POST (default: /)")); | ||
1818 | printf (" %s\n", "-P, --post=STRING"); | ||
1819 | printf (" %s\n", _("URL encoded http POST data")); | ||
1820 | printf (" %s\n", "-j, --method=STRING (for example: HEAD, OPTIONS, TRACE, PUT, DELETE, CONNECT)"); | ||
1821 | printf (" %s\n", _("Set HTTP method.")); | ||
1822 | printf (" %s\n", "-N, --no-body"); | ||
1823 | printf (" %s\n", _("Don't wait for document body: stop reading after headers.")); | ||
1824 | printf (" %s\n", _("(Note that this still does an HTTP GET or POST, not a HEAD.)")); | ||
1825 | printf (" %s\n", "-M, --max-age=SECONDS"); | ||
1826 | printf (" %s\n", _("Warn if document is more than SECONDS old. the number can also be of")); | ||
1827 | printf (" %s\n", _("the form \"10m\" for minutes, \"10h\" for hours, or \"10d\" for days.")); | ||
1828 | printf (" %s\n", "-T, --content-type=STRING"); | ||
1829 | printf (" %s\n", _("specify Content-Type header media type when POSTing\n")); | ||
1830 | printf (" %s\n", "-l, --linespan"); | ||
1831 | printf (" %s\n", _("Allow regex to span newlines (must precede -r or -R)")); | ||
1832 | printf (" %s\n", "-r, --regex, --ereg=STRING"); | ||
1833 | printf (" %s\n", _("Search page for regex STRING")); | ||
1834 | printf (" %s\n", "-R, --eregi=STRING"); | ||
1835 | printf (" %s\n", _("Search page for case-insensitive regex STRING")); | ||
1836 | printf (" %s\n", "--invert-regex"); | ||
1837 | printf (" %s\n", _("Return CRITICAL if found, OK if not\n")); | ||
1838 | printf (" %s\n", "-a, --authorization=AUTH_PAIR"); | ||
1839 | printf (" %s\n", _("Username:password on sites with basic authentication")); | ||
1840 | printf (" %s\n", "-b, --proxy-authorization=AUTH_PAIR"); | ||
1841 | printf (" %s\n", _("Username:password on proxy-servers with basic authentication")); | ||
1842 | printf (" %s\n", "-A, --useragent=STRING"); | ||
1843 | printf (" %s\n", _("String to be sent in http header as \"User Agent\"")); | ||
1844 | printf (" %s\n", "-k, --header=STRING"); | ||
1845 | printf (" %s\n", _("Any other tags to be sent in http header. Use multiple times for additional headers")); | ||
1846 | printf (" %s\n", "-E, --extended-perfdata"); | ||
1847 | printf (" %s\n", _("Print additional performance data")); | ||
1848 | printf (" %s\n", "-B, --show-body"); | ||
1849 | printf (" %s\n", _("Print body content below status line")); | ||
1850 | printf (" %s\n", "-L, --link"); | ||
1851 | printf (" %s\n", _("Wrap output in HTML link (obsoleted by urlize)")); | ||
1852 | printf (" %s\n", "-f, --onredirect=<ok|warning|critical|follow|sticky|stickyport|curl>"); | ||
1853 | printf (" %s\n", _("How to handle redirected pages. sticky is like follow but stick to the")); | ||
1854 | printf (" %s\n", _("specified IP address. stickyport also ensures port stays the same.")); | ||
1855 | printf (" %s\n", _("follow uses the old redirection algorithm of check_http.")); | ||
1856 | printf (" %s\n", _("curl uses CURL_FOLLOWLOCATION built into libcurl.")); | ||
1857 | printf (" %s\n", "-m, --pagesize=INTEGER<:INTEGER>"); | ||
1858 | printf (" %s\n", _("Minimum page size required (bytes) : Maximum page size required (bytes)")); | ||
1859 | printf ("\n"); | ||
1860 | printf (" %s\n", "--http-version=VERSION"); | ||
1861 | printf (" %s\n", _("Connect via specific HTTP protocol.")); | ||
1862 | printf (" %s\n", _("1.0 = HTTP/1.0, 1.1 = HTTP/1.1, 2.0 = HTTP/2 (HTTP/2 will fail without -S)")); | ||
1863 | printf (" %s\n", "--enable-automatic-decompression"); | ||
1864 | printf (" %s\n", _("Enable automatic decompression of body (CURLOPT_ACCEPT_ENCODING).")); | ||
1865 | printf ("\n"); | ||
1866 | |||
1867 | printf (UT_WARN_CRIT); | ||
1868 | |||
1869 | printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT); | ||
1870 | |||
1871 | printf (UT_VERBOSE); | ||
1872 | |||
1873 | printf ("\n"); | ||
1874 | printf ("%s\n", _("Notes:")); | ||
1875 | printf (" %s\n", _("This plugin will attempt to open an HTTP connection with the host.")); | ||
1876 | printf (" %s\n", _("Successful connects return STATE_OK, refusals and timeouts return STATE_CRITICAL")); | ||
1877 | printf (" %s\n", _("other errors return STATE_UNKNOWN. Successful connects, but incorrect response")); | ||
1878 | printf (" %s\n", _("messages from the host result in STATE_WARNING return values. If you are")); | ||
1879 | printf (" %s\n", _("checking a virtual server that uses 'host headers' you must supply the FQDN")); | ||
1880 | printf (" %s\n", _("(fully qualified domain name) as the [host_name] argument.")); | ||
1881 | |||
1882 | #ifdef LIBCURL_FEATURE_SSL | ||
1883 | printf ("\n"); | ||
1884 | printf (" %s\n", _("This plugin can also check whether an SSL enabled web server is able to")); | ||
1885 | printf (" %s\n", _("serve content (optionally within a specified time) or whether the X509 ")); | ||
1886 | printf (" %s\n", _("certificate is still valid for the specified number of days.")); | ||
1887 | printf ("\n"); | ||
1888 | printf (" %s\n", _("Please note that this plugin does not check if the presented server")); | ||
1889 | printf (" %s\n", _("certificate matches the hostname of the server, or if the certificate")); | ||
1890 | printf (" %s\n", _("has a valid chain of trust to one of the locally installed CAs.")); | ||
1891 | printf ("\n"); | ||
1892 | printf ("%s\n", _("Examples:")); | ||
1893 | printf (" %s\n\n", "CHECK CONTENT: check_curl -w 5 -c 10 --ssl -H www.verisign.com"); | ||
1894 | printf (" %s\n", _("When the 'www.verisign.com' server returns its content within 5 seconds,")); | ||
1895 | printf (" %s\n", _("a STATE_OK will be returned. When the server returns its content but exceeds")); | ||
1896 | printf (" %s\n", _("the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,")); | ||
1897 | printf (" %s\n", _("a STATE_CRITICAL will be returned.")); | ||
1898 | printf ("\n"); | ||
1899 | printf (" %s\n\n", "CHECK CERTIFICATE: check_curl -H www.verisign.com -C 14"); | ||
1900 | printf (" %s\n", _("When the certificate of 'www.verisign.com' is valid for more than 14 days,")); | ||
1901 | printf (" %s\n", _("a STATE_OK is returned. When the certificate is still valid, but for less than")); | ||
1902 | printf (" %s\n", _("14 days, a STATE_WARNING is returned. A STATE_CRITICAL will be returned when")); | ||
1903 | printf (" %s\n\n", _("the certificate is expired.")); | ||
1904 | printf ("\n"); | ||
1905 | printf (" %s\n\n", "CHECK CERTIFICATE: check_curl -H www.verisign.com -C 30,14"); | ||
1906 | printf (" %s\n", _("When the certificate of 'www.verisign.com' is valid for more than 30 days,")); | ||
1907 | printf (" %s\n", _("a STATE_OK is returned. When the certificate is still valid, but for less than")); | ||
1908 | printf (" %s\n", _("30 days, but more than 14 days, a STATE_WARNING is returned.")); | ||
1909 | printf (" %s\n", _("A STATE_CRITICAL will be returned when certificate expires in less than 14 days")); | ||
1910 | #endif | ||
1911 | |||
1912 | printf ("\n %s\n", "CHECK WEBSERVER CONTENT VIA PROXY:"); | ||
1913 | printf (" %s\n", _("It is recommended to use an environment proxy like:")); | ||
1914 | printf (" %s\n", _("http_proxy=http://192.168.100.35:3128 ./check_curl -H www.monitoring-plugins.org")); | ||
1915 | printf (" %s\n", _("legacy proxy requests in check_http style still work:")); | ||
1916 | printf (" %s\n", _("check_curl -I 192.168.100.35 -p 3128 -u http://www.monitoring-plugins.org/ -H www.monitoring-plugins.org")); | ||
1917 | |||
1918 | #ifdef LIBCURL_FEATURE_SSL | ||
1919 | printf ("\n %s\n", "CHECK SSL WEBSERVER CONTENT VIA PROXY USING HTTP 1.1 CONNECT: "); | ||
1920 | printf (" %s\n", _("It is recommended to use an environment proxy like:")); | ||
1921 | printf (" %s\n", _("https_proxy=http://192.168.100.35:3128 ./check_curl -H www.verisign.com -S")); | ||
1922 | printf (" %s\n", _("legacy proxy requests in check_http style still work:")); | ||
1923 | printf (" %s\n", _("check_curl -I 192.168.100.35 -p 3128 -u https://www.verisign.com/ -S -j CONNECT -H www.verisign.com ")); | ||
1924 | printf (" %s\n", _("all these options are needed: -I <proxy> -p <proxy-port> -u <check-url> -S(sl) -j CONNECT -H <webserver>")); | ||
1925 | printf (" %s\n", _("a STATE_OK will be returned. When the server returns its content but exceeds")); | ||
1926 | printf (" %s\n", _("the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,")); | ||
1927 | printf (" %s\n", _("a STATE_CRITICAL will be returned.")); | ||
1928 | |||
1929 | #endif | ||
1930 | |||
1931 | printf (UT_SUPPORT); | ||
1932 | |||
1933 | } | ||
1934 | |||
1935 | |||
1936 | |||
1937 | void | ||
1938 | print_usage (void) | ||
1939 | { | ||
1940 | printf ("%s\n", _("Usage:")); | ||
1941 | printf (" %s -H <vhost> | -I <IP-address> [-u <uri>] [-p <port>]\n",progname); | ||
1942 | printf (" [-J <client certificate file>] [-K <private key>] [--ca-cert <CA certificate file>] [-D]\n"); | ||
1943 | printf (" [-w <warn time>] [-c <critical time>] [-t <timeout>] [-L] [-E] [-a auth]\n"); | ||
1944 | printf (" [-b proxy_auth] [-f <ok|warning|critcal|follow|sticky|stickyport|curl>]\n"); | ||
1945 | printf (" [-e <expect>] [-d string] [-s string] [-l] [-r <regex> | -R <case-insensitive regex>]\n"); | ||
1946 | printf (" [-P string] [-m <min_pg_size>:<max_pg_size>] [-4|-6] [-N] [-M <age>]\n"); | ||
1947 | printf (" [-A string] [-k string] [-S <version>] [--sni]\n"); | ||
1948 | printf (" [-T <content-type>] [-j method]\n"); | ||
1949 | printf (" [--http-version=<version>]\n"); | ||
1950 | printf (" %s -H <vhost> | -I <IP-address> -C <warn_age>[,<crit_age>]\n",progname); | ||
1951 | printf (" [-p <port>] [-t <timeout>] [-4|-6] [--sni]\n"); | ||
1952 | printf ("\n"); | ||
1953 | #ifdef LIBCURL_FEATURE_SSL | ||
1954 | printf ("%s\n", _("In the first form, make an HTTP request.")); | ||
1955 | printf ("%s\n\n", _("In the second form, connect to the server and check the TLS certificate.")); | ||
1956 | #endif | ||
1957 | printf ("%s\n", _("WARNING: check_curl is experimental. Please use")); | ||
1958 | printf ("%s\n\n", _("check_http if you need a stable version.")); | ||
1959 | } | ||
1960 | |||
1961 | void | ||
1962 | print_curl_version (void) | ||
1963 | { | ||
1964 | printf( "%s\n", curl_version()); | ||
1965 | } | ||
1966 | |||
1967 | int | ||
1968 | curlhelp_initwritebuffer (curlhelp_write_curlbuf *buf) | ||
1969 | { | ||
1970 | buf->bufsize = DEFAULT_BUFFER_SIZE; | ||
1971 | buf->buflen = 0; | ||
1972 | buf->buf = (char *)malloc ((size_t)buf->bufsize); | ||
1973 | if (buf->buf == NULL) return -1; | ||
1974 | return 0; | ||
1975 | } | ||
1976 | |||
1977 | int | ||
1978 | curlhelp_buffer_write_callback (void *buffer, size_t size, size_t nmemb, void *stream) | ||
1979 | { | ||
1980 | curlhelp_write_curlbuf *buf = (curlhelp_write_curlbuf *)stream; | ||
1981 | |||
1982 | while (buf->bufsize < buf->buflen + size * nmemb + 1) { | ||
1983 | buf->bufsize *= buf->bufsize * 2; | ||
1984 | buf->buf = (char *)realloc (buf->buf, buf->bufsize); | ||
1985 | if (buf->buf == NULL) return -1; | ||
1986 | } | ||
1987 | |||
1988 | memcpy (buf->buf + buf->buflen, buffer, size * nmemb); | ||
1989 | buf->buflen += size * nmemb; | ||
1990 | buf->buf[buf->buflen] = '\0'; | ||
1991 | |||
1992 | return (int)(size * nmemb); | ||
1993 | } | ||
1994 | |||
1995 | int | ||
1996 | curlhelp_buffer_read_callback (void *buffer, size_t size, size_t nmemb, void *stream) | ||
1997 | { | ||
1998 | curlhelp_read_curlbuf *buf = (curlhelp_read_curlbuf *)stream; | ||
1999 | |||
2000 | size_t n = min (nmemb * size, buf->buflen - buf->pos); | ||
2001 | |||
2002 | memcpy (buffer, buf->buf + buf->pos, n); | ||
2003 | buf->pos += n; | ||
2004 | |||
2005 | return (int)n; | ||
2006 | } | ||
2007 | |||
2008 | void | ||
2009 | curlhelp_freewritebuffer (curlhelp_write_curlbuf *buf) | ||
2010 | { | ||
2011 | free (buf->buf); | ||
2012 | buf->buf = NULL; | ||
2013 | } | ||
2014 | |||
2015 | int | ||
2016 | curlhelp_initreadbuffer (curlhelp_read_curlbuf *buf, const char *data, size_t datalen) | ||
2017 | { | ||
2018 | buf->buflen = datalen; | ||
2019 | buf->buf = (char *)malloc ((size_t)buf->buflen); | ||
2020 | if (buf->buf == NULL) return -1; | ||
2021 | memcpy (buf->buf, data, datalen); | ||
2022 | buf->pos = 0; | ||
2023 | return 0; | ||
2024 | } | ||
2025 | |||
2026 | void | ||
2027 | curlhelp_freereadbuffer (curlhelp_read_curlbuf *buf) | ||
2028 | { | ||
2029 | free (buf->buf); | ||
2030 | buf->buf = NULL; | ||
2031 | } | ||
2032 | |||
2033 | /* TODO: where to put this, it's actually part of sstrings2 (logically)? | ||
2034 | */ | ||
2035 | const char* | ||
2036 | strrstr2(const char *haystack, const char *needle) | ||
2037 | { | ||
2038 | int counter; | ||
2039 | size_t len; | ||
2040 | const char *prev_pos; | ||
2041 | const char *pos; | ||
2042 | |||
2043 | if (haystack == NULL || needle == NULL) | ||
2044 | return NULL; | ||
2045 | |||
2046 | if (haystack[0] == '\0' || needle[0] == '\0') | ||
2047 | return NULL; | ||
2048 | |||
2049 | counter = 0; | ||
2050 | prev_pos = NULL; | ||
2051 | pos = haystack; | ||
2052 | len = strlen (needle); | ||
2053 | for (;;) { | ||
2054 | pos = strstr (pos, needle); | ||
2055 | if (pos == NULL) { | ||
2056 | if (counter == 0) | ||
2057 | return NULL; | ||
2058 | else | ||
2059 | return prev_pos; | ||
2060 | } | ||
2061 | counter++; | ||
2062 | prev_pos = pos; | ||
2063 | pos += len; | ||
2064 | if (*pos == '\0') return prev_pos; | ||
2065 | } | ||
2066 | } | ||
2067 | |||
2068 | int | ||
2069 | curlhelp_parse_statusline (const char *buf, curlhelp_statusline *status_line) | ||
2070 | { | ||
2071 | char *first_line_end; | ||
2072 | char *p; | ||
2073 | size_t first_line_len; | ||
2074 | char *pp; | ||
2075 | const char *start; | ||
2076 | char *first_line_buf; | ||
2077 | |||
2078 | /* find last start of a new header */ | ||
2079 | start = strrstr2 (buf, "\r\nHTTP/"); | ||
2080 | if (start != NULL) { | ||
2081 | start += 2; | ||
2082 | buf = start; | ||
2083 | } | ||
2084 | |||
2085 | first_line_end = strstr(buf, "\r\n"); | ||
2086 | if (first_line_end == NULL) return -1; | ||
2087 | |||
2088 | first_line_len = (size_t)(first_line_end - buf); | ||
2089 | status_line->first_line = (char *)malloc (first_line_len + 1); | ||
2090 | if (status_line->first_line == NULL) return -1; | ||
2091 | memcpy (status_line->first_line, buf, first_line_len); | ||
2092 | status_line->first_line[first_line_len] = '\0'; | ||
2093 | first_line_buf = strdup( status_line->first_line ); | ||
2094 | |||
2095 | /* protocol and version: "HTTP/x.x" SP or "HTTP/2" SP */ | ||
2096 | |||
2097 | p = strtok(first_line_buf, "/"); | ||
2098 | if( p == NULL ) { free( first_line_buf ); return -1; } | ||
2099 | if( strcmp( p, "HTTP" ) != 0 ) { free( first_line_buf ); return -1; } | ||
2100 | |||
2101 | p = strtok( NULL, " " ); | ||
2102 | if( p == NULL ) { free( first_line_buf ); return -1; } | ||
2103 | if( strchr( p, '.' ) != NULL ) { | ||
2104 | |||
2105 | /* HTTP 1.x case */ | ||
2106 | char *ppp; | ||
2107 | ppp = strtok( p, "." ); | ||
2108 | status_line->http_major = (int)strtol( p, &pp, 10 ); | ||
2109 | if( *pp != '\0' ) { free( first_line_buf ); return -1; } | ||
2110 | ppp = strtok( NULL, " " ); | ||
2111 | status_line->http_minor = (int)strtol( p, &pp, 10 ); | ||
2112 | if( *pp != '\0' ) { free( first_line_buf ); return -1; } | ||
2113 | p += 4; /* 1.x SP */ | ||
2114 | } else { | ||
2115 | /* HTTP 2 case */ | ||
2116 | status_line->http_major = (int)strtol( p, &pp, 10 ); | ||
2117 | status_line->http_minor = 0; | ||
2118 | p += 2; /* 2 SP */ | ||
2119 | } | ||
2120 | |||
2121 | /* status code: "404" or "404.1", then SP */ | ||
2122 | |||
2123 | p = strtok( p, " " ); | ||
2124 | if( p == NULL ) { free( first_line_buf ); return -1; } | ||
2125 | if( strchr( p, '.' ) != NULL ) { | ||
2126 | char *ppp; | ||
2127 | ppp = strtok( p, "." ); | ||
2128 | status_line->http_code = (int)strtol( ppp, &pp, 10 ); | ||
2129 | if( *pp != '\0' ) { free( first_line_buf ); return -1; } | ||
2130 | ppp = strtok( NULL, "" ); | ||
2131 | status_line->http_subcode = (int)strtol( ppp, &pp, 10 ); | ||
2132 | if( *pp != '\0' ) { free( first_line_buf ); return -1; } | ||
2133 | p += 6; /* 400.1 SP */ | ||
2134 | } else { | ||
2135 | status_line->http_code = (int)strtol( p, &pp, 10 ); | ||
2136 | status_line->http_subcode = -1; | ||
2137 | if( *pp != '\0' ) { free( first_line_buf ); return -1; } | ||
2138 | p += 4; /* 400 SP */ | ||
2139 | } | ||
2140 | |||
2141 | /* Human readable message: "Not Found" CRLF */ | ||
2142 | |||
2143 | p = strtok( p, "" ); | ||
2144 | if( p == NULL ) { status_line->msg = ""; return 0; } | ||
2145 | status_line->msg = status_line->first_line + ( p - first_line_buf ); | ||
2146 | free( first_line_buf ); | ||
2147 | |||
2148 | return 0; | ||
2149 | } | ||
2150 | |||
2151 | void | ||
2152 | curlhelp_free_statusline (curlhelp_statusline *status_line) | ||
2153 | { | ||
2154 | free (status_line->first_line); | ||
2155 | } | ||
2156 | |||
2157 | void | ||
2158 | remove_newlines (char *s) | ||
2159 | { | ||
2160 | char *p; | ||
2161 | |||
2162 | for (p = s; *p != '\0'; p++) | ||
2163 | if (*p == '\r' || *p == '\n') | ||
2164 | *p = ' '; | ||
2165 | } | ||
2166 | |||
2167 | char * | ||
2168 | get_header_value (const struct phr_header* headers, const size_t nof_headers, const char* header) | ||
2169 | { | ||
2170 | int i; | ||
2171 | for( i = 0; i < nof_headers; i++ ) { | ||
2172 | if(headers[i].name != NULL && strncasecmp( header, headers[i].name, max( headers[i].name_len, 4 ) ) == 0 ) { | ||
2173 | return strndup( headers[i].value, headers[i].value_len ); | ||
2174 | } | ||
2175 | } | ||
2176 | return NULL; | ||
2177 | } | ||
2178 | |||
2179 | int | ||
2180 | check_document_dates (const curlhelp_write_curlbuf *header_buf, char (*msg)[DEFAULT_BUFFER_SIZE]) | ||
2181 | { | ||
2182 | char *server_date = NULL; | ||
2183 | char *document_date = NULL; | ||
2184 | int date_result = STATE_OK; | ||
2185 | curlhelp_statusline status_line; | ||
2186 | struct phr_header headers[255]; | ||
2187 | size_t nof_headers = 255; | ||
2188 | size_t msglen; | ||
2189 | |||
2190 | int res = phr_parse_response (header_buf->buf, header_buf->buflen, | ||
2191 | &status_line.http_minor, &status_line.http_code, &status_line.msg, &msglen, | ||
2192 | headers, &nof_headers, 0); | ||
2193 | |||
2194 | server_date = get_header_value (headers, nof_headers, "date"); | ||
2195 | document_date = get_header_value (headers, nof_headers, "last-modified"); | ||
2196 | |||
2197 | if (!server_date || !*server_date) { | ||
2198 | snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sServer date unknown, "), *msg); | ||
2199 | date_result = max_state_alt(STATE_UNKNOWN, date_result); | ||
2200 | } else if (!document_date || !*document_date) { | ||
2201 | snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sDocument modification date unknown, "), *msg); | ||
2202 | date_result = max_state_alt(STATE_CRITICAL, date_result); | ||
2203 | } else { | ||
2204 | time_t srv_data = curl_getdate (server_date, NULL); | ||
2205 | time_t doc_data = curl_getdate (document_date, NULL); | ||
2206 | if (verbose >= 2) | ||
2207 | printf ("* server date: '%s' (%d), doc_date: '%s' (%d)\n", server_date, (int)srv_data, document_date, (int)doc_data); | ||
2208 | if (srv_data <= 0) { | ||
2209 | snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sServer date \"%100s\" unparsable, "), *msg, server_date); | ||
2210 | date_result = max_state_alt(STATE_CRITICAL, date_result); | ||
2211 | } else if (doc_data <= 0) { | ||
2212 | snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sDocument date \"%100s\" unparsable, "), *msg, document_date); | ||
2213 | date_result = max_state_alt(STATE_CRITICAL, date_result); | ||
2214 | } else if (doc_data > srv_data + 30) { | ||
2215 | snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sDocument is %d seconds in the future, "), *msg, (int)doc_data - (int)srv_data); | ||
2216 | date_result = max_state_alt(STATE_CRITICAL, date_result); | ||
2217 | } else if (doc_data < srv_data - maximum_age) { | ||
2218 | int n = (srv_data - doc_data); | ||
2219 | if (n > (60 * 60 * 24 * 2)) { | ||
2220 | snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sLast modified %.1f days ago, "), *msg, ((float) n) / (60 * 60 * 24)); | ||
2221 | date_result = max_state_alt(STATE_CRITICAL, date_result); | ||
2222 | } else { | ||
2223 | snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sLast modified %d:%02d:%02d ago, "), *msg, n / (60 * 60), (n / 60) % 60, n % 60); | ||
2224 | date_result = max_state_alt(STATE_CRITICAL, date_result); | ||
2225 | } | ||
2226 | } | ||
2227 | } | ||
2228 | |||
2229 | if (server_date) free (server_date); | ||
2230 | if (document_date) free (document_date); | ||
2231 | |||
2232 | return date_result; | ||
2233 | } | ||
2234 | |||
2235 | |||
2236 | int | ||
2237 | get_content_length (const curlhelp_write_curlbuf* header_buf, const curlhelp_write_curlbuf* body_buf) | ||
2238 | { | ||
2239 | const char *s; | ||
2240 | int content_length = 0; | ||
2241 | char *copy; | ||
2242 | struct phr_header headers[255]; | ||
2243 | size_t nof_headers = 255; | ||
2244 | size_t msglen; | ||
2245 | char *content_length_s = NULL; | ||
2246 | curlhelp_statusline status_line; | ||
2247 | |||
2248 | int res = phr_parse_response (header_buf->buf, header_buf->buflen, | ||
2249 | &status_line.http_minor, &status_line.http_code, &status_line.msg, &msglen, | ||
2250 | headers, &nof_headers, 0); | ||
2251 | |||
2252 | content_length_s = get_header_value (headers, nof_headers, "content-length"); | ||
2253 | if (!content_length_s) { | ||
2254 | return header_buf->buflen + body_buf->buflen; | ||
2255 | } | ||
2256 | content_length_s += strspn (content_length_s, " \t"); | ||
2257 | content_length = atoi (content_length_s); | ||
2258 | if (content_length != body_buf->buflen) { | ||
2259 | /* TODO: should we warn if the actual and the reported body length don't match? */ | ||
2260 | } | ||
2261 | |||
2262 | if (content_length_s) free (content_length_s); | ||
2263 | |||
2264 | return header_buf->buflen + body_buf->buflen; | ||
2265 | } | ||
2266 | |||
2267 | /* TODO: is there a better way in libcurl to check for the SSL library? */ | ||
2268 | curlhelp_ssl_library | ||
2269 | curlhelp_get_ssl_library (CURL* curl) | ||
2270 | { | ||
2271 | curl_version_info_data* version_data; | ||
2272 | char *ssl_version; | ||
2273 | char *library; | ||
2274 | curlhelp_ssl_library ssl_library = CURLHELP_SSL_LIBRARY_UNKNOWN; | ||
2275 | |||
2276 | version_data = curl_version_info (CURLVERSION_NOW); | ||
2277 | if (version_data == NULL) return CURLHELP_SSL_LIBRARY_UNKNOWN; | ||
2278 | |||
2279 | ssl_version = strdup (version_data->ssl_version); | ||
2280 | if (ssl_version == NULL ) return CURLHELP_SSL_LIBRARY_UNKNOWN; | ||
2281 | |||
2282 | library = strtok (ssl_version, "/"); | ||
2283 | if (library == NULL) return CURLHELP_SSL_LIBRARY_UNKNOWN; | ||
2284 | |||
2285 | if (strcmp (library, "OpenSSL") == 0) | ||
2286 | ssl_library = CURLHELP_SSL_LIBRARY_OPENSSL; | ||
2287 | else if (strcmp (library, "LibreSSL") == 0) | ||
2288 | ssl_library = CURLHELP_SSL_LIBRARY_LIBRESSL; | ||
2289 | else if (strcmp (library, "GnuTLS") == 0) | ||
2290 | ssl_library = CURLHELP_SSL_LIBRARY_GNUTLS; | ||
2291 | else if (strcmp (library, "NSS") == 0) | ||
2292 | ssl_library = CURLHELP_SSL_LIBRARY_NSS; | ||
2293 | |||
2294 | if (verbose >= 2) | ||
2295 | printf ("* SSL library string is : %s %s (%d)\n", version_data->ssl_version, library, ssl_library); | ||
2296 | |||
2297 | free (ssl_version); | ||
2298 | |||
2299 | return ssl_library; | ||
2300 | } | ||
2301 | |||
2302 | const char* | ||
2303 | curlhelp_get_ssl_library_string (curlhelp_ssl_library ssl_library) | ||
2304 | { | ||
2305 | switch (ssl_library) { | ||
2306 | case CURLHELP_SSL_LIBRARY_OPENSSL: | ||
2307 | return "OpenSSL"; | ||
2308 | case CURLHELP_SSL_LIBRARY_LIBRESSL: | ||
2309 | return "LibreSSL"; | ||
2310 | case CURLHELP_SSL_LIBRARY_GNUTLS: | ||
2311 | return "GnuTLS"; | ||
2312 | case CURLHELP_SSL_LIBRARY_NSS: | ||
2313 | return "NSS"; | ||
2314 | case CURLHELP_SSL_LIBRARY_UNKNOWN: | ||
2315 | default: | ||
2316 | return "unknown"; | ||
2317 | } | ||
2318 | } | ||
2319 | |||
2320 | #ifdef LIBCURL_FEATURE_SSL | ||
2321 | #ifndef USE_OPENSSL | ||
2322 | time_t | ||
2323 | parse_cert_date (const char *s) | ||
2324 | { | ||
2325 | struct tm tm; | ||
2326 | time_t date; | ||
2327 | char *res; | ||
2328 | |||
2329 | if (!s) return -1; | ||
2330 | |||
2331 | /* Jan 17 14:25:12 2020 GMT */ | ||
2332 | res = strptime (s, "%Y-%m-%d %H:%M:%S GMT", &tm); | ||
2333 | /* Sep 11 12:00:00 2020 GMT */ | ||
2334 | if (res == NULL) strptime (s, "%Y %m %d %H:%M:%S GMT", &tm); | ||
2335 | date = mktime (&tm); | ||
2336 | |||
2337 | return date; | ||
2338 | } | ||
2339 | |||
2340 | /* TODO: this needs cleanup in the sslutils.c, maybe we the #else case to | ||
2341 | * OpenSSL could be this function | ||
2342 | */ | ||
2343 | int | ||
2344 | net_noopenssl_check_certificate (cert_ptr_union* cert_ptr, int days_till_exp_warn, int days_till_exp_crit) | ||
2345 | { | ||
2346 | int i; | ||
2347 | struct curl_slist* slist; | ||
2348 | int cname_found = 0; | ||
2349 | char* start_date_str = NULL; | ||
2350 | char* end_date_str = NULL; | ||
2351 | time_t start_date; | ||
2352 | time_t end_date; | ||
2353 | char *tz; | ||
2354 | float time_left; | ||
2355 | int days_left; | ||
2356 | int time_remaining; | ||
2357 | char timestamp[50] = ""; | ||
2358 | int status = STATE_UNKNOWN; | ||
2359 | |||
2360 | if (verbose >= 2) | ||
2361 | printf ("**** REQUEST CERTIFICATES ****\n"); | ||
2362 | |||
2363 | for (i = 0; i < cert_ptr->to_certinfo->num_of_certs; i++) { | ||
2364 | for (slist = cert_ptr->to_certinfo->certinfo[i]; slist; slist = slist->next) { | ||
2365 | /* find first common name in subject, | ||
2366 | * TODO: check alternative subjects for | ||
2367 | * TODO: have a decent parser here and not a hack | ||
2368 | * multi-host certificate, check wildcards | ||
2369 | */ | ||
2370 | if (strncasecmp (slist->data, "Subject:", 8) == 0) { | ||
2371 | int d = 3; | ||
2372 | char* p = strstr (slist->data, "CN="); | ||
2373 | if (p == NULL) { | ||
2374 | d = 5; | ||
2375 | p = strstr (slist->data, "CN = "); | ||
2376 | } | ||
2377 | if (p != NULL) { | ||
2378 | if (strncmp (host_name, p+d, strlen (host_name)) == 0) { | ||
2379 | cname_found = 1; | ||
2380 | } | ||
2381 | } | ||
2382 | } else if (strncasecmp (slist->data, "Start Date:", 11) == 0) { | ||
2383 | start_date_str = &slist->data[11]; | ||
2384 | } else if (strncasecmp (slist->data, "Expire Date:", 12) == 0) { | ||
2385 | end_date_str = &slist->data[12]; | ||
2386 | } else if (strncasecmp (slist->data, "Cert:", 5) == 0) { | ||
2387 | goto HAVE_FIRST_CERT; | ||
2388 | } | ||
2389 | if (verbose >= 2) | ||
2390 | printf ("%d ** %s\n", i, slist->data); | ||
2391 | } | ||
2392 | } | ||
2393 | HAVE_FIRST_CERT: | ||
2394 | |||
2395 | if (verbose >= 2) | ||
2396 | printf ("**** REQUEST CERTIFICATES ****\n"); | ||
2397 | |||
2398 | if (!cname_found) { | ||
2399 | printf("%s\n",_("CRITICAL - Cannot retrieve certificate subject.")); | ||
2400 | return STATE_CRITICAL; | ||
2401 | } | ||
2402 | |||
2403 | start_date = parse_cert_date (start_date_str); | ||
2404 | if (start_date <= 0) { | ||
2405 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("WARNING - Unparsable 'Start Date' in certificate: '%s'"), | ||
2406 | start_date_str); | ||
2407 | puts (msg); | ||
2408 | return STATE_WARNING; | ||
2409 | } | ||
2410 | |||
2411 | end_date = parse_cert_date (end_date_str); | ||
2412 | if (end_date <= 0) { | ||
2413 | snprintf (msg, DEFAULT_BUFFER_SIZE, _("WARNING - Unparsable 'Expire Date' in certificate: '%s'"), | ||
2414 | start_date_str); | ||
2415 | puts (msg); | ||
2416 | return STATE_WARNING; | ||
2417 | } | ||
2418 | |||
2419 | time_left = difftime (end_date, time(NULL)); | ||
2420 | days_left = time_left / 86400; | ||
2421 | tz = getenv("TZ"); | ||
2422 | setenv("TZ", "GMT", 1); | ||
2423 | tzset(); | ||
2424 | strftime(timestamp, 50, "%c %z", localtime(&end_date)); | ||
2425 | if (tz) | ||
2426 | setenv("TZ", tz, 1); | ||
2427 | else | ||
2428 | unsetenv("TZ"); | ||
2429 | tzset(); | ||
2430 | |||
2431 | if (days_left > 0 && days_left <= days_till_exp_warn) { | ||
2432 | printf (_("%s - Certificate '%s' expires in %d day(s) (%s).\n"), (days_left>days_till_exp_crit)?"WARNING":"CRITICAL", host_name, days_left, timestamp); | ||
2433 | if (days_left > days_till_exp_crit) | ||
2434 | status = STATE_WARNING; | ||
2435 | else | ||
2436 | status = STATE_CRITICAL; | ||
2437 | } else if (days_left == 0 && time_left > 0) { | ||
2438 | if (time_left >= 3600) | ||
2439 | time_remaining = (int) time_left / 3600; | ||
2440 | else | ||
2441 | time_remaining = (int) time_left / 60; | ||
2442 | |||
2443 | printf (_("%s - Certificate '%s' expires in %u %s (%s)\n"), | ||
2444 | (days_left>days_till_exp_crit) ? "WARNING" : "CRITICAL", host_name, time_remaining, | ||
2445 | time_left >= 3600 ? "hours" : "minutes", timestamp); | ||
2446 | |||
2447 | if ( days_left > days_till_exp_crit) | ||
2448 | status = STATE_WARNING; | ||
2449 | else | ||
2450 | status = STATE_CRITICAL; | ||
2451 | } else if (time_left < 0) { | ||
2452 | printf(_("CRITICAL - Certificate '%s' expired on %s.\n"), host_name, timestamp); | ||
2453 | status=STATE_CRITICAL; | ||
2454 | } else if (days_left == 0) { | ||
2455 | printf (_("%s - Certificate '%s' just expired (%s).\n"), (days_left>days_till_exp_crit)?"WARNING":"CRITICAL", host_name, timestamp); | ||
2456 | if (days_left > days_till_exp_crit) | ||
2457 | status = STATE_WARNING; | ||
2458 | else | ||
2459 | status = STATE_CRITICAL; | ||
2460 | } else { | ||
2461 | printf(_("OK - Certificate '%s' will expire on %s.\n"), host_name, timestamp); | ||
2462 | status = STATE_OK; | ||
2463 | } | ||
2464 | return status; | ||
2465 | } | ||
2466 | #endif /* USE_OPENSSL */ | ||
2467 | #endif /* LIBCURL_FEATURE_SSL */ | ||
diff --git a/plugins/check_dbi.c b/plugins/check_dbi.c index 826eb8d9..ced13d05 100644 --- a/plugins/check_dbi.c +++ b/plugins/check_dbi.c | |||
@@ -35,6 +35,7 @@ const char *email = "devel@monitoring-plugins.org"; | |||
35 | 35 | ||
36 | #include "common.h" | 36 | #include "common.h" |
37 | #include "utils.h" | 37 | #include "utils.h" |
38 | #include "utils_cmd.h" | ||
38 | 39 | ||
39 | #include "netutils.h" | 40 | #include "netutils.h" |
40 | 41 | ||
diff --git a/plugins/check_disk.c b/plugins/check_disk.c index e73a0083..54befcad 100644 --- a/plugins/check_disk.c +++ b/plugins/check_disk.c | |||
@@ -1,29 +1,29 @@ | |||
1 | /***************************************************************************** | 1 | /***************************************************************************** |
2 | * | 2 | * |
3 | * Monitoring check_disk plugin | 3 | * Monitoring check_disk plugin |
4 | * | 4 | * |
5 | * License: GPL | 5 | * License: GPL |
6 | * Copyright (c) 1999-2008 Monitoring Plugins Development Team | 6 | * Copyright (c) 1999-2008 Monitoring Plugins Development Team |
7 | * | 7 | * |
8 | * Description: | 8 | * Description: |
9 | * | 9 | * |
10 | * This file contains the check_disk plugin | 10 | * This file contains the check_disk plugin |
11 | * | 11 | * |
12 | * | 12 | * |
13 | * This program is free software: you can redistribute it and/or modify | 13 | * This program is free software: you can redistribute it and/or modify |
14 | * it under the terms of the GNU General Public License as published by | 14 | * it under the terms of the GNU General Public License as published by |
15 | * the Free Software Foundation, either version 3 of the License, or | 15 | * the Free Software Foundation, either version 3 of the License, or |
16 | * (at your option) any later version. | 16 | * (at your option) any later version. |
17 | * | 17 | * |
18 | * This program is distributed in the hope that it will be useful, | 18 | * This program is distributed in the hope that it will be useful, |
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | 19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | 20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
21 | * GNU General Public License for more details. | 21 | * GNU General Public License for more details. |
22 | * | 22 | * |
23 | * You should have received a copy of the GNU General Public License | 23 | * You should have received a copy of the GNU General Public License |
24 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | 24 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
25 | * | 25 | * |
26 | * | 26 | * |
27 | *****************************************************************************/ | 27 | *****************************************************************************/ |
28 | 28 | ||
29 | const char *progname = "check_disk"; | 29 | const char *progname = "check_disk"; |
@@ -46,7 +46,7 @@ const char *email = "devel@monitoring-plugins.org"; | |||
46 | #include <stdarg.h> | 46 | #include <stdarg.h> |
47 | #include "fsusage.h" | 47 | #include "fsusage.h" |
48 | #include "mountlist.h" | 48 | #include "mountlist.h" |
49 | #include "intprops.h" /* necessary for TYPE_MAXIMUM */ | 49 | #include "intprops.h" /* necessary for TYPE_MAXIMUM */ |
50 | #if HAVE_LIMITS_H | 50 | #if HAVE_LIMITS_H |
51 | # include <limits.h> | 51 | # include <limits.h> |
52 | #endif | 52 | #endif |
@@ -141,6 +141,7 @@ int erronly = FALSE; | |||
141 | int display_mntp = FALSE; | 141 | int display_mntp = FALSE; |
142 | int exact_match = FALSE; | 142 | int exact_match = FALSE; |
143 | int freespace_ignore_reserved = FALSE; | 143 | int freespace_ignore_reserved = FALSE; |
144 | int display_inodes_perfdata = FALSE; | ||
144 | char *warn_freespace_units = NULL; | 145 | char *warn_freespace_units = NULL; |
145 | char *crit_freespace_units = NULL; | 146 | char *crit_freespace_units = NULL; |
146 | char *warn_freespace_percent = NULL; | 147 | char *warn_freespace_percent = NULL; |
@@ -167,11 +168,10 @@ main (int argc, char **argv) | |||
167 | char *output; | 168 | char *output; |
168 | char *details; | 169 | char *details; |
169 | char *perf; | 170 | char *perf; |
171 | char *perf_ilabel; | ||
170 | char *preamble; | 172 | char *preamble; |
171 | char *flag_header; | 173 | char *flag_header; |
172 | double inode_space_pct; | 174 | double inode_space_pct; |
173 | double warning_high_tide; | ||
174 | double critical_high_tide; | ||
175 | int temp_result; | 175 | int temp_result; |
176 | 176 | ||
177 | struct mount_entry *me; | 177 | struct mount_entry *me; |
@@ -186,6 +186,7 @@ main (int argc, char **argv) | |||
186 | output = strdup (""); | 186 | output = strdup (""); |
187 | details = strdup (""); | 187 | details = strdup (""); |
188 | perf = strdup (""); | 188 | perf = strdup (""); |
189 | perf_ilabel = strdup (""); | ||
189 | stat_buf = malloc(sizeof *stat_buf); | 190 | stat_buf = malloc(sizeof *stat_buf); |
190 | 191 | ||
191 | setlocale (LC_ALL, ""); | 192 | setlocale (LC_ALL, ""); |
@@ -242,17 +243,17 @@ main (int argc, char **argv) | |||
242 | 243 | ||
243 | #ifdef __CYGWIN__ | 244 | #ifdef __CYGWIN__ |
244 | if (strncmp(path->name, "/cygdrive/", 10) != 0 || strlen(path->name) > 11) | 245 | if (strncmp(path->name, "/cygdrive/", 10) != 0 || strlen(path->name) > 11) |
245 | continue; | 246 | continue; |
246 | snprintf(mountdir, sizeof(mountdir), "%s:\\", me->me_mountdir + 10); | 247 | snprintf(mountdir, sizeof(mountdir), "%s:\\", me->me_mountdir + 10); |
247 | if (GetDriveType(mountdir) != DRIVE_FIXED) | 248 | if (GetDriveType(mountdir) != DRIVE_FIXED) |
248 | me->me_remote = 1; | 249 | me->me_remote = 1; |
249 | #endif | 250 | #endif |
250 | /* Filters */ | 251 | /* Filters */ |
251 | 252 | ||
252 | /* Remove filesystems already seen */ | 253 | /* Remove filesystems already seen */ |
253 | if (np_seen_name(seen, me->me_mountdir)) { | 254 | if (np_seen_name(seen, me->me_mountdir)) { |
254 | continue; | 255 | continue; |
255 | } | 256 | } |
256 | np_add_name(&seen, me->me_mountdir); | 257 | np_add_name(&seen, me->me_mountdir); |
257 | 258 | ||
258 | if (path->group == NULL) { | 259 | if (path->group == NULL) { |
@@ -285,8 +286,17 @@ main (int argc, char **argv) | |||
285 | get_stats (path, &fsp); | 286 | get_stats (path, &fsp); |
286 | 287 | ||
287 | if (verbose >= 3) { | 288 | if (verbose >= 3) { |
288 | printf ("For %s, used_pct=%g free_pct=%g used_units=%g free_units=%g total_units=%g used_inodes_pct=%g free_inodes_pct=%g fsp.fsu_blocksize=%llu mult=%llu\n", | 289 | printf ("For %s, used_pct=%g free_pct=%g used_units=%llu free_units=%llu total_units=%llu used_inodes_pct=%g free_inodes_pct=%g fsp.fsu_blocksize=%llu mult=%llu\n", |
289 | me->me_mountdir, path->dused_pct, path->dfree_pct, path->dused_units, path->dfree_units, path->dtotal_units, path->dused_inodes_percent, path->dfree_inodes_percent, fsp.fsu_blocksize, mult); | 290 | me->me_mountdir, |
291 | path->dused_pct, | ||
292 | path->dfree_pct, | ||
293 | path->dused_units, | ||
294 | path->dfree_units, | ||
295 | path->dtotal_units, | ||
296 | path->dused_inodes_percent, | ||
297 | path->dfree_inodes_percent, | ||
298 | fsp.fsu_blocksize, | ||
299 | mult); | ||
290 | } | 300 | } |
291 | 301 | ||
292 | /* Threshold comparisons */ | 302 | /* Threshold comparisons */ |
@@ -323,54 +333,79 @@ main (int argc, char **argv) | |||
323 | */ | 333 | */ |
324 | 334 | ||
325 | /* *_high_tide must be reinitialized at each run */ | 335 | /* *_high_tide must be reinitialized at each run */ |
326 | warning_high_tide = UINT_MAX; | 336 | uint64_t warning_high_tide = UINT64_MAX; |
327 | critical_high_tide = UINT_MAX; | ||
328 | 337 | ||
329 | if (path->freespace_units->warning != NULL) { | 338 | if (path->freespace_units->warning != NULL) { |
330 | warning_high_tide = path->dtotal_units - path->freespace_units->warning->end; | 339 | warning_high_tide = (path->dtotal_units - path->freespace_units->warning->end) * mult; |
331 | } | 340 | } |
332 | if (path->freespace_percent->warning != NULL) { | 341 | if (path->freespace_percent->warning != NULL) { |
333 | warning_high_tide = abs( min( (double) warning_high_tide, (double) (1.0 - path->freespace_percent->warning->end/100)*path->dtotal_units )); | 342 | warning_high_tide = min( warning_high_tide, (uint64_t)((1.0 - path->freespace_percent->warning->end/100) * (path->dtotal_units * mult)) ); |
334 | } | 343 | } |
344 | |||
345 | uint64_t critical_high_tide = UINT64_MAX; | ||
346 | |||
335 | if (path->freespace_units->critical != NULL) { | 347 | if (path->freespace_units->critical != NULL) { |
336 | critical_high_tide = path->dtotal_units - path->freespace_units->critical->end; | 348 | critical_high_tide = (path->dtotal_units - path->freespace_units->critical->end) * mult; |
337 | } | 349 | } |
338 | if (path->freespace_percent->critical != NULL) { | 350 | if (path->freespace_percent->critical != NULL) { |
339 | critical_high_tide = abs( min( (double) critical_high_tide, (double) (1.0 - path->freespace_percent->critical->end/100)*path->dtotal_units )); | 351 | critical_high_tide = min( critical_high_tide, (uint64_t)((1.0 - path->freespace_percent->critical->end/100) * (path->dtotal_units * mult)) ); |
340 | } | 352 | } |
341 | 353 | ||
342 | /* Nb: *_high_tide are unset when == UINT_MAX */ | 354 | /* Nb: *_high_tide are unset when == UINT64_MAX */ |
343 | xasprintf (&perf, "%s %s", perf, | 355 | xasprintf (&perf, "%s %s", perf, |
344 | perfdata ((!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir, | 356 | perfdata_uint64 ( |
345 | path->dused_units, units, | 357 | (!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir, |
346 | (warning_high_tide != UINT_MAX ? TRUE : FALSE), warning_high_tide, | 358 | path->dused_units * mult, "B", |
347 | (critical_high_tide != UINT_MAX ? TRUE : FALSE), critical_high_tide, | 359 | (warning_high_tide == UINT64_MAX ? FALSE : TRUE), warning_high_tide, |
348 | TRUE, 0, | 360 | (critical_high_tide == UINT64_MAX ? FALSE : TRUE), critical_high_tide, |
349 | TRUE, path->dtotal_units)); | 361 | TRUE, 0, |
362 | TRUE, path->dtotal_units * mult)); | ||
363 | |||
364 | if (display_inodes_perfdata) { | ||
365 | /* *_high_tide must be reinitialized at each run */ | ||
366 | warning_high_tide = UINT64_MAX; | ||
367 | critical_high_tide = UINT64_MAX; | ||
368 | |||
369 | if (path->freeinodes_percent->warning != NULL) { | ||
370 | warning_high_tide = llabs( min( (double) warning_high_tide, (double) (1.0 - path->freeinodes_percent->warning->end/100)*path->inodes_total )); | ||
371 | } | ||
372 | if (path->freeinodes_percent->critical != NULL) { | ||
373 | critical_high_tide = llabs( min( (double) critical_high_tide, (double) (1.0 - path->freeinodes_percent->critical->end/100)*path->inodes_total )); | ||
374 | } | ||
375 | |||
376 | xasprintf (&perf_ilabel, "%s (inodes)", (!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir); | ||
377 | /* Nb: *_high_tide are unset when == UINT64_MAX */ | ||
378 | xasprintf (&perf, "%s %s", perf, | ||
379 | perfdata_uint64 (perf_ilabel, | ||
380 | path->inodes_used, "", | ||
381 | (warning_high_tide != UINT64_MAX ? TRUE : FALSE), warning_high_tide, | ||
382 | (critical_high_tide != UINT64_MAX ? TRUE : FALSE), critical_high_tide, | ||
383 | TRUE, 0, | ||
384 | TRUE, path->inodes_total)); | ||
385 | } | ||
350 | 386 | ||
351 | if (disk_result==STATE_OK && erronly && !verbose) | 387 | if (disk_result==STATE_OK && erronly && !verbose) |
352 | continue; | 388 | continue; |
353 | 389 | ||
354 | if(disk_result && verbose >= 1) { | 390 | if(disk_result && verbose >= 1) { |
355 | xasprintf(&flag_header, " %s [", state_text (disk_result)); | 391 | xasprintf(&flag_header, " %s [", state_text (disk_result)); |
356 | } else { | 392 | } else { |
357 | xasprintf(&flag_header, ""); | 393 | xasprintf(&flag_header, ""); |
358 | } | 394 | } |
359 | xasprintf (&output, "%s%s %s %.0f %s (%.0f%%", | 395 | xasprintf (&output, "%s%s %s %llu%s (%.0f%%", |
360 | output, flag_header, | 396 | output, flag_header, |
361 | (!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir, | 397 | (!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir, |
362 | path->dfree_units, | 398 | path->dfree_units, |
363 | units, | 399 | units, |
364 | path->dfree_pct); | 400 | path->dfree_pct); |
365 | if (path->dused_inodes_percent < 0) { | 401 | if (path->dused_inodes_percent < 0) { |
366 | xasprintf(&output, "%s inode=-)%s;", output, (disk_result ? "]" : "")); | 402 | xasprintf(&output, "%s inode=-)%s;", output, (disk_result ? "]" : "")); |
367 | } else { | 403 | } else { |
368 | xasprintf(&output, "%s inode=%.0f%%)%s;", output, path->dfree_inodes_percent, ((disk_result && verbose >= 1) ? "]" : "")); | 404 | xasprintf(&output, "%s inode=%.0f%%)%s;", output, path->dfree_inodes_percent, ((disk_result && verbose >= 1) ? "]" : "")); |
369 | } | 405 | } |
370 | free(flag_header); | 406 | free(flag_header); |
371 | /* TODO: Need to do a similar debug line | 407 | /* TODO: Need to do a similar debug line |
372 | xasprintf (&details, _("%s\n\ | 408 | xasprintf (&details, _("%s\n\%.0f of %.0f %s (%.0f%% inode=%.0f%%) free on %s (type %s mounted on %s) warn:%lu crit:%lu warn%%:%.0f%% crit%%:%.0f%%"), |
373 | %.0f of %.0f %s (%.0f%% inode=%.0f%%) free on %s (type %s mounted on %s) warn:%lu crit:%lu warn%%:%.0f%% crit%%:%.0f%%"), | ||
374 | details, dfree_units, dtotal_units, units, dfree_pct, inode_space_pct, | 409 | details, dfree_units, dtotal_units, units, dfree_pct, inode_space_pct, |
375 | me->me_devname, me->me_type, me->me_mountdir, | 410 | me->me_devname, me->me_type, me->me_mountdir, |
376 | (unsigned long)w_df, (unsigned long)c_df, w_dfp, c_dfp); | 411 | (unsigned long)w_df, (unsigned long)c_df, w_dfp, c_dfp); |
@@ -455,6 +490,7 @@ process_arguments (int argc, char **argv) | |||
455 | {"ignore-eregi-partition", required_argument, 0, 'I'}, | 490 | {"ignore-eregi-partition", required_argument, 0, 'I'}, |
456 | {"local", no_argument, 0, 'l'}, | 491 | {"local", no_argument, 0, 'l'}, |
457 | {"stat-remote-fs", no_argument, 0, 'L'}, | 492 | {"stat-remote-fs", no_argument, 0, 'L'}, |
493 | {"iperfdata", no_argument, 0, 'P'}, | ||
458 | {"mountpoint", no_argument, 0, 'M'}, | 494 | {"mountpoint", no_argument, 0, 'M'}, |
459 | {"errors-only", no_argument, 0, 'e'}, | 495 | {"errors-only", no_argument, 0, 'e'}, |
460 | {"exact-match", no_argument, 0, 'E'}, | 496 | {"exact-match", no_argument, 0, 'E'}, |
@@ -477,7 +513,7 @@ process_arguments (int argc, char **argv) | |||
477 | strcpy (argv[c], "-t"); | 513 | strcpy (argv[c], "-t"); |
478 | 514 | ||
479 | while (1) { | 515 | while (1) { |
480 | c = getopt_long (argc, argv, "+?VqhvefCt:c:w:K:W:u:p:x:X:N:mklLg:R:r:i:I:MEA", longopts, &option); | 516 | c = getopt_long (argc, argv, "+?VqhvefCt:c:w:K:W:u:p:x:X:N:mklLPg:R:r:i:I:MEA", longopts, &option); |
481 | 517 | ||
482 | if (c == -1 || c == EOF) | 518 | if (c == -1 || c == EOF) |
483 | break; | 519 | break; |
@@ -530,14 +566,14 @@ process_arguments (int argc, char **argv) | |||
530 | } | 566 | } |
531 | break; | 567 | break; |
532 | 568 | ||
533 | case 'W': /* warning inode threshold */ | 569 | case 'W': /* warning inode threshold */ |
534 | if (*optarg == '@') { | 570 | if (*optarg == '@') { |
535 | warn_freeinodes_percent = optarg; | 571 | warn_freeinodes_percent = optarg; |
536 | } else { | 572 | } else { |
537 | xasprintf(&warn_freeinodes_percent, "@%s", optarg); | 573 | xasprintf(&warn_freeinodes_percent, "@%s", optarg); |
538 | } | 574 | } |
539 | break; | 575 | break; |
540 | case 'K': /* critical inode threshold */ | 576 | case 'K': /* critical inode threshold */ |
541 | if (*optarg == '@') { | 577 | if (*optarg == '@') { |
542 | crit_freeinodes_percent = optarg; | 578 | crit_freeinodes_percent = optarg; |
543 | } else { | 579 | } else { |
@@ -547,21 +583,24 @@ process_arguments (int argc, char **argv) | |||
547 | case 'u': | 583 | case 'u': |
548 | if (units) | 584 | if (units) |
549 | free(units); | 585 | free(units); |
550 | if (! strcmp (optarg, "bytes")) { | 586 | if (! strcasecmp (optarg, "bytes")) { |
551 | mult = (uintmax_t)1; | 587 | mult = (uintmax_t)1; |
552 | units = strdup ("B"); | 588 | units = strdup ("B"); |
553 | } else if (! strcmp (optarg, "kB")) { | 589 | } else if ( (! strcmp (optarg, "kB")) || (!strcmp(optarg, "KiB")) ) { |
554 | mult = (uintmax_t)1024; | 590 | mult = (uintmax_t)1024; |
555 | units = strdup ("kB"); | 591 | units = strdup ("kiB"); |
556 | } else if (! strcmp (optarg, "MB")) { | 592 | } else if ( (! strcmp (optarg, "MB")) || (!strcmp(optarg, "MiB")) ) { |
557 | mult = (uintmax_t)1024 * 1024; | 593 | mult = (uintmax_t)1024 * 1024; |
558 | units = strdup ("MB"); | 594 | units = strdup ("MiB"); |
559 | } else if (! strcmp (optarg, "GB")) { | 595 | } else if ( (! strcmp (optarg, "GB")) || (!strcmp(optarg, "GiB")) ) { |
560 | mult = (uintmax_t)1024 * 1024 * 1024; | 596 | mult = (uintmax_t)1024 * 1024 * 1024; |
561 | units = strdup ("GB"); | 597 | units = strdup ("GiB"); |
562 | } else if (! strcmp (optarg, "TB")) { | 598 | } else if ( (! strcmp (optarg, "TB")) || (!strcmp(optarg, "TiB")) ) { |
563 | mult = (uintmax_t)1024 * 1024 * 1024 * 1024; | 599 | mult = (uintmax_t)1024 * 1024 * 1024 * 1024; |
564 | units = strdup ("TB"); | 600 | units = strdup ("TiB"); |
601 | } else if ( (! strcmp (optarg, "PB")) || (!strcmp(optarg, "PiB")) ) { | ||
602 | mult = (uintmax_t)1024 * 1024 * 1024 * 1024 * 1024; | ||
603 | units = strdup ("PiB"); | ||
565 | } else { | 604 | } else { |
566 | die (STATE_UNKNOWN, _("unit type %s not known\n"), optarg); | 605 | die (STATE_UNKNOWN, _("unit type %s not known\n"), optarg); |
567 | } | 606 | } |
@@ -572,19 +611,23 @@ process_arguments (int argc, char **argv) | |||
572 | mult = 1024; | 611 | mult = 1024; |
573 | if (units) | 612 | if (units) |
574 | free(units); | 613 | free(units); |
575 | units = strdup ("kB"); | 614 | units = strdup ("kiB"); |
576 | break; | 615 | break; |
577 | case 'm': /* display mountpoint */ | 616 | case 'm': /* display mountpoint */ |
578 | mult = 1024 * 1024; | 617 | mult = 1024 * 1024; |
579 | if (units) | 618 | if (units) |
580 | free(units); | 619 | free(units); |
581 | units = strdup ("MB"); | 620 | units = strdup ("MiB"); |
582 | break; | 621 | break; |
583 | case 'L': | 622 | case 'L': |
584 | stat_remote_fs = 1; | 623 | stat_remote_fs = 1; |
624 | /* fallthrough */ | ||
585 | case 'l': | 625 | case 'l': |
586 | show_local_fs = 1; | 626 | show_local_fs = 1; |
587 | break; | 627 | break; |
628 | case 'P': | ||
629 | display_inodes_perfdata = 1; | ||
630 | break; | ||
588 | case 'p': /* select path */ | 631 | case 'p': /* select path */ |
589 | if (! (warn_freespace_units || crit_freespace_units || warn_freespace_percent || | 632 | if (! (warn_freespace_units || crit_freespace_units || warn_freespace_percent || |
590 | crit_freespace_percent || warn_usedspace_units || crit_usedspace_units || | 633 | crit_freespace_percent || warn_usedspace_units || crit_usedspace_units || |
@@ -781,7 +824,7 @@ process_arguments (int argc, char **argv) | |||
781 | } | 824 | } |
782 | 825 | ||
783 | if (units == NULL) { | 826 | if (units == NULL) { |
784 | units = strdup ("MB"); | 827 | units = strdup ("MiB"); |
785 | mult = (uintmax_t)1024 * 1024; | 828 | mult = (uintmax_t)1024 * 1024; |
786 | } | 829 | } |
787 | 830 | ||
@@ -904,6 +947,8 @@ print_help (void) | |||
904 | printf (" %s\n", _("Display only devices/mountpoints with errors")); | 947 | printf (" %s\n", _("Display only devices/mountpoints with errors")); |
905 | printf (" %s\n", "-f, --freespace-ignore-reserved"); | 948 | printf (" %s\n", "-f, --freespace-ignore-reserved"); |
906 | printf (" %s\n", _("Don't account root-reserved blocks into freespace in perfdata")); | 949 | printf (" %s\n", _("Don't account root-reserved blocks into freespace in perfdata")); |
950 | printf (" %s\n", "-P, --iperfdata"); | ||
951 | printf (" %s\n", _("Display inode usage in perfdata")); | ||
907 | printf (" %s\n", "-g, --group=NAME"); | 952 | printf (" %s\n", "-g, --group=NAME"); |
908 | printf (" %s\n", _("Group paths. Thresholds apply to (free-)space of all partitions together")); | 953 | printf (" %s\n", _("Group paths. Thresholds apply to (free-)space of all partitions together")); |
909 | printf (" %s\n", "-k, --kilobytes"); | 954 | printf (" %s\n", "-k, --kilobytes"); |
@@ -993,50 +1038,59 @@ get_stats (struct parameter_list *p, struct fs_usage *fsp) { | |||
993 | if (p_list->group && ! (strcmp(p_list->group, p->group))) { | 1038 | if (p_list->group && ! (strcmp(p_list->group, p->group))) { |
994 | stat_path(p_list); | 1039 | stat_path(p_list); |
995 | get_fs_usage (p_list->best_match->me_mountdir, p_list->best_match->me_devname, &tmpfsp); | 1040 | get_fs_usage (p_list->best_match->me_mountdir, p_list->best_match->me_devname, &tmpfsp); |
996 | get_path_stats(p_list, &tmpfsp); | 1041 | get_path_stats(p_list, &tmpfsp); |
997 | if (verbose >= 3) | 1042 | if (verbose >= 3) |
998 | printf("Group %s: adding %llu blocks sized %llu, (%s) used_units=%g free_units=%g total_units=%g fsu_blocksize=%llu mult=%llu\n", | 1043 | printf("Group %s: adding %llu blocks sized %llu, (%s) used_units=%lu free_units=%llu total_units=%llu mult=%llu\n", |
999 | p_list->group, tmpfsp.fsu_bavail, tmpfsp.fsu_blocksize, p_list->best_match->me_mountdir, p_list->dused_units, p_list->dfree_units, | 1044 | p_list->group, |
1000 | p_list->dtotal_units, mult); | 1045 | tmpfsp.fsu_blocks, |
1001 | 1046 | tmpfsp.fsu_blocksize, | |
1002 | /* prevent counting the first FS of a group twice since its parameter_list entry | 1047 | p_list->best_match->me_mountdir, |
1048 | p_list->dused_units, | ||
1049 | p_list->dfree_units, | ||
1050 | p_list->dtotal_units, | ||
1051 | mult); | ||
1052 | |||
1053 | /* prevent counting the first FS of a group twice since its parameter_list entry | ||
1003 | * is used to carry the information of all file systems of the entire group */ | 1054 | * is used to carry the information of all file systems of the entire group */ |
1004 | if (! first) { | 1055 | if (! first) { |
1005 | p->total += p_list->total; | 1056 | p->total += p_list->total; |
1006 | p->available += p_list->available; | 1057 | p->available += p_list->available; |
1007 | p->available_to_root += p_list->available_to_root; | 1058 | p->available_to_root += p_list->available_to_root; |
1008 | p->used += p_list->used; | 1059 | p->used += p_list->used; |
1009 | 1060 | ||
1010 | p->dused_units += p_list->dused_units; | 1061 | p->dused_units += p_list->dused_units; |
1011 | p->dfree_units += p_list->dfree_units; | 1062 | p->dfree_units += p_list->dfree_units; |
1012 | p->dtotal_units += p_list->dtotal_units; | 1063 | p->dtotal_units += p_list->dtotal_units; |
1013 | p->inodes_total += p_list->inodes_total; | 1064 | p->inodes_total += p_list->inodes_total; |
1014 | p->inodes_free += p_list->inodes_free; | 1065 | p->inodes_free += p_list->inodes_free; |
1066 | p->inodes_free_to_root += p_list->inodes_free_to_root; | ||
1067 | p->inodes_used += p_list->inodes_used; | ||
1015 | } | 1068 | } |
1016 | first = 0; | 1069 | first = 0; |
1017 | } | 1070 | } |
1018 | if (verbose >= 3) | 1071 | if (verbose >= 3) |
1019 | printf("Group %s now has: used_units=%g free_units=%g total_units=%g fsu_blocksize=%llu mult=%llu\n", | 1072 | printf("Group %s now has: used_units=%llu free_units=%llu total_units=%llu fsu_blocksize=%llu mult=%llu\n", |
1020 | p->group, tmpfsp.fsu_bavail, tmpfsp.fsu_blocksize, p->best_match->me_mountdir, p->dused_units, | 1073 | p->group, |
1021 | p->dfree_units, p->dtotal_units, mult); | 1074 | p->dused_units, |
1075 | p->dfree_units, | ||
1076 | p->dtotal_units, | ||
1077 | tmpfsp.fsu_blocksize, | ||
1078 | mult); | ||
1022 | } | 1079 | } |
1023 | /* modify devname and mountdir for output */ | 1080 | /* modify devname and mountdir for output */ |
1024 | p->best_match->me_mountdir = p->best_match->me_devname = p->group; | 1081 | p->best_match->me_mountdir = p->best_match->me_devname = p->group; |
1025 | } | 1082 | } |
1026 | /* finally calculate percentages for either plain FS or summed up group */ | 1083 | /* finally calculate percentages for either plain FS or summed up group */ |
1027 | p->dused_pct = calculate_percent( p->used, p->used + p->available ); /* used + available can never be > uintmax */ | 1084 | p->dused_pct = calculate_percent( p->used, p->used + p->available ); /* used + available can never be > uintmax */ |
1028 | p->dfree_pct = 100 - p->dused_pct; | 1085 | p->dfree_pct = 100 - p->dused_pct; |
1029 | p->dused_inodes_percent = calculate_percent(p->inodes_total - p->inodes_free, p->inodes_total); | 1086 | p->dused_inodes_percent = calculate_percent(p->inodes_total - p->inodes_free, p->inodes_total); |
1030 | p->dfree_inodes_percent = 100 - p->dused_inodes_percent; | 1087 | p->dfree_inodes_percent = 100 - p->dused_inodes_percent; |
1031 | 1088 | ||
1032 | } | 1089 | } |
1033 | 1090 | ||
1034 | void | 1091 | void |
1035 | get_path_stats (struct parameter_list *p, struct fs_usage *fsp) { | 1092 | get_path_stats (struct parameter_list *p, struct fs_usage *fsp) { |
1036 | /* 2007-12-08 - Workaround for Gnulib reporting insanely high available | 1093 | p->available = fsp->fsu_bavail; |
1037 | * space on BSD (the actual value should be negative but fsp->fsu_bavail | ||
1038 | * is unsigned) */ | ||
1039 | p->available = fsp->fsu_bavail > fsp->fsu_bfree ? 0 : fsp->fsu_bavail; | ||
1040 | p->available_to_root = fsp->fsu_bfree; | 1094 | p->available_to_root = fsp->fsu_bfree; |
1041 | p->used = fsp->fsu_blocks - fsp->fsu_bfree; | 1095 | p->used = fsp->fsu_blocks - fsp->fsu_bfree; |
1042 | if (freespace_ignore_reserved) { | 1096 | if (freespace_ignore_reserved) { |
@@ -1046,11 +1100,22 @@ get_path_stats (struct parameter_list *p, struct fs_usage *fsp) { | |||
1046 | /* default behaviour : take all the blocks into account */ | 1100 | /* default behaviour : take all the blocks into account */ |
1047 | p->total = fsp->fsu_blocks; | 1101 | p->total = fsp->fsu_blocks; |
1048 | } | 1102 | } |
1049 | 1103 | ||
1050 | p->dused_units = p->used*fsp->fsu_blocksize/mult; | 1104 | p->dused_units = p->used*fsp->fsu_blocksize/mult; |
1051 | p->dfree_units = p->available*fsp->fsu_blocksize/mult; | 1105 | p->dfree_units = p->available*fsp->fsu_blocksize/mult; |
1052 | p->dtotal_units = p->total*fsp->fsu_blocksize/mult; | 1106 | p->dtotal_units = p->total*fsp->fsu_blocksize/mult; |
1053 | p->inodes_total = fsp->fsu_files; /* Total file nodes. */ | 1107 | /* Free file nodes. Not sure the workaround is required, but in case...*/ |
1054 | p->inodes_free = fsp->fsu_ffree; /* Free file nodes. */ | 1108 | p->inodes_free = fsp->fsu_favail > fsp->fsu_ffree ? 0 : fsp->fsu_favail; |
1109 | p->inodes_free_to_root = fsp->fsu_ffree; /* Free file nodes for root. */ | ||
1110 | p->inodes_used = fsp->fsu_files - fsp->fsu_ffree; | ||
1111 | if (freespace_ignore_reserved) { | ||
1112 | /* option activated : we substract the root-reserved inodes from the total */ | ||
1113 | /* not all OS report fsp->fsu_favail, only the ones with statvfs syscall */ | ||
1114 | /* for others, fsp->fsu_ffree == fsp->fsu_favail */ | ||
1115 | p->inodes_total = fsp->fsu_files - p->inodes_free_to_root + p->inodes_free; | ||
1116 | } else { | ||
1117 | /* default behaviour : take all the inodes into account */ | ||
1118 | p->inodes_total = fsp->fsu_files; | ||
1119 | } | ||
1055 | np_add_name(&seen, p->best_match->me_mountdir); | 1120 | np_add_name(&seen, p->best_match->me_mountdir); |
1056 | } | 1121 | } |
diff --git a/plugins/check_dns.c b/plugins/check_dns.c index f2061636..9de6caf5 100644 --- a/plugins/check_dns.c +++ b/plugins/check_dns.c | |||
@@ -41,7 +41,7 @@ const char *email = "devel@monitoring-plugins.org"; | |||
41 | 41 | ||
42 | int process_arguments (int, char **); | 42 | int process_arguments (int, char **); |
43 | int validate_arguments (void); | 43 | int validate_arguments (void); |
44 | int error_scan (char *); | 44 | int error_scan (char *, int *); |
45 | int ip_match_cidr(const char *, const char *); | 45 | int ip_match_cidr(const char *, const char *); |
46 | unsigned long ip2long(const char *); | 46 | unsigned long ip2long(const char *); |
47 | void print_help (void); | 47 | void print_help (void); |
@@ -54,8 +54,10 @@ char ptr_server[ADDRESS_LENGTH] = ""; | |||
54 | int verbose = FALSE; | 54 | int verbose = FALSE; |
55 | char **expected_address = NULL; | 55 | char **expected_address = NULL; |
56 | int expected_address_cnt = 0; | 56 | int expected_address_cnt = 0; |
57 | int expect_nxdomain = FALSE; | ||
57 | 58 | ||
58 | int expect_authority = FALSE; | 59 | int expect_authority = FALSE; |
60 | int all_match = FALSE; | ||
59 | thresholds *time_thresholds = NULL; | 61 | thresholds *time_thresholds = NULL; |
60 | 62 | ||
61 | static int | 63 | static int |
@@ -86,6 +88,7 @@ main (int argc, char **argv) | |||
86 | int parse_address = FALSE; /* This flag scans for Address: but only after Name: */ | 88 | int parse_address = FALSE; /* This flag scans for Address: but only after Name: */ |
87 | output chld_out, chld_err; | 89 | output chld_out, chld_err; |
88 | size_t i; | 90 | size_t i; |
91 | int is_nxdomain = FALSE; | ||
89 | 92 | ||
90 | setlocale (LC_ALL, ""); | 93 | setlocale (LC_ALL, ""); |
91 | bindtextdomain (PACKAGE, LOCALEDIR); | 94 | bindtextdomain (PACKAGE, LOCALEDIR); |
@@ -168,8 +171,8 @@ main (int argc, char **argv) | |||
168 | temp_buffer++; | 171 | temp_buffer++; |
169 | 172 | ||
170 | /* Strip leading spaces */ | 173 | /* Strip leading spaces */ |
171 | for (; *temp_buffer != '\0' && *temp_buffer == ' '; temp_buffer++) | 174 | while (*temp_buffer == ' ') |
172 | /* NOOP */; | 175 | temp_buffer++; |
173 | 176 | ||
174 | strip(temp_buffer); | 177 | strip(temp_buffer); |
175 | if (temp_buffer==NULL || strlen(temp_buffer)==0) { | 178 | if (temp_buffer==NULL || strlen(temp_buffer)==0) { |
@@ -185,7 +188,7 @@ main (int argc, char **argv) | |||
185 | } | 188 | } |
186 | 189 | ||
187 | 190 | ||
188 | result = error_scan (chld_out.line[i]); | 191 | result = error_scan (chld_out.line[i], &is_nxdomain); |
189 | if (result != STATE_OK) { | 192 | if (result != STATE_OK) { |
190 | msg = strchr (chld_out.line[i], ':'); | 193 | msg = strchr (chld_out.line[i], ':'); |
191 | if(msg) msg++; | 194 | if(msg) msg++; |
@@ -198,13 +201,20 @@ main (int argc, char **argv) | |||
198 | if (verbose) | 201 | if (verbose) |
199 | puts(chld_err.line[i]); | 202 | puts(chld_err.line[i]); |
200 | 203 | ||
201 | if (error_scan (chld_err.line[i]) != STATE_OK) { | 204 | if (error_scan (chld_err.line[i], &is_nxdomain) != STATE_OK) { |
202 | result = max_state (result, error_scan (chld_err.line[i])); | 205 | result = max_state (result, error_scan (chld_err.line[i], &is_nxdomain)); |
203 | msg = strchr(input_buffer, ':'); | 206 | msg = strchr(input_buffer, ':'); |
204 | if(msg) msg++; | 207 | if(msg) |
208 | msg++; | ||
209 | else | ||
210 | msg = input_buffer; | ||
205 | } | 211 | } |
206 | } | 212 | } |
207 | 213 | ||
214 | if (is_nxdomain && !expect_nxdomain) { | ||
215 | die (STATE_CRITICAL, _("Domain '%s' was not found by the server\n"), query_address); | ||
216 | } | ||
217 | |||
208 | if (addresses) { | 218 | if (addresses) { |
209 | int i,slen; | 219 | int i,slen; |
210 | char *adrp; | 220 | char *adrp; |
@@ -228,16 +238,27 @@ main (int argc, char **argv) | |||
228 | if (result == STATE_OK && expected_address_cnt > 0) { | 238 | if (result == STATE_OK && expected_address_cnt > 0) { |
229 | result = STATE_CRITICAL; | 239 | result = STATE_CRITICAL; |
230 | temp_buffer = ""; | 240 | temp_buffer = ""; |
241 | unsigned long expect_match = (1 << expected_address_cnt) - 1; | ||
242 | unsigned long addr_match = (1 << n_addresses) - 1; | ||
231 | 243 | ||
232 | for (i=0; i<expected_address_cnt; i++) { | 244 | for (i=0; i<expected_address_cnt; i++) { |
245 | int j; | ||
233 | /* check if we get a match on 'raw' ip or cidr */ | 246 | /* check if we get a match on 'raw' ip or cidr */ |
234 | if ( strcmp(address, expected_address[i]) == 0 | 247 | for (j=0; j<n_addresses; j++) { |
235 | || ip_match_cidr(address, expected_address[i]) ) | 248 | if ( strcmp(addresses[j], expected_address[i]) == 0 |
236 | result = STATE_OK; | 249 | || ip_match_cidr(addresses[j], expected_address[i]) ) { |
250 | result = STATE_OK; | ||
251 | addr_match &= ~(1 << j); | ||
252 | expect_match &= ~(1 << i); | ||
253 | } | ||
254 | } | ||
237 | 255 | ||
238 | /* prepare an error string */ | 256 | /* prepare an error string */ |
239 | xasprintf(&temp_buffer, "%s%s; ", temp_buffer, expected_address[i]); | 257 | xasprintf(&temp_buffer, "%s%s; ", temp_buffer, expected_address[i]); |
240 | } | 258 | } |
259 | /* check if expected_address must cover all in addresses and none may be missing */ | ||
260 | if (all_match && (expect_match != 0 || addr_match != 0)) | ||
261 | result = STATE_CRITICAL; | ||
241 | if (result == STATE_CRITICAL) { | 262 | if (result == STATE_CRITICAL) { |
242 | /* Strip off last semicolon... */ | 263 | /* Strip off last semicolon... */ |
243 | temp_buffer[strlen(temp_buffer)-2] = '\0'; | 264 | temp_buffer[strlen(temp_buffer)-2] = '\0'; |
@@ -245,6 +266,16 @@ main (int argc, char **argv) | |||
245 | } | 266 | } |
246 | } | 267 | } |
247 | 268 | ||
269 | if (expect_nxdomain) { | ||
270 | if (!is_nxdomain) { | ||
271 | result = STATE_CRITICAL; | ||
272 | xasprintf(&msg, _("Domain '%s' was found by the server: '%s'\n"), query_address, address); | ||
273 | } else { | ||
274 | if (address != NULL) free(address); | ||
275 | address = "NXDOMAIN"; | ||
276 | } | ||
277 | } | ||
278 | |||
248 | /* check if authoritative */ | 279 | /* check if authoritative */ |
249 | if (result == STATE_OK && expect_authority && non_authoritative) { | 280 | if (result == STATE_OK && expect_authority && non_authoritative) { |
250 | result = STATE_CRITICAL; | 281 | result = STATE_CRITICAL; |
@@ -324,9 +355,15 @@ ip2long(const char* src) { | |||
324 | } | 355 | } |
325 | 356 | ||
326 | int | 357 | int |
327 | error_scan (char *input_buffer) | 358 | error_scan (char *input_buffer, int *is_nxdomain) |
328 | { | 359 | { |
329 | 360 | ||
361 | const int nxdomain = strstr (input_buffer, "Non-existent") || | ||
362 | strstr (input_buffer, "** server can't find") || | ||
363 | strstr (input_buffer, "** Can't find") || | ||
364 | strstr (input_buffer, "NXDOMAIN"); | ||
365 | if (nxdomain) *is_nxdomain = TRUE; | ||
366 | |||
330 | /* the DNS lookup timed out */ | 367 | /* the DNS lookup timed out */ |
331 | if (strstr (input_buffer, _("Note: nslookup is deprecated and may be removed from future releases.")) || | 368 | if (strstr (input_buffer, _("Note: nslookup is deprecated and may be removed from future releases.")) || |
332 | strstr (input_buffer, _("Consider using the `dig' or `host' programs instead. Run nslookup with")) || | 369 | strstr (input_buffer, _("Consider using the `dig' or `host' programs instead. Run nslookup with")) || |
@@ -336,6 +373,8 @@ error_scan (char *input_buffer) | |||
336 | /* DNS server is not running... */ | 373 | /* DNS server is not running... */ |
337 | else if (strstr (input_buffer, "No response from server")) | 374 | else if (strstr (input_buffer, "No response from server")) |
338 | die (STATE_CRITICAL, _("No response from DNS %s\n"), dns_server); | 375 | die (STATE_CRITICAL, _("No response from DNS %s\n"), dns_server); |
376 | else if (strstr (input_buffer, "no servers could be reached")) | ||
377 | die (STATE_CRITICAL, _("No response from DNS %s\n"), dns_server); | ||
339 | 378 | ||
340 | /* Host name is valid, but server doesn't have records... */ | 379 | /* Host name is valid, but server doesn't have records... */ |
341 | else if (strstr (input_buffer, "No records")) | 380 | else if (strstr (input_buffer, "No records")) |
@@ -343,7 +382,7 @@ error_scan (char *input_buffer) | |||
343 | 382 | ||
344 | /* Connection was refused */ | 383 | /* Connection was refused */ |
345 | else if (strstr (input_buffer, "Connection refused") || | 384 | else if (strstr (input_buffer, "Connection refused") || |
346 | strstr (input_buffer, "Couldn't find server") || | 385 | strstr (input_buffer, "Couldn't find server") || |
347 | strstr (input_buffer, "Refused") || | 386 | strstr (input_buffer, "Refused") || |
348 | (strstr (input_buffer, "** server can't find") && | 387 | (strstr (input_buffer, "** server can't find") && |
349 | strstr (input_buffer, ": REFUSED"))) | 388 | strstr (input_buffer, ": REFUSED"))) |
@@ -357,13 +396,6 @@ error_scan (char *input_buffer) | |||
357 | else if (strstr (input_buffer, "No information")) | 396 | else if (strstr (input_buffer, "No information")) |
358 | die (STATE_CRITICAL, _("No information returned by DNS server at %s\n"), dns_server); | 397 | die (STATE_CRITICAL, _("No information returned by DNS server at %s\n"), dns_server); |
359 | 398 | ||
360 | /* Host or domain name does not exist */ | ||
361 | else if (strstr (input_buffer, "Non-existent") || | ||
362 | strstr (input_buffer, "** server can't find") || | ||
363 | strstr (input_buffer, "** Can't find") || | ||
364 | strstr (input_buffer,"NXDOMAIN")) | ||
365 | die (STATE_CRITICAL, _("Domain %s was not found by the server\n"), query_address); | ||
366 | |||
367 | /* Network is unreachable */ | 399 | /* Network is unreachable */ |
368 | else if (strstr (input_buffer, "Network is unreachable")) | 400 | else if (strstr (input_buffer, "Network is unreachable")) |
369 | die (STATE_CRITICAL, _("Network is unreachable\n")); | 401 | die (STATE_CRITICAL, _("Network is unreachable\n")); |
@@ -400,7 +432,9 @@ process_arguments (int argc, char **argv) | |||
400 | {"server", required_argument, 0, 's'}, | 432 | {"server", required_argument, 0, 's'}, |
401 | {"reverse-server", required_argument, 0, 'r'}, | 433 | {"reverse-server", required_argument, 0, 'r'}, |
402 | {"expected-address", required_argument, 0, 'a'}, | 434 | {"expected-address", required_argument, 0, 'a'}, |
435 | {"expect-nxdomain", no_argument, 0, 'n'}, | ||
403 | {"expect-authority", no_argument, 0, 'A'}, | 436 | {"expect-authority", no_argument, 0, 'A'}, |
437 | {"all", no_argument, 0, 'L'}, | ||
404 | {"warning", required_argument, 0, 'w'}, | 438 | {"warning", required_argument, 0, 'w'}, |
405 | {"critical", required_argument, 0, 'c'}, | 439 | {"critical", required_argument, 0, 'c'}, |
406 | {0, 0, 0, 0} | 440 | {0, 0, 0, 0} |
@@ -414,7 +448,7 @@ process_arguments (int argc, char **argv) | |||
414 | strcpy (argv[c], "-t"); | 448 | strcpy (argv[c], "-t"); |
415 | 449 | ||
416 | while (1) { | 450 | while (1) { |
417 | c = getopt_long (argc, argv, "hVvAt:H:s:r:a:w:c:", long_opts, &opt_index); | 451 | c = getopt_long (argc, argv, "hVvALnt:H:s:r:a:w:c:", long_opts, &opt_index); |
418 | 452 | ||
419 | if (c == -1 || c == EOF) | 453 | if (c == -1 || c == EOF) |
420 | break; | 454 | break; |
@@ -455,13 +489,33 @@ process_arguments (int argc, char **argv) | |||
455 | case 'a': /* expected address */ | 489 | case 'a': /* expected address */ |
456 | if (strlen (optarg) >= ADDRESS_LENGTH) | 490 | if (strlen (optarg) >= ADDRESS_LENGTH) |
457 | die (STATE_UNKNOWN, _("Input buffer overflow\n")); | 491 | die (STATE_UNKNOWN, _("Input buffer overflow\n")); |
458 | expected_address = (char **)realloc(expected_address, (expected_address_cnt+1) * sizeof(char**)); | 492 | if (strchr(optarg, ',') != NULL) { |
459 | expected_address[expected_address_cnt] = strdup(optarg); | 493 | char *comma = strchr(optarg, ','); |
460 | expected_address_cnt++; | 494 | while (comma != NULL) { |
495 | expected_address = (char **)realloc(expected_address, (expected_address_cnt+1) * sizeof(char**)); | ||
496 | expected_address[expected_address_cnt] = strndup(optarg, comma - optarg); | ||
497 | expected_address_cnt++; | ||
498 | optarg = comma + 1; | ||
499 | comma = strchr(optarg, ','); | ||
500 | } | ||
501 | expected_address = (char **)realloc(expected_address, (expected_address_cnt+1) * sizeof(char**)); | ||
502 | expected_address[expected_address_cnt] = strdup(optarg); | ||
503 | expected_address_cnt++; | ||
504 | } else { | ||
505 | expected_address = (char **)realloc(expected_address, (expected_address_cnt+1) * sizeof(char**)); | ||
506 | expected_address[expected_address_cnt] = strdup(optarg); | ||
507 | expected_address_cnt++; | ||
508 | } | ||
509 | break; | ||
510 | case 'n': /* expect NXDOMAIN */ | ||
511 | expect_nxdomain = TRUE; | ||
461 | break; | 512 | break; |
462 | case 'A': /* expect authority */ | 513 | case 'A': /* expect authority */ |
463 | expect_authority = TRUE; | 514 | expect_authority = TRUE; |
464 | break; | 515 | break; |
516 | case 'L': /* all must match */ | ||
517 | all_match = TRUE; | ||
518 | break; | ||
465 | case 'w': | 519 | case 'w': |
466 | warning = optarg; | 520 | warning = optarg; |
467 | break; | 521 | break; |
@@ -497,8 +551,15 @@ process_arguments (int argc, char **argv) | |||
497 | int | 551 | int |
498 | validate_arguments () | 552 | validate_arguments () |
499 | { | 553 | { |
500 | if (query_address[0] == 0) | 554 | if (query_address[0] == 0) { |
555 | printf ("missing --host argument\n"); | ||
501 | return ERROR; | 556 | return ERROR; |
557 | } | ||
558 | |||
559 | if (expected_address_cnt > 0 && expect_nxdomain) { | ||
560 | printf ("--expected-address and --expect-nxdomain cannot be combined\n"); | ||
561 | return ERROR; | ||
562 | } | ||
502 | 563 | ||
503 | return OK; | 564 | return OK; |
504 | } | 565 | } |
@@ -530,14 +591,19 @@ print_help (void) | |||
530 | printf (" -a, --expected-address=IP-ADDRESS|CIDR|HOST\n"); | 591 | printf (" -a, --expected-address=IP-ADDRESS|CIDR|HOST\n"); |
531 | printf (" %s\n", _("Optional IP-ADDRESS/CIDR you expect the DNS server to return. HOST must end")); | 592 | printf (" %s\n", _("Optional IP-ADDRESS/CIDR you expect the DNS server to return. HOST must end")); |
532 | printf (" %s\n", _("with a dot (.). This option can be repeated multiple times (Returns OK if any")); | 593 | printf (" %s\n", _("with a dot (.). This option can be repeated multiple times (Returns OK if any")); |
533 | printf (" %s\n", _("value match). If multiple addresses are returned at once, you have to match")); | 594 | printf (" %s\n", _("value matches).")); |
534 | printf (" %s\n", _("the whole string of addresses separated with commas (sorted alphabetically).")); | 595 | printf (" -n, --expect-nxdomain\n"); |
596 | printf (" %s\n", _("Expect the DNS server to return NXDOMAIN (i.e. the domain was not found)")); | ||
597 | printf (" %s\n", _("Cannot be used together with -a")); | ||
535 | printf (" -A, --expect-authority\n"); | 598 | printf (" -A, --expect-authority\n"); |
536 | printf (" %s\n", _("Optionally expect the DNS server to be authoritative for the lookup")); | 599 | printf (" %s\n", _("Optionally expect the DNS server to be authoritative for the lookup")); |
537 | printf (" -w, --warning=seconds\n"); | 600 | printf (" -w, --warning=seconds\n"); |
538 | printf (" %s\n", _("Return warning if elapsed time exceeds value. Default off")); | 601 | printf (" %s\n", _("Return warning if elapsed time exceeds value. Default off")); |
539 | printf (" -c, --critical=seconds\n"); | 602 | printf (" -c, --critical=seconds\n"); |
540 | printf (" %s\n", _("Return critical if elapsed time exceeds value. Default off")); | 603 | printf (" %s\n", _("Return critical if elapsed time exceeds value. Default off")); |
604 | printf (" -L, --all\n"); | ||
605 | printf (" %s\n", _("Return critical if the list of expected addresses does not match all addresses")); | ||
606 | printf (" %s\n", _("returned. Default off")); | ||
541 | 607 | ||
542 | printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT); | 608 | printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT); |
543 | 609 | ||
@@ -549,5 +615,5 @@ void | |||
549 | print_usage (void) | 615 | print_usage (void) |
550 | { | 616 | { |
551 | printf ("%s\n", _("Usage:")); | 617 | printf ("%s\n", _("Usage:")); |
552 | printf ("%s -H host [-s server] [-a expected-address] [-A] [-t timeout] [-w warn] [-c crit]\n", progname); | 618 | printf ("%s -H host [-s server] [-a expected-address] [-n] [-A] [-t timeout] [-w warn] [-c crit] [-L]\n", progname); |
553 | } | 619 | } |
diff --git a/plugins/check_hpjd.c b/plugins/check_hpjd.c index f159f5a2..c4b44178 100644 --- a/plugins/check_hpjd.c +++ b/plugins/check_hpjd.c | |||
@@ -66,7 +66,8 @@ void print_usage (void); | |||
66 | 66 | ||
67 | char *community = NULL; | 67 | char *community = NULL; |
68 | char *address = NULL; | 68 | char *address = NULL; |
69 | char *port = NULL; | 69 | unsigned int port = 0; |
70 | int check_paper_out = 1; | ||
70 | 71 | ||
71 | int | 72 | int |
72 | main (int argc, char **argv) | 73 | main (int argc, char **argv) |
@@ -120,8 +121,12 @@ main (int argc, char **argv) | |||
120 | HPJD_GD_DOOR_OPEN, HPJD_GD_PAPER_OUTPUT, HPJD_GD_STATUS_DISPLAY); | 121 | HPJD_GD_DOOR_OPEN, HPJD_GD_PAPER_OUTPUT, HPJD_GD_STATUS_DISPLAY); |
121 | 122 | ||
122 | /* get the command to run */ | 123 | /* get the command to run */ |
123 | sprintf (command_line, "%s -OQa -m : -v 1 -c %s %s:%hd %s", PATH_TO_SNMPGET, community, | 124 | sprintf (command_line, "%s -OQa -m : -v 1 -c %s %s:%u %s", |
124 | address, port, query_string); | 125 | PATH_TO_SNMPGET, |
126 | community, | ||
127 | address, | ||
128 | port, | ||
129 | query_string); | ||
125 | 130 | ||
126 | /* run the command */ | 131 | /* run the command */ |
127 | child_process = spopen (command_line); | 132 | child_process = spopen (command_line); |
@@ -240,7 +245,8 @@ main (int argc, char **argv) | |||
240 | strcpy (errmsg, _("Paper Jam")); | 245 | strcpy (errmsg, _("Paper Jam")); |
241 | } | 246 | } |
242 | else if (paper_out) { | 247 | else if (paper_out) { |
243 | result = STATE_WARNING; | 248 | if (check_paper_out) |
249 | result = STATE_WARNING; | ||
244 | strcpy (errmsg, _("Out of Paper")); | 250 | strcpy (errmsg, _("Out of Paper")); |
245 | } | 251 | } |
246 | else if (line_status == OFFLINE) { | 252 | else if (line_status == OFFLINE) { |
@@ -325,7 +331,7 @@ process_arguments (int argc, char **argv) | |||
325 | 331 | ||
326 | 332 | ||
327 | while (1) { | 333 | while (1) { |
328 | c = getopt_long (argc, argv, "+hVH:C:p:", longopts, &option); | 334 | c = getopt_long (argc, argv, "+hVH:C:p:D", longopts, &option); |
329 | 335 | ||
330 | if (c == -1 || c == EOF || c == 1) | 336 | if (c == -1 || c == EOF || c == 1) |
331 | break; | 337 | break; |
@@ -347,6 +353,8 @@ process_arguments (int argc, char **argv) | |||
347 | usage2 (_("Port must be a positive short integer"), optarg); | 353 | usage2 (_("Port must be a positive short integer"), optarg); |
348 | else | 354 | else |
349 | port = atoi(optarg); | 355 | port = atoi(optarg); |
356 | case 'D': /* disable paper out check*/ | ||
357 | check_paper_out = 0; | ||
350 | break; | 358 | break; |
351 | case 'V': /* version */ | 359 | case 'V': /* version */ |
352 | print_revision (progname, NP_VERSION); | 360 | print_revision (progname, NP_VERSION); |
@@ -376,11 +384,8 @@ process_arguments (int argc, char **argv) | |||
376 | community = strdup (DEFAULT_COMMUNITY); | 384 | community = strdup (DEFAULT_COMMUNITY); |
377 | } | 385 | } |
378 | 386 | ||
379 | if (port == NULL) { | 387 | if (port == 0) { |
380 | if (argv[c] != NULL ) | 388 | port = atoi(DEFAULT_PORT); |
381 | port = argv[c]; | ||
382 | else | ||
383 | port = atoi (DEFAULT_PORT); | ||
384 | } | 389 | } |
385 | 390 | ||
386 | return validate_arguments (); | 391 | return validate_arguments (); |
@@ -420,6 +425,8 @@ print_help (void) | |||
420 | printf (" %s", _("Specify the port to check ")); | 425 | printf (" %s", _("Specify the port to check ")); |
421 | printf (_("(default=%s)"), DEFAULT_PORT); | 426 | printf (_("(default=%s)"), DEFAULT_PORT); |
422 | printf ("\n"); | 427 | printf ("\n"); |
428 | printf (" %s\n", "-D"); | ||
429 | printf (" %s", _("Disable paper check ")); | ||
423 | 430 | ||
424 | printf (UT_SUPPORT); | 431 | printf (UT_SUPPORT); |
425 | } | 432 | } |
@@ -430,5 +437,5 @@ void | |||
430 | print_usage (void) | 437 | print_usage (void) |
431 | { | 438 | { |
432 | printf ("%s\n", _("Usage:")); | 439 | printf ("%s\n", _("Usage:")); |
433 | printf ("%s -H host [-C community] [-p port]\n", progname); | 440 | printf ("%s -H host [-C community] [-p port] [-D]\n", progname); |
434 | } | 441 | } |
diff --git a/plugins/check_http.c b/plugins/check_http.c index 86a36c20..34fb4f01 100644 --- a/plugins/check_http.c +++ b/plugins/check_http.c | |||
@@ -72,7 +72,7 @@ int maximum_age = -1; | |||
72 | 72 | ||
73 | enum { | 73 | enum { |
74 | REGS = 2, | 74 | REGS = 2, |
75 | MAX_RE_SIZE = 256 | 75 | MAX_RE_SIZE = 1024 |
76 | }; | 76 | }; |
77 | #include "regex.h" | 77 | #include "regex.h" |
78 | regex_t preg; | 78 | regex_t preg; |
@@ -120,12 +120,14 @@ int use_ssl = FALSE; | |||
120 | int use_sni = FALSE; | 120 | int use_sni = FALSE; |
121 | int verbose = FALSE; | 121 | int verbose = FALSE; |
122 | int show_extended_perfdata = FALSE; | 122 | int show_extended_perfdata = FALSE; |
123 | int show_body = FALSE; | ||
123 | int sd; | 124 | int sd; |
124 | int min_page_len = 0; | 125 | int min_page_len = 0; |
125 | int max_page_len = 0; | 126 | int max_page_len = 0; |
126 | int redir_depth = 0; | 127 | int redir_depth = 0; |
127 | int max_depth = 15; | 128 | int max_depth = 15; |
128 | char *http_method; | 129 | char *http_method; |
130 | char *http_method_proxy; | ||
129 | char *http_post_data; | 131 | char *http_post_data; |
130 | char *http_content_type; | 132 | char *http_content_type; |
131 | char buffer[MAX_INPUT_BUFFER]; | 133 | char buffer[MAX_INPUT_BUFFER]; |
@@ -239,6 +241,7 @@ process_arguments (int argc, char **argv) | |||
239 | {"use-ipv4", no_argument, 0, '4'}, | 241 | {"use-ipv4", no_argument, 0, '4'}, |
240 | {"use-ipv6", no_argument, 0, '6'}, | 242 | {"use-ipv6", no_argument, 0, '6'}, |
241 | {"extended-perfdata", no_argument, 0, 'E'}, | 243 | {"extended-perfdata", no_argument, 0, 'E'}, |
244 | {"show-body", no_argument, 0, 'B'}, | ||
242 | {0, 0, 0, 0} | 245 | {0, 0, 0, 0} |
243 | }; | 246 | }; |
244 | 247 | ||
@@ -259,7 +262,7 @@ process_arguments (int argc, char **argv) | |||
259 | } | 262 | } |
260 | 263 | ||
261 | while (1) { | 264 | while (1) { |
262 | c = getopt_long (argc, argv, "Vvh46t:c:w:A:k:H:P:j:T:I:a:b:d:e:p:s:R:r:u:f:C:J:K:nlLS::m:M:NE", longopts, &option); | 265 | c = getopt_long (argc, argv, "Vvh46t:c:w:A:k:H:P:j:T:I:a:b:d:e:p:s:R:r:u:f:C:J:K:nlLS::m:M:NEB", longopts, &option); |
263 | if (c == -1 || c == EOF) | 266 | if (c == -1 || c == EOF) |
264 | break; | 267 | break; |
265 | 268 | ||
@@ -446,6 +449,12 @@ process_arguments (int argc, char **argv) | |||
446 | if (http_method) | 449 | if (http_method) |
447 | free(http_method); | 450 | free(http_method); |
448 | http_method = strdup (optarg); | 451 | http_method = strdup (optarg); |
452 | char *tmp; | ||
453 | if ((tmp = strstr(http_method, ":")) > 0) { | ||
454 | tmp[0] = '\0'; | ||
455 | http_method = http_method; | ||
456 | http_method_proxy = ++tmp; | ||
457 | } | ||
449 | break; | 458 | break; |
450 | case 'd': /* string or substring */ | 459 | case 'd': /* string or substring */ |
451 | strncpy (header_expect, optarg, MAX_INPUT_BUFFER - 1); | 460 | strncpy (header_expect, optarg, MAX_INPUT_BUFFER - 1); |
@@ -540,6 +549,9 @@ process_arguments (int argc, char **argv) | |||
540 | case 'E': /* show extended perfdata */ | 549 | case 'E': /* show extended perfdata */ |
541 | show_extended_perfdata = TRUE; | 550 | show_extended_perfdata = TRUE; |
542 | break; | 551 | break; |
552 | case 'B': /* print body content after status line */ | ||
553 | show_body = TRUE; | ||
554 | break; | ||
543 | } | 555 | } |
544 | } | 556 | } |
545 | 557 | ||
@@ -566,6 +578,9 @@ process_arguments (int argc, char **argv) | |||
566 | if (http_method == NULL) | 578 | if (http_method == NULL) |
567 | http_method = strdup ("GET"); | 579 | http_method = strdup ("GET"); |
568 | 580 | ||
581 | if (http_method_proxy == NULL) | ||
582 | http_method_proxy = strdup ("GET"); | ||
583 | |||
569 | if (client_cert && !client_privkey) | 584 | if (client_cert && !client_privkey) |
570 | usage4 (_("If you use a client certificate you must also specify a private key file")); | 585 | usage4 (_("If you use a client certificate you must also specify a private key file")); |
571 | 586 | ||
@@ -916,6 +931,21 @@ check_http (void) | |||
916 | 931 | ||
917 | if (verbose) printf ("Entering CONNECT tunnel mode with proxy %s:%d to dst %s:%d\n", server_address, server_port, host_name, HTTPS_PORT); | 932 | if (verbose) printf ("Entering CONNECT tunnel mode with proxy %s:%d to dst %s:%d\n", server_address, server_port, host_name, HTTPS_PORT); |
918 | asprintf (&buf, "%s %s:%d HTTP/1.1\r\n%s\r\n", http_method, host_name, HTTPS_PORT, user_agent); | 933 | asprintf (&buf, "%s %s:%d HTTP/1.1\r\n%s\r\n", http_method, host_name, HTTPS_PORT, user_agent); |
934 | if (strlen(proxy_auth)) { | ||
935 | base64_encode_alloc (proxy_auth, strlen (proxy_auth), &auth); | ||
936 | xasprintf (&buf, "%sProxy-Authorization: Basic %s\r\n", buf, auth); | ||
937 | } | ||
938 | /* optionally send any other header tag */ | ||
939 | if (http_opt_headers_count) { | ||
940 | for (i = 0; i < http_opt_headers_count ; i++) { | ||
941 | if (force_host_header != http_opt_headers[i]) { | ||
942 | xasprintf (&buf, "%s%s\r\n", buf, http_opt_headers[i]); | ||
943 | } | ||
944 | } | ||
945 | /* This cannot be free'd here because a redirection will then try to access this and segfault */ | ||
946 | /* Covered in a testcase in tests/check_http.t */ | ||
947 | /* free(http_opt_headers); */ | ||
948 | } | ||
919 | asprintf (&buf, "%sProxy-Connection: keep-alive\r\n", buf); | 949 | asprintf (&buf, "%sProxy-Connection: keep-alive\r\n", buf); |
920 | asprintf (&buf, "%sHost: %s\r\n", buf, host_name); | 950 | asprintf (&buf, "%sHost: %s\r\n", buf, host_name); |
921 | /* we finished our request, send empty line with CRLF */ | 951 | /* we finished our request, send empty line with CRLF */ |
@@ -950,7 +980,7 @@ check_http (void) | |||
950 | 980 | ||
951 | if ( server_address != NULL && strcmp(http_method, "CONNECT") == 0 | 981 | if ( server_address != NULL && strcmp(http_method, "CONNECT") == 0 |
952 | && host_name != NULL && use_ssl == TRUE) | 982 | && host_name != NULL && use_ssl == TRUE) |
953 | asprintf (&buf, "%s %s %s\r\n%s\r\n", "GET", server_url, host_name ? "HTTP/1.1" : "HTTP/1.0", user_agent); | 983 | asprintf (&buf, "%s %s %s\r\n%s\r\n", http_method_proxy, server_url, host_name ? "HTTP/1.1" : "HTTP/1.0", user_agent); |
954 | else | 984 | else |
955 | asprintf (&buf, "%s %s %s\r\n%s\r\n", http_method, server_url, host_name ? "HTTP/1.1" : "HTTP/1.0", user_agent); | 985 | asprintf (&buf, "%s %s %s\r\n%s\r\n", http_method, server_url, host_name ? "HTTP/1.1" : "HTTP/1.0", user_agent); |
956 | 986 | ||
@@ -1140,6 +1170,8 @@ check_http (void) | |||
1140 | xasprintf (&msg, | 1170 | xasprintf (&msg, |
1141 | _("Invalid HTTP response received from host on port %d: %s\n"), | 1171 | _("Invalid HTTP response received from host on port %d: %s\n"), |
1142 | server_port, status_line); | 1172 | server_port, status_line); |
1173 | if (show_body) | ||
1174 | xasprintf (&msg, _("%s\n%s"), msg, page); | ||
1143 | die (STATE_CRITICAL, "HTTP CRITICAL - %s", msg); | 1175 | die (STATE_CRITICAL, "HTTP CRITICAL - %s", msg); |
1144 | } | 1176 | } |
1145 | 1177 | ||
@@ -1290,6 +1322,9 @@ check_http (void) | |||
1290 | perfd_time (elapsed_time), | 1322 | perfd_time (elapsed_time), |
1291 | perfd_size (page_len)); | 1323 | perfd_size (page_len)); |
1292 | 1324 | ||
1325 | if (show_body) | ||
1326 | xasprintf (&msg, _("%s\n%s"), msg, page); | ||
1327 | |||
1293 | result = max_state_alt(get_status(elapsed_time, thlds), result); | 1328 | result = max_state_alt(get_status(elapsed_time, thlds), result); |
1294 | 1329 | ||
1295 | die (result, "HTTP %s: %s\n", state_text(result), msg); | 1330 | die (result, "HTTP %s: %s\n", state_text(result), msg); |
@@ -1418,8 +1453,8 @@ redir (char *pos, char *status_line) | |||
1418 | !strncmp(server_address, addr, MAX_IPV4_HOSTLENGTH) && | 1453 | !strncmp(server_address, addr, MAX_IPV4_HOSTLENGTH) && |
1419 | (host_name && !strncmp(host_name, addr, MAX_IPV4_HOSTLENGTH)) && | 1454 | (host_name && !strncmp(host_name, addr, MAX_IPV4_HOSTLENGTH)) && |
1420 | !strcmp(server_url, url)) | 1455 | !strcmp(server_url, url)) |
1421 | die (STATE_WARNING, | 1456 | die (STATE_CRITICAL, |
1422 | _("HTTP WARNING - redirection creates an infinite loop - %s://%s:%d%s%s\n"), | 1457 | _("HTTP CRITICAL - redirection creates an infinite loop - %s://%s:%d%s%s\n"), |
1423 | type, addr, i, url, (display_html ? "</A>" : "")); | 1458 | type, addr, i, url, (display_html ? "</A>" : "")); |
1424 | 1459 | ||
1425 | strcpy (server_type, type); | 1460 | strcpy (server_type, type); |
@@ -1532,6 +1567,10 @@ print_help (void) | |||
1532 | 1567 | ||
1533 | print_usage (); | 1568 | print_usage (); |
1534 | 1569 | ||
1570 | #ifdef HAVE_SSL | ||
1571 | printf (_("In the first form, make an HTTP request.")); | ||
1572 | printf (_("In the second form, connect to the server and check the TLS certificate.")); | ||
1573 | #endif | ||
1535 | printf (_("NOTE: One or both of -H and -I must be specified")); | 1574 | printf (_("NOTE: One or both of -H and -I must be specified")); |
1536 | 1575 | ||
1537 | printf ("\n"); | 1576 | printf ("\n"); |
@@ -1581,7 +1620,7 @@ print_help (void) | |||
1581 | printf (" %s\n", _("URL to GET or POST (default: /)")); | 1620 | printf (" %s\n", _("URL to GET or POST (default: /)")); |
1582 | printf (" %s\n", "-P, --post=STRING"); | 1621 | printf (" %s\n", "-P, --post=STRING"); |
1583 | printf (" %s\n", _("URL encoded http POST data")); | 1622 | printf (" %s\n", _("URL encoded http POST data")); |
1584 | printf (" %s\n", "-j, --method=STRING (for example: HEAD, OPTIONS, TRACE, PUT, DELETE, CONNECT)"); | 1623 | printf (" %s\n", "-j, --method=STRING (for example: HEAD, OPTIONS, TRACE, PUT, DELETE, CONNECT, CONNECT:POST)"); |
1585 | printf (" %s\n", _("Set HTTP method.")); | 1624 | printf (" %s\n", _("Set HTTP method.")); |
1586 | printf (" %s\n", "-N, --no-body"); | 1625 | printf (" %s\n", "-N, --no-body"); |
1587 | printf (" %s\n", _("Don't wait for document body: stop reading after headers.")); | 1626 | printf (" %s\n", _("Don't wait for document body: stop reading after headers.")); |
@@ -1611,6 +1650,8 @@ print_help (void) | |||
1611 | printf (" %s\n", _("Any other tags to be sent in http header. Use multiple times for additional headers")); | 1650 | printf (" %s\n", _("Any other tags to be sent in http header. Use multiple times for additional headers")); |
1612 | printf (" %s\n", "-E, --extended-perfdata"); | 1651 | printf (" %s\n", "-E, --extended-perfdata"); |
1613 | printf (" %s\n", _("Print additional performance data")); | 1652 | printf (" %s\n", _("Print additional performance data")); |
1653 | printf (" %s\n", "-B, --show-body"); | ||
1654 | printf (" %s\n", _("Print body content below status line")); | ||
1614 | printf (" %s\n", "-L, --link"); | 1655 | printf (" %s\n", "-L, --link"); |
1615 | printf (" %s\n", _("Wrap output in HTML link (obsoleted by urlize)")); | 1656 | printf (" %s\n", _("Wrap output in HTML link (obsoleted by urlize)")); |
1616 | printf (" %s\n", "-f, --onredirect=<ok|warning|critical|follow|sticky|stickyport>"); | 1657 | printf (" %s\n", "-f, --onredirect=<ok|warning|critical|follow|sticky|stickyport>"); |
@@ -1668,7 +1709,8 @@ print_help (void) | |||
1668 | printf (" %s\n", _("all these options are needed: -I <proxy> -p <proxy-port> -u <check-url> -S(sl) -j CONNECT -H <webserver>")); | 1709 | printf (" %s\n", _("all these options are needed: -I <proxy> -p <proxy-port> -u <check-url> -S(sl) -j CONNECT -H <webserver>")); |
1669 | printf (" %s\n", _("a STATE_OK will be returned. When the server returns its content but exceeds")); | 1710 | printf (" %s\n", _("a STATE_OK will be returned. When the server returns its content but exceeds")); |
1670 | printf (" %s\n", _("the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,")); | 1711 | printf (" %s\n", _("the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,")); |
1671 | printf (" %s\n", _("a STATE_CRITICAL will be returned.")); | 1712 | printf (" %s\n", _("a STATE_CRITICAL will be returned. By adding a colon to the method you can set the method used")); |
1713 | printf (" %s\n", _("inside the proxied connection: -j CONNECT:POST")); | ||
1672 | 1714 | ||
1673 | #endif | 1715 | #endif |
1674 | 1716 | ||
@@ -1688,6 +1730,8 @@ print_usage (void) | |||
1688 | printf (" [-b proxy_auth] [-f <ok|warning|critcal|follow|sticky|stickyport>]\n"); | 1730 | printf (" [-b proxy_auth] [-f <ok|warning|critcal|follow|sticky|stickyport>]\n"); |
1689 | printf (" [-e <expect>] [-d string] [-s string] [-l] [-r <regex> | -R <case-insensitive regex>]\n"); | 1731 | printf (" [-e <expect>] [-d string] [-s string] [-l] [-r <regex> | -R <case-insensitive regex>]\n"); |
1690 | printf (" [-P string] [-m <min_pg_size>:<max_pg_size>] [-4|-6] [-N] [-M <age>]\n"); | 1732 | printf (" [-P string] [-m <min_pg_size>:<max_pg_size>] [-4|-6] [-N] [-M <age>]\n"); |
1691 | printf (" [-A string] [-k string] [-S <version>] [--sni] [-C <warn_age>[,<crit_age>]]\n"); | 1733 | printf (" [-A string] [-k string] [-S <version>] [--sni]\n"); |
1692 | printf (" [-T <content-type>] [-j method]\n"); | 1734 | printf (" [-T <content-type>] [-j method]\n"); |
1735 | printf (" %s -H <vhost> | -I <IP-address> -C <warn_age>[,<crit_age>]\n",progname); | ||
1736 | printf (" [-p <port>] [-t <timeout>] [-4|-6] [--sni]\n"); | ||
1693 | } | 1737 | } |
diff --git a/plugins/check_ldap.c b/plugins/check_ldap.c index bc7bd44c..845a4f52 100644 --- a/plugins/check_ldap.c +++ b/plugins/check_ldap.c | |||
@@ -432,6 +432,9 @@ validate_arguments () | |||
432 | set_thresholds(&entries_thresholds, | 432 | set_thresholds(&entries_thresholds, |
433 | warn_entries, crit_entries); | 433 | warn_entries, crit_entries); |
434 | } | 434 | } |
435 | if (ld_passwd==NULL) | ||
436 | ld_passwd = getenv("LDAP_PASSWORD"); | ||
437 | |||
435 | return OK; | 438 | return OK; |
436 | } | 439 | } |
437 | 440 | ||
@@ -465,7 +468,7 @@ print_help (void) | |||
465 | printf (" %s\n", "-D [--bind]"); | 468 | printf (" %s\n", "-D [--bind]"); |
466 | printf (" %s\n", _("ldap bind DN (if required)")); | 469 | printf (" %s\n", _("ldap bind DN (if required)")); |
467 | printf (" %s\n", "-P [--pass]"); | 470 | printf (" %s\n", "-P [--pass]"); |
468 | printf (" %s\n", _("ldap password (if required)")); | 471 | printf (" %s\n", _("ldap password (if required, or set the password through environment variable 'LDAP_PASSWORD')")); |
469 | printf (" %s\n", "-T [--starttls]"); | 472 | printf (" %s\n", "-T [--starttls]"); |
470 | printf (" %s\n", _("use starttls mechanism introduced in protocol version 3")); | 473 | printf (" %s\n", _("use starttls mechanism introduced in protocol version 3")); |
471 | printf (" %s\n", "-S [--ssl]"); | 474 | printf (" %s\n", "-S [--ssl]"); |
diff --git a/plugins/check_load.c b/plugins/check_load.c index b1cc498f..0e4de54e 100644 --- a/plugins/check_load.c +++ b/plugins/check_load.c | |||
@@ -33,6 +33,7 @@ const char *copyright = "1999-2007"; | |||
33 | const char *email = "devel@monitoring-plugins.org"; | 33 | const char *email = "devel@monitoring-plugins.org"; |
34 | 34 | ||
35 | #include "common.h" | 35 | #include "common.h" |
36 | #include "runcmd.h" | ||
36 | #include "utils.h" | 37 | #include "utils.h" |
37 | #include "popen.h" | 38 | #include "popen.h" |
38 | 39 | ||
@@ -52,6 +53,9 @@ static int process_arguments (int argc, char **argv); | |||
52 | static int validate_arguments (void); | 53 | static int validate_arguments (void); |
53 | void print_help (void); | 54 | void print_help (void); |
54 | void print_usage (void); | 55 | void print_usage (void); |
56 | static int print_top_consuming_processes(); | ||
57 | |||
58 | static int n_procs_to_show = 0; | ||
55 | 59 | ||
56 | /* strictly for pretty-print usage in loops */ | 60 | /* strictly for pretty-print usage in loops */ |
57 | static const int nums[3] = { 1, 5, 15 }; | 61 | static const int nums[3] = { 1, 5, 15 }; |
@@ -205,11 +209,14 @@ main (int argc, char **argv) | |||
205 | else if(la[i] > wload[i]) result = STATE_WARNING; | 209 | else if(la[i] > wload[i]) result = STATE_WARNING; |
206 | } | 210 | } |
207 | 211 | ||
208 | printf("%s - %s|", state_text(result), status_line); | 212 | printf("LOAD %s - %s|", state_text(result), status_line); |
209 | for(i = 0; i < 3; i++) | 213 | for(i = 0; i < 3; i++) |
210 | printf("load%d=%.3f;%.3f;%.3f;0; ", nums[i], la[i], wload[i], cload[i]); | 214 | printf("load%d=%.3f;%.3f;%.3f;0; ", nums[i], la[i], wload[i], cload[i]); |
211 | 215 | ||
212 | putchar('\n'); | 216 | putchar('\n'); |
217 | if (n_procs_to_show > 0) { | ||
218 | print_top_consuming_processes(); | ||
219 | } | ||
213 | return result; | 220 | return result; |
214 | } | 221 | } |
215 | 222 | ||
@@ -227,6 +234,7 @@ process_arguments (int argc, char **argv) | |||
227 | {"percpu", no_argument, 0, 'r'}, | 234 | {"percpu", no_argument, 0, 'r'}, |
228 | {"version", no_argument, 0, 'V'}, | 235 | {"version", no_argument, 0, 'V'}, |
229 | {"help", no_argument, 0, 'h'}, | 236 | {"help", no_argument, 0, 'h'}, |
237 | {"procs-to-show", required_argument, 0, 'n'}, | ||
230 | {0, 0, 0, 0} | 238 | {0, 0, 0, 0} |
231 | }; | 239 | }; |
232 | 240 | ||
@@ -234,7 +242,7 @@ process_arguments (int argc, char **argv) | |||
234 | return ERROR; | 242 | return ERROR; |
235 | 243 | ||
236 | while (1) { | 244 | while (1) { |
237 | c = getopt_long (argc, argv, "Vhrc:w:", longopts, &option); | 245 | c = getopt_long (argc, argv, "Vhrc:w:n:", longopts, &option); |
238 | 246 | ||
239 | if (c == -1 || c == EOF) | 247 | if (c == -1 || c == EOF) |
240 | break; | 248 | break; |
@@ -255,6 +263,9 @@ process_arguments (int argc, char **argv) | |||
255 | case 'h': /* help */ | 263 | case 'h': /* help */ |
256 | print_help (); | 264 | print_help (); |
257 | exit (STATE_UNKNOWN); | 265 | exit (STATE_UNKNOWN); |
266 | case 'n': | ||
267 | n_procs_to_show = atoi(optarg); | ||
268 | break; | ||
258 | case '?': /* help */ | 269 | case '?': /* help */ |
259 | usage5 (); | 270 | usage5 (); |
260 | } | 271 | } |
@@ -324,6 +335,9 @@ print_help (void) | |||
324 | printf (" %s\n", _("the load average format is the same used by \"uptime\" and \"w\"")); | 335 | printf (" %s\n", _("the load average format is the same used by \"uptime\" and \"w\"")); |
325 | printf (" %s\n", "-r, --percpu"); | 336 | printf (" %s\n", "-r, --percpu"); |
326 | printf (" %s\n", _("Divide the load averages by the number of CPUs (when possible)")); | 337 | printf (" %s\n", _("Divide the load averages by the number of CPUs (when possible)")); |
338 | printf (" %s\n", "-n, --procs-to-show=NUMBER_OF_PROCS"); | ||
339 | printf (" %s\n", _("Number of processes to show when printing the top consuming processes.")); | ||
340 | printf (" %s\n", _("NUMBER_OF_PROCS=0 disables this feature. Default value is 0")); | ||
327 | 341 | ||
328 | printf (UT_SUPPORT); | 342 | printf (UT_SUPPORT); |
329 | } | 343 | } |
@@ -332,5 +346,48 @@ void | |||
332 | print_usage (void) | 346 | print_usage (void) |
333 | { | 347 | { |
334 | printf ("%s\n", _("Usage:")); | 348 | printf ("%s\n", _("Usage:")); |
335 | printf ("%s [-r] -w WLOAD1,WLOAD5,WLOAD15 -c CLOAD1,CLOAD5,CLOAD15\n", progname); | 349 | printf ("%s [-r] -w WLOAD1,WLOAD5,WLOAD15 -c CLOAD1,CLOAD5,CLOAD15 [-n NUMBER_OF_PROCS]\n", progname); |
350 | } | ||
351 | |||
352 | #ifdef PS_USES_PROCPCPU | ||
353 | int cmpstringp(const void *p1, const void *p2) { | ||
354 | int procuid = 0; | ||
355 | int procpid = 0; | ||
356 | int procppid = 0; | ||
357 | int procvsz = 0; | ||
358 | int procrss = 0; | ||
359 | float procpcpu = 0; | ||
360 | char procstat[8]; | ||
361 | #ifdef PS_USES_PROCETIME | ||
362 | char procetime[MAX_INPUT_BUFFER]; | ||
363 | #endif /* PS_USES_PROCETIME */ | ||
364 | char procprog[MAX_INPUT_BUFFER]; | ||
365 | int pos; | ||
366 | sscanf (* (char * const *) p1, PS_FORMAT, PS_VARLIST); | ||
367 | float procpcpu1 = procpcpu; | ||
368 | sscanf (* (char * const *) p2, PS_FORMAT, PS_VARLIST); | ||
369 | return procpcpu1 < procpcpu; | ||
370 | } | ||
371 | #endif /* PS_USES_PROCPCPU */ | ||
372 | |||
373 | static int print_top_consuming_processes() { | ||
374 | int i = 0; | ||
375 | struct output chld_out, chld_err; | ||
376 | if(np_runcmd(PS_COMMAND, &chld_out, &chld_err, 0) != 0){ | ||
377 | fprintf(stderr, _("'%s' exited with non-zero status.\n"), PS_COMMAND); | ||
378 | return STATE_UNKNOWN; | ||
379 | } | ||
380 | if (chld_out.lines < 2) { | ||
381 | fprintf(stderr, _("some error occurred getting procs list.\n")); | ||
382 | return STATE_UNKNOWN; | ||
383 | } | ||
384 | #ifdef PS_USES_PROCPCPU | ||
385 | qsort(chld_out.line + 1, chld_out.lines - 1, sizeof(char*), cmpstringp); | ||
386 | #endif /* PS_USES_PROCPCPU */ | ||
387 | int lines_to_show = chld_out.lines < (n_procs_to_show + 1) | ||
388 | ? chld_out.lines : n_procs_to_show + 1; | ||
389 | for (i = 0; i < lines_to_show; i += 1) { | ||
390 | printf("%s\n", chld_out.line[i]); | ||
391 | } | ||
392 | return OK; | ||
336 | } | 393 | } |
diff --git a/plugins/check_mysql.c b/plugins/check_mysql.c index 5773afd9..0cba50e6 100644 --- a/plugins/check_mysql.c +++ b/plugins/check_mysql.c | |||
@@ -379,6 +379,9 @@ process_arguments (int argc, char **argv) | |||
379 | if (is_host (optarg)) { | 379 | if (is_host (optarg)) { |
380 | db_host = optarg; | 380 | db_host = optarg; |
381 | } | 381 | } |
382 | else if (*optarg == '/') { | ||
383 | db_socket = optarg; | ||
384 | } | ||
382 | else { | 385 | else { |
383 | usage2 (_("Invalid hostname/address"), optarg); | 386 | usage2 (_("Invalid hostname/address"), optarg); |
384 | } | 387 | } |
diff --git a/plugins/check_mysql_query.c b/plugins/check_mysql_query.c index 49a14dd3..ac2fb15d 100644 --- a/plugins/check_mysql_query.c +++ b/plugins/check_mysql_query.c | |||
@@ -136,18 +136,18 @@ main (int argc, char **argv) | |||
136 | die (STATE_CRITICAL, "QUERY %s: Fetch row error - %s\n", _("CRITICAL"), error); | 136 | die (STATE_CRITICAL, "QUERY %s: Fetch row error - %s\n", _("CRITICAL"), error); |
137 | } | 137 | } |
138 | 138 | ||
139 | /* free the result */ | ||
140 | mysql_free_result (res); | ||
141 | |||
142 | /* close the connection */ | ||
143 | mysql_close (&mysql); | ||
144 | |||
145 | if (! is_numeric(row[0])) { | 139 | if (! is_numeric(row[0])) { |
146 | die (STATE_CRITICAL, "QUERY %s: %s - '%s'\n", _("CRITICAL"), _("Is not a numeric"), row[0]); | 140 | die (STATE_CRITICAL, "QUERY %s: %s - '%s'\n", _("CRITICAL"), _("Is not a numeric"), row[0]); |
147 | } | 141 | } |
148 | 142 | ||
149 | value = strtod(row[0], NULL); | 143 | value = strtod(row[0], NULL); |
150 | 144 | ||
145 | /* free the result */ | ||
146 | mysql_free_result (res); | ||
147 | |||
148 | /* close the connection */ | ||
149 | mysql_close (&mysql); | ||
150 | |||
151 | if (verbose >= 3) | 151 | if (verbose >= 3) |
152 | printf("mysql result: %f\n", value); | 152 | printf("mysql result: %f\n", value); |
153 | 153 | ||
diff --git a/plugins/check_pgsql.c b/plugins/check_pgsql.c index 5cd47093..b8fc5f1d 100644 --- a/plugins/check_pgsql.c +++ b/plugins/check_pgsql.c | |||
@@ -34,6 +34,7 @@ const char *email = "devel@monitoring-plugins.org"; | |||
34 | 34 | ||
35 | #include "common.h" | 35 | #include "common.h" |
36 | #include "utils.h" | 36 | #include "utils.h" |
37 | #include "utils_cmd.h" | ||
37 | 38 | ||
38 | #include "netutils.h" | 39 | #include "netutils.h" |
39 | #include <libpq-fe.h> | 40 | #include <libpq-fe.h> |
@@ -346,7 +347,7 @@ process_arguments (int argc, char **argv) | |||
346 | if (!is_pg_dbname (optarg)) /* checks length and valid chars */ | 347 | if (!is_pg_dbname (optarg)) /* checks length and valid chars */ |
347 | usage2 (_("Database name is not valid"), optarg); | 348 | usage2 (_("Database name is not valid"), optarg); |
348 | else /* we know length, and know optarg is terminated, so us strcpy */ | 349 | else /* we know length, and know optarg is terminated, so us strcpy */ |
349 | strcpy (dbName, optarg); | 350 | snprintf(dbName, NAMEDATALEN, "%s", optarg); |
350 | break; | 351 | break; |
351 | case 'l': /* login name */ | 352 | case 'l': /* login name */ |
352 | if (!is_pg_logname (optarg)) | 353 | if (!is_pg_logname (optarg)) |
diff --git a/plugins/check_ping.c b/plugins/check_ping.c index 423ecbe5..ba7af373 100644 --- a/plugins/check_ping.c +++ b/plugins/check_ping.c | |||
@@ -37,6 +37,8 @@ const char *email = "devel@monitoring-plugins.org"; | |||
37 | #include "popen.h" | 37 | #include "popen.h" |
38 | #include "utils.h" | 38 | #include "utils.h" |
39 | 39 | ||
40 | #include <signal.h> | ||
41 | |||
40 | #define WARN_DUPLICATES "DUPLICATES FOUND! " | 42 | #define WARN_DUPLICATES "DUPLICATES FOUND! " |
41 | #define UNKNOWN_TRIP_TIME -1.0 /* -1 seconds */ | 43 | #define UNKNOWN_TRIP_TIME -1.0 /* -1 seconds */ |
42 | 44 | ||
@@ -163,10 +165,14 @@ main (int argc, char **argv) | |||
163 | printf ("</A>"); | 165 | printf ("</A>"); |
164 | 166 | ||
165 | /* Print performance data */ | 167 | /* Print performance data */ |
166 | printf("|%s", fperfdata ("rta", (double) rta, "ms", | 168 | if (pl != 100) { |
167 | wrta>0?TRUE:FALSE, wrta, | 169 | printf("|%s", fperfdata ("rta", (double) rta, "ms", |
168 | crta>0?TRUE:FALSE, crta, | 170 | wrta>0?TRUE:FALSE, wrta, |
169 | TRUE, 0, FALSE, 0)); | 171 | crta>0?TRUE:FALSE, crta, |
172 | TRUE, 0, FALSE, 0)); | ||
173 | } else { | ||
174 | printf("| rta=U;%f;%f;;", wrta, crta); | ||
175 | } | ||
170 | printf(" %s\n", perfdata ("pl", (long) pl, "%", | 176 | printf(" %s\n", perfdata ("pl", (long) pl, "%", |
171 | wpl>0?TRUE:FALSE, wpl, | 177 | wpl>0?TRUE:FALSE, wpl, |
172 | cpl>0?TRUE:FALSE, cpl, | 178 | cpl>0?TRUE:FALSE, cpl, |
diff --git a/plugins/check_procs.c b/plugins/check_procs.c index 4bcc56bc..48723404 100644 --- a/plugins/check_procs.c +++ b/plugins/check_procs.c | |||
@@ -1,34 +1,34 @@ | |||
1 | /***************************************************************************** | 1 | /***************************************************************************** |
2 | * | 2 | * |
3 | * Monitoring check_procs plugin | 3 | * Monitoring check_procs plugin |
4 | * | 4 | * |
5 | * License: GPL | 5 | * License: GPL |
6 | * Copyright (c) 2000-2008 Monitoring Plugins Development Team | 6 | * Copyright (c) 2000-2008 Monitoring Plugins Development Team |
7 | * | 7 | * |
8 | * Description: | 8 | * Description: |
9 | * | 9 | * |
10 | * This file contains the check_procs plugin | 10 | * This file contains the check_procs plugin |
11 | * | 11 | * |
12 | * Checks all processes and generates WARNING or CRITICAL states if the | 12 | * Checks all processes and generates WARNING or CRITICAL states if the |
13 | * specified metric is outside the required threshold ranges. The metric | 13 | * specified metric is outside the required threshold ranges. The metric |
14 | * defaults to number of processes. Search filters can be applied to limit | 14 | * defaults to number of processes. Search filters can be applied to limit |
15 | * the processes to check. | 15 | * the processes to check. |
16 | * | 16 | * |
17 | * | 17 | * |
18 | * This program is free software: you can redistribute it and/or modify | 18 | * This program is free software: you can redistribute it and/or modify |
19 | * it under the terms of the GNU General Public License as published by | 19 | * it under the terms of the GNU General Public License as published by |
20 | * the Free Software Foundation, either version 3 of the License, or | 20 | * the Free Software Foundation, either version 3 of the License, or |
21 | * (at your option) any later version. | 21 | * (at your option) any later version. |
22 | * | 22 | * |
23 | * This program is distributed in the hope that it will be useful, | 23 | * This program is distributed in the hope that it will be useful, |
24 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | 24 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
25 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | 25 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
26 | * GNU General Public License for more details. | 26 | * GNU General Public License for more details. |
27 | * | 27 | * |
28 | * You should have received a copy of the GNU General Public License | 28 | * You should have received a copy of the GNU General Public License |
29 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | 29 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
30 | * | 30 | * |
31 | * | 31 | * |
32 | *****************************************************************************/ | 32 | *****************************************************************************/ |
33 | 33 | ||
34 | const char *progname = "check_procs"; | 34 | const char *progname = "check_procs"; |
@@ -50,7 +50,7 @@ const char *email = "devel@monitoring-plugins.org"; | |||
50 | 50 | ||
51 | int process_arguments (int, char **); | 51 | int process_arguments (int, char **); |
52 | int validate_arguments (void); | 52 | int validate_arguments (void); |
53 | int convert_to_seconds (char *); | 53 | int convert_to_seconds (char *); |
54 | void print_help (void); | 54 | void print_help (void); |
55 | void print_usage (void); | 55 | void print_usage (void); |
56 | 56 | ||
@@ -230,9 +230,9 @@ main (int argc, char **argv) | |||
230 | procseconds = convert_to_seconds(procetime); | 230 | procseconds = convert_to_seconds(procetime); |
231 | 231 | ||
232 | if (verbose >= 3) | 232 | if (verbose >= 3) |
233 | printf ("proc#=%d uid=%d vsz=%d rss=%d pid=%d ppid=%d pcpu=%.2f stat=%s etime=%s prog=%s args=%s\n", | 233 | printf ("proc#=%d uid=%d vsz=%d rss=%d pid=%d ppid=%d pcpu=%.2f stat=%s etime=%s prog=%s args=%s\n", |
234 | procs, procuid, procvsz, procrss, | 234 | procs, procuid, procvsz, procrss, |
235 | procpid, procppid, procpcpu, procstat, | 235 | procpid, procppid, procpcpu, procstat, |
236 | procetime, procprog, procargs); | 236 | procetime, procprog, procargs); |
237 | 237 | ||
238 | /* Ignore self */ | 238 | /* Ignore self */ |
@@ -265,7 +265,7 @@ main (int argc, char **argv) | |||
265 | } | 265 | } |
266 | } | 266 | } |
267 | 267 | ||
268 | if ((options & STAT) && (strstr (statopts, procstat))) | 268 | if ((options & STAT) && (strstr (procstat, statopts))) |
269 | resultsum |= STAT; | 269 | resultsum |= STAT; |
270 | if ((options & ARGS) && procargs && (strstr (procargs, args) != NULL)) | 270 | if ((options & ARGS) && procargs && (strstr (procargs, args) != NULL)) |
271 | resultsum |= ARGS; | 271 | resultsum |= ARGS; |
@@ -292,9 +292,9 @@ main (int argc, char **argv) | |||
292 | 292 | ||
293 | procs++; | 293 | procs++; |
294 | if (verbose >= 2) { | 294 | if (verbose >= 2) { |
295 | printf ("Matched: uid=%d vsz=%d rss=%d pid=%d ppid=%d pcpu=%.2f stat=%s etime=%s prog=%s args=%s\n", | 295 | printf ("Matched: uid=%d vsz=%d rss=%d pid=%d ppid=%d pcpu=%.2f stat=%s etime=%s prog=%s args=%s\n", |
296 | procuid, procvsz, procrss, | 296 | procuid, procvsz, procrss, |
297 | procpid, procppid, procpcpu, procstat, | 297 | procpid, procppid, procpcpu, procstat, |
298 | procetime, procprog, procargs); | 298 | procetime, procprog, procargs); |
299 | } | 299 | } |
300 | 300 | ||
@@ -320,7 +320,7 @@ main (int argc, char **argv) | |||
320 | result = max_state (result, i); | 320 | result = max_state (result, i); |
321 | } | 321 | } |
322 | } | 322 | } |
323 | } | 323 | } |
324 | /* This should not happen */ | 324 | /* This should not happen */ |
325 | else if (verbose) { | 325 | else if (verbose) { |
326 | printf(_("Not parseable: %s"), input_buffer); | 326 | printf(_("Not parseable: %s"), input_buffer); |
@@ -332,7 +332,7 @@ main (int argc, char **argv) | |||
332 | return STATE_UNKNOWN; | 332 | return STATE_UNKNOWN; |
333 | } | 333 | } |
334 | 334 | ||
335 | if ( result == STATE_UNKNOWN ) | 335 | if ( result == STATE_UNKNOWN ) |
336 | result = STATE_OK; | 336 | result = STATE_OK; |
337 | 337 | ||
338 | /* Needed if procs found, but none match filter */ | 338 | /* Needed if procs found, but none match filter */ |
@@ -352,9 +352,9 @@ main (int argc, char **argv) | |||
352 | if (metric != METRIC_PROCS) { | 352 | if (metric != METRIC_PROCS) { |
353 | printf (_("%d crit, %d warn out of "), crit, warn); | 353 | printf (_("%d crit, %d warn out of "), crit, warn); |
354 | } | 354 | } |
355 | } | 355 | } |
356 | printf (ngettext ("%d process", "%d processes", (unsigned long) procs), procs); | 356 | printf (ngettext ("%d process", "%d processes", (unsigned long) procs), procs); |
357 | 357 | ||
358 | if (strcmp(fmt,"") != 0) { | 358 | if (strcmp(fmt,"") != 0) { |
359 | printf (_(" with %s"), fmt); | 359 | printf (_(" with %s"), fmt); |
360 | } | 360 | } |
@@ -440,7 +440,7 @@ process_arguments (int argc, char **argv) | |||
440 | break; | 440 | break; |
441 | case 'c': /* critical threshold */ | 441 | case 'c': /* critical threshold */ |
442 | critical_range = optarg; | 442 | critical_range = optarg; |
443 | break; | 443 | break; |
444 | case 'w': /* warning threshold */ | 444 | case 'w': /* warning threshold */ |
445 | warning_range = optarg; | 445 | warning_range = optarg; |
446 | break; | 446 | break; |
@@ -542,11 +542,11 @@ process_arguments (int argc, char **argv) | |||
542 | if ( strcmp(optarg, "PROCS") == 0) { | 542 | if ( strcmp(optarg, "PROCS") == 0) { |
543 | metric = METRIC_PROCS; | 543 | metric = METRIC_PROCS; |
544 | break; | 544 | break; |
545 | } | 545 | } |
546 | else if ( strcmp(optarg, "VSZ") == 0) { | 546 | else if ( strcmp(optarg, "VSZ") == 0) { |
547 | metric = METRIC_VSZ; | 547 | metric = METRIC_VSZ; |
548 | break; | 548 | break; |
549 | } | 549 | } |
550 | else if ( strcmp(optarg, "RSS") == 0 ) { | 550 | else if ( strcmp(optarg, "RSS") == 0 ) { |
551 | metric = METRIC_RSS; | 551 | metric = METRIC_RSS; |
552 | break; | 552 | break; |
@@ -559,7 +559,7 @@ process_arguments (int argc, char **argv) | |||
559 | metric = METRIC_ELAPSED; | 559 | metric = METRIC_ELAPSED; |
560 | break; | 560 | break; |
561 | } | 561 | } |
562 | 562 | ||
563 | usage4 (_("Metric must be one of PROCS, VSZ, RSS, CPU, ELAPSED!")); | 563 | usage4 (_("Metric must be one of PROCS, VSZ, RSS, CPU, ELAPSED!")); |
564 | case 'k': /* linux kernel thread filter */ | 564 | case 'k': /* linux kernel thread filter */ |
565 | kthread_filter = 1; | 565 | kthread_filter = 1; |
@@ -642,7 +642,7 @@ convert_to_seconds(char *etime) { | |||
642 | seconds = 0; | 642 | seconds = 0; |
643 | 643 | ||
644 | for (ptr = etime; *ptr != '\0'; ptr++) { | 644 | for (ptr = etime; *ptr != '\0'; ptr++) { |
645 | 645 | ||
646 | if (*ptr == '-') { | 646 | if (*ptr == '-') { |
647 | hyphcnt++; | 647 | hyphcnt++; |
648 | continue; | 648 | continue; |
@@ -764,6 +764,11 @@ be the total number of running processes\n\n")); | |||
764 | printf (" %s\n", "check_procs -w 2:2 -c 2:1024 -C portsentry"); | 764 | printf (" %s\n", "check_procs -w 2:2 -c 2:1024 -C portsentry"); |
765 | printf (" %s\n", _("Warning if not two processes with command name portsentry.")); | 765 | printf (" %s\n", _("Warning if not two processes with command name portsentry.")); |
766 | printf (" %s\n\n", _("Critical if < 2 or > 1024 processes")); | 766 | printf (" %s\n\n", _("Critical if < 2 or > 1024 processes")); |
767 | printf (" %s\n", "check_procs -c 1: -C sshd"); | ||
768 | printf (" %s\n", _("Critical if not at least 1 process with command sshd")); | ||
769 | printf (" %s\n", "check_procs -w 1024 -c 1: -C sshd"); | ||
770 | printf (" %s\n", _("Warning if > 1024 processes with command name sshd.")); | ||
771 | printf (" %s\n\n", _("Critical if < 1 processes with command name sshd.")); | ||
767 | printf (" %s\n", "check_procs -w 10 -a '/usr/local/bin/perl' -u root"); | 772 | printf (" %s\n", "check_procs -w 10 -a '/usr/local/bin/perl' -u root"); |
768 | printf (" %s\n", _("Warning alert if > 10 processes with command arguments containing")); | 773 | printf (" %s\n", _("Warning alert if > 10 processes with command arguments containing")); |
769 | printf (" %s\n\n", _("'/usr/local/bin/perl' and owned by root")); | 774 | printf (" %s\n\n", _("'/usr/local/bin/perl' and owned by root")); |
diff --git a/plugins/check_smtp.c b/plugins/check_smtp.c index 0fcf4c68..c1e92dff 100644 --- a/plugins/check_smtp.c +++ b/plugins/check_smtp.c | |||
@@ -55,6 +55,7 @@ enum { | |||
55 | #define SMTP_EXPECT "220" | 55 | #define SMTP_EXPECT "220" |
56 | #define SMTP_HELO "HELO " | 56 | #define SMTP_HELO "HELO " |
57 | #define SMTP_EHLO "EHLO " | 57 | #define SMTP_EHLO "EHLO " |
58 | #define SMTP_LHLO "LHLO " | ||
58 | #define SMTP_QUIT "QUIT\r\n" | 59 | #define SMTP_QUIT "QUIT\r\n" |
59 | #define SMTP_STARTTLS "STARTTLS\r\n" | 60 | #define SMTP_STARTTLS "STARTTLS\r\n" |
60 | #define SMTP_AUTH_LOGIN "AUTH LOGIN\r\n" | 61 | #define SMTP_AUTH_LOGIN "AUTH LOGIN\r\n" |
@@ -102,6 +103,7 @@ int check_critical_time = FALSE; | |||
102 | int verbose = 0; | 103 | int verbose = 0; |
103 | int use_ssl = FALSE; | 104 | int use_ssl = FALSE; |
104 | short use_ehlo = FALSE; | 105 | short use_ehlo = FALSE; |
106 | short use_lhlo = FALSE; | ||
105 | short ssl_established = 0; | 107 | short ssl_established = 0; |
106 | char *localhostname = NULL; | 108 | char *localhostname = NULL; |
107 | int sd; | 109 | int sd; |
@@ -152,7 +154,9 @@ main (int argc, char **argv) | |||
152 | return STATE_CRITICAL; | 154 | return STATE_CRITICAL; |
153 | } | 155 | } |
154 | } | 156 | } |
155 | if(use_ehlo) | 157 | if(use_lhlo) |
158 | xasprintf (&helocmd, "%s%s%s", SMTP_LHLO, localhostname, "\r\n"); | ||
159 | else if(use_ehlo) | ||
156 | xasprintf (&helocmd, "%s%s%s", SMTP_EHLO, localhostname, "\r\n"); | 160 | xasprintf (&helocmd, "%s%s%s", SMTP_EHLO, localhostname, "\r\n"); |
157 | else | 161 | else |
158 | xasprintf (&helocmd, "%s%s%s", SMTP_HELO, localhostname, "\r\n"); | 162 | xasprintf (&helocmd, "%s%s%s", SMTP_HELO, localhostname, "\r\n"); |
@@ -197,7 +201,7 @@ main (int argc, char **argv) | |||
197 | if (recvlines(buffer, MAX_INPUT_BUFFER) <= 0) { | 201 | if (recvlines(buffer, MAX_INPUT_BUFFER) <= 0) { |
198 | printf (_("recv() failed\n")); | 202 | printf (_("recv() failed\n")); |
199 | return STATE_WARNING; | 203 | return STATE_WARNING; |
200 | } else if(use_ehlo){ | 204 | } else if(use_ehlo || use_lhlo){ |
201 | if(strstr(buffer, "250 STARTTLS") != NULL || | 205 | if(strstr(buffer, "250 STARTTLS") != NULL || |
202 | strstr(buffer, "250-STARTTLS") != NULL){ | 206 | strstr(buffer, "250-STARTTLS") != NULL){ |
203 | supports_tls=TRUE; | 207 | supports_tls=TRUE; |
@@ -293,6 +297,7 @@ main (int argc, char **argv) | |||
293 | printf("%s", buffer); | 297 | printf("%s", buffer); |
294 | } | 298 | } |
295 | 299 | ||
300 | n = 0; | ||
296 | while (n < ncommands) { | 301 | while (n < ncommands) { |
297 | xasprintf (&cmd_str, "%s%s", commands[n], "\r\n"); | 302 | xasprintf (&cmd_str, "%s%s", commands[n], "\r\n"); |
298 | my_send(cmd_str, strlen(cmd_str)); | 303 | my_send(cmd_str, strlen(cmd_str)); |
@@ -469,6 +474,7 @@ process_arguments (int argc, char **argv) | |||
469 | {"use-ipv4", no_argument, 0, '4'}, | 474 | {"use-ipv4", no_argument, 0, '4'}, |
470 | {"use-ipv6", no_argument, 0, '6'}, | 475 | {"use-ipv6", no_argument, 0, '6'}, |
471 | {"help", no_argument, 0, 'h'}, | 476 | {"help", no_argument, 0, 'h'}, |
477 | {"lmtp", no_argument, 0, 'L'}, | ||
472 | {"starttls",no_argument,0,'S'}, | 478 | {"starttls",no_argument,0,'S'}, |
473 | {"certificate",required_argument,0,'D'}, | 479 | {"certificate",required_argument,0,'D'}, |
474 | {"ignore-quit-failure",no_argument,0,'q'}, | 480 | {"ignore-quit-failure",no_argument,0,'q'}, |
@@ -488,7 +494,7 @@ process_arguments (int argc, char **argv) | |||
488 | } | 494 | } |
489 | 495 | ||
490 | while (1) { | 496 | while (1) { |
491 | c = getopt_long (argc, argv, "+hVv46t:p:f:e:c:w:H:C:R:SD:F:A:U:P:q", | 497 | c = getopt_long (argc, argv, "+hVv46Lt:p:f:e:c:w:H:C:R:SD:F:A:U:P:q", |
492 | longopts, &option); | 498 | longopts, &option); |
493 | 499 | ||
494 | if (c == -1 || c == EOF) | 500 | if (c == -1 || c == EOF) |
@@ -615,6 +621,9 @@ process_arguments (int argc, char **argv) | |||
615 | use_ssl = TRUE; | 621 | use_ssl = TRUE; |
616 | use_ehlo = TRUE; | 622 | use_ehlo = TRUE; |
617 | break; | 623 | break; |
624 | case 'L': | ||
625 | use_lhlo = TRUE; | ||
626 | break; | ||
618 | case '4': | 627 | case '4': |
619 | address_family = AF_INET; | 628 | address_family = AF_INET; |
620 | break; | 629 | break; |
@@ -823,6 +832,8 @@ print_help (void) | |||
823 | printf (" %s\n", _("SMTP AUTH username")); | 832 | printf (" %s\n", _("SMTP AUTH username")); |
824 | printf (" %s\n", "-P, --authpass=STRING"); | 833 | printf (" %s\n", "-P, --authpass=STRING"); |
825 | printf (" %s\n", _("SMTP AUTH password")); | 834 | printf (" %s\n", _("SMTP AUTH password")); |
835 | printf (" %s\n", "-L, --lmtp"); | ||
836 | printf (" %s\n", _("Send LHLO instead of HELO/EHLO")); | ||
826 | printf (" %s\n", "-q, --ignore-quit-failure"); | 837 | printf (" %s\n", "-q, --ignore-quit-failure"); |
827 | printf (" %s\n", _("Ignore failure when sending QUIT command to server")); | 838 | printf (" %s\n", _("Ignore failure when sending QUIT command to server")); |
828 | 839 | ||
@@ -849,6 +860,6 @@ print_usage (void) | |||
849 | printf ("%s\n", _("Usage:")); | 860 | printf ("%s\n", _("Usage:")); |
850 | printf ("%s -H host [-p port] [-4|-6] [-e expect] [-C command] [-R response] [-f from addr]\n", progname); | 861 | printf ("%s -H host [-p port] [-4|-6] [-e expect] [-C command] [-R response] [-f from addr]\n", progname); |
851 | printf ("[-A authtype -U authuser -P authpass] [-w warn] [-c crit] [-t timeout] [-q]\n"); | 862 | printf ("[-A authtype -U authuser -P authpass] [-w warn] [-c crit] [-t timeout] [-q]\n"); |
852 | printf ("[-F fqdn] [-S] [-D warn days cert expire[,crit days cert expire]] [-v] \n"); | 863 | printf ("[-F fqdn] [-S] [-L] [-D warn days cert expire[,crit days cert expire]] [-v] \n"); |
853 | } | 864 | } |
854 | 865 | ||
diff --git a/plugins/check_snmp.c b/plugins/check_snmp.c index da9638c4..abe54cfb 100644 --- a/plugins/check_snmp.c +++ b/plugins/check_snmp.c | |||
@@ -468,6 +468,9 @@ main (int argc, char **argv) | |||
468 | /* Process this block for numeric comparisons */ | 468 | /* Process this block for numeric comparisons */ |
469 | /* Make some special values,like Timeticks numeric only if a threshold is defined */ | 469 | /* Make some special values,like Timeticks numeric only if a threshold is defined */ |
470 | if (thlds[i]->warning || thlds[i]->critical || calculate_rate) { | 470 | if (thlds[i]->warning || thlds[i]->critical || calculate_rate) { |
471 | if (verbose > 2) { | ||
472 | print_thresholds(" thresholds", thlds[i]); | ||
473 | } | ||
471 | ptr = strpbrk (show, "-0123456789"); | 474 | ptr = strpbrk (show, "-0123456789"); |
472 | if (ptr == NULL) | 475 | if (ptr == NULL) |
473 | die (STATE_UNKNOWN,_("No valid data returned (%s)\n"), show); | 476 | die (STATE_UNKNOWN,_("No valid data returned (%s)\n"), show); |
@@ -576,20 +579,23 @@ main (int argc, char **argv) | |||
576 | len = sizeof(perfstr)-strlen(perfstr)-1; | 579 | len = sizeof(perfstr)-strlen(perfstr)-1; |
577 | strncat(perfstr, show, len>ptr-show ? ptr-show : len); | 580 | strncat(perfstr, show, len>ptr-show ? ptr-show : len); |
578 | 581 | ||
582 | if (type) | ||
583 | strncat(perfstr, type, sizeof(perfstr)-strlen(perfstr)-1); | ||
584 | |||
579 | if (warning_thresholds) { | 585 | if (warning_thresholds) { |
580 | strncat(perfstr, ";", sizeof(perfstr)-strlen(perfstr)-1); | 586 | strncat(perfstr, ";", sizeof(perfstr)-strlen(perfstr)-1); |
581 | strncat(perfstr, warning_thresholds, sizeof(perfstr)-strlen(perfstr)-1); | 587 | if(thlds[i]->warning && thlds[i]->warning->text) |
588 | strncat(perfstr, thlds[i]->warning->text, sizeof(perfstr)-strlen(perfstr)-1); | ||
582 | } | 589 | } |
583 | 590 | ||
584 | if (critical_thresholds) { | 591 | if (critical_thresholds) { |
585 | if (!warning_thresholds) | 592 | if (!warning_thresholds) |
586 | strncat(perfstr, ";", sizeof(perfstr)-strlen(perfstr)-1); | 593 | strncat(perfstr, ";", sizeof(perfstr)-strlen(perfstr)-1); |
587 | strncat(perfstr, ";", sizeof(perfstr)-strlen(perfstr)-1); | 594 | strncat(perfstr, ";", sizeof(perfstr)-strlen(perfstr)-1); |
588 | strncat(perfstr, critical_thresholds, sizeof(perfstr)-strlen(perfstr)-1); | 595 | if(thlds[i]->critical && thlds[i]->critical->text) |
596 | strncat(perfstr, thlds[i]->critical->text, sizeof(perfstr)-strlen(perfstr)-1); | ||
589 | } | 597 | } |
590 | 598 | ||
591 | if (type) | ||
592 | strncat(perfstr, type, sizeof(perfstr)-strlen(perfstr)-1); | ||
593 | strncat(perfstr, " ", sizeof(perfstr)-strlen(perfstr)-1); | 599 | strncat(perfstr, " ", sizeof(perfstr)-strlen(perfstr)-1); |
594 | } | 600 | } |
595 | } | 601 | } |
@@ -1160,7 +1166,7 @@ print_help (void) | |||
1160 | printf ("(%s \"%s\")\n", _("default is") ,DEFAULT_COMMUNITY); | 1166 | printf ("(%s \"%s\")\n", _("default is") ,DEFAULT_COMMUNITY); |
1161 | printf (" %s\n", "-U, --secname=USERNAME"); | 1167 | printf (" %s\n", "-U, --secname=USERNAME"); |
1162 | printf (" %s\n", _("SNMPv3 username")); | 1168 | printf (" %s\n", _("SNMPv3 username")); |
1163 | printf (" %s\n", "-A, --authpassword=PASSWORD"); | 1169 | printf (" %s\n", "-A, --authpasswd=PASSWORD"); |
1164 | printf (" %s\n", _("SNMPv3 authentication password")); | 1170 | printf (" %s\n", _("SNMPv3 authentication password")); |
1165 | printf (" %s\n", "-X, --privpasswd=PASSWORD"); | 1171 | printf (" %s\n", "-X, --privpasswd=PASSWORD"); |
1166 | printf (" %s\n", _("SNMPv3 privacy password")); | 1172 | printf (" %s\n", _("SNMPv3 privacy password")); |
@@ -1207,8 +1213,9 @@ print_help (void) | |||
1207 | printf (" %s\n", _("Separates output on multiple OID requests")); | 1213 | printf (" %s\n", _("Separates output on multiple OID requests")); |
1208 | 1214 | ||
1209 | printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT); | 1215 | printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT); |
1216 | printf (" %s\n", _("NOTE the final timeout value is calculated using this formula: timeout_interval * retries + 5")); | ||
1210 | printf (" %s\n", "-e, --retries=INTEGER"); | 1217 | printf (" %s\n", "-e, --retries=INTEGER"); |
1211 | printf (" %s\n", _("Number of retries to be used in the requests")); | 1218 | printf (" %s%i\n", _("Number of retries to be used in the requests, default: "), DEFAULT_RETRIES); |
1212 | 1219 | ||
1213 | printf (" %s\n", "-O, --perf-oids"); | 1220 | printf (" %s\n", "-O, --perf-oids"); |
1214 | printf (" %s\n", _("Label performance data with OIDs instead of --label's")); | 1221 | printf (" %s\n", _("Label performance data with OIDs instead of --label's")); |
diff --git a/plugins/check_swap.c b/plugins/check_swap.c index 4d5a4071..7da26cfc 100644 --- a/plugins/check_swap.c +++ b/plugins/check_swap.c | |||
@@ -34,6 +34,9 @@ const char *email = "devel@monitoring-plugins.org"; | |||
34 | #include "common.h" | 34 | #include "common.h" |
35 | #include "popen.h" | 35 | #include "popen.h" |
36 | #include "utils.h" | 36 | #include "utils.h" |
37 | #include <string.h> | ||
38 | #include <math.h> | ||
39 | #include <libintl.h> | ||
37 | 40 | ||
38 | #ifdef HAVE_DECL_SWAPCTL | 41 | #ifdef HAVE_DECL_SWAPCTL |
39 | # ifdef HAVE_SYS_PARAM_H | 42 | # ifdef HAVE_SYS_PARAM_H |
@@ -51,16 +54,19 @@ const char *email = "devel@monitoring-plugins.org"; | |||
51 | # define SWAP_CONVERSION 1 | 54 | # define SWAP_CONVERSION 1 |
52 | #endif | 55 | #endif |
53 | 56 | ||
54 | int check_swap (int usp, float free_swap_mb); | 57 | typedef struct { |
58 | int is_percentage; | ||
59 | uint64_t value; | ||
60 | } threshold_t; | ||
61 | |||
62 | int check_swap (float free_swap_mb, float total_swap_mb); | ||
55 | int process_arguments (int argc, char **argv); | 63 | int process_arguments (int argc, char **argv); |
56 | int validate_arguments (void); | 64 | int validate_arguments (void); |
57 | void print_usage (void); | 65 | void print_usage (void); |
58 | void print_help (void); | 66 | void print_help (void); |
59 | 67 | ||
60 | int warn_percent = 0; | 68 | threshold_t warn; |
61 | int crit_percent = 0; | 69 | threshold_t crit; |
62 | float warn_size_bytes = 0; | ||
63 | float crit_size_bytes = 0; | ||
64 | int verbose; | 70 | int verbose; |
65 | int allswaps; | 71 | int allswaps; |
66 | int no_swap_state = STATE_CRITICAL; | 72 | int no_swap_state = STATE_CRITICAL; |
@@ -68,9 +74,10 @@ int no_swap_state = STATE_CRITICAL; | |||
68 | int | 74 | int |
69 | main (int argc, char **argv) | 75 | main (int argc, char **argv) |
70 | { | 76 | { |
71 | int percent_used, percent; | 77 | unsigned int percent_used, percent; |
72 | float total_swap_mb = 0, used_swap_mb = 0, free_swap_mb = 0; | 78 | uint64_t total_swap_mb = 0, used_swap_mb = 0, free_swap_mb = 0; |
73 | float dsktotal_mb = 0, dskused_mb = 0, dskfree_mb = 0, tmp_mb = 0; | 79 | uint64_t dsktotal_mb = 0, dskused_mb = 0, dskfree_mb = 0; |
80 | uint64_t tmp_KB = 0; | ||
74 | int result = STATE_UNKNOWN; | 81 | int result = STATE_UNKNOWN; |
75 | char input_buffer[MAX_INPUT_BUFFER]; | 82 | char input_buffer[MAX_INPUT_BUFFER]; |
76 | #ifdef HAVE_PROC_MEMINFO | 83 | #ifdef HAVE_PROC_MEMINFO |
@@ -116,10 +123,15 @@ main (int argc, char **argv) | |||
116 | } | 123 | } |
117 | fp = fopen (PROC_MEMINFO, "r"); | 124 | fp = fopen (PROC_MEMINFO, "r"); |
118 | while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) { | 125 | while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) { |
119 | if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%*[:] %f %f %f", &dsktotal_mb, &dskused_mb, &dskfree_mb) == 3) { | 126 | /* |
120 | dsktotal_mb = dsktotal_mb / 1048576; /* Apply conversion */ | 127 | * The following sscanf call looks for a line looking like: "Swap: 123 123 123" |
121 | dskused_mb = dskused_mb / 1048576; | 128 | * On which kind of system this format exists, I can not say, but I wanted to |
122 | dskfree_mb = dskfree_mb / 1048576; | 129 | * document this for people who are not adapt with sscanf anymore, like me |
130 | */ | ||
131 | if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%*[:] %lu %lu %lu", &dsktotal_mb, &dskused_mb, &dskfree_mb) == 3) { | ||
132 | dsktotal_mb = dsktotal_mb / (1024 * 1024); /* Apply conversion */ | ||
133 | dskused_mb = dskused_mb / (1024 * 1024); | ||
134 | dskfree_mb = dskfree_mb / (1024 * 1024); | ||
123 | total_swap_mb += dsktotal_mb; | 135 | total_swap_mb += dsktotal_mb; |
124 | used_swap_mb += dskused_mb; | 136 | used_swap_mb += dskused_mb; |
125 | free_swap_mb += dskfree_mb; | 137 | free_swap_mb += dskfree_mb; |
@@ -128,21 +140,25 @@ main (int argc, char **argv) | |||
128 | percent=100.0; | 140 | percent=100.0; |
129 | else | 141 | else |
130 | percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); | 142 | percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); |
131 | result = max_state (result, check_swap (percent, dskfree_mb)); | 143 | result = max_state (result, check_swap (dskfree_mb, dsktotal_mb)); |
132 | if (verbose) | 144 | if (verbose) |
133 | xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); | 145 | xasprintf (&status, "%s [%lu (%d%%)]", status, dskfree_mb, 100 - percent); |
134 | } | 146 | } |
135 | } | 147 | } |
136 | else if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%[TotalFre]%*[:] %f %*[k]%*[B]", str, &tmp_mb)) { | 148 | /* |
149 | * The following sscanf call looks for lines looking like: "SwapTotal: 123" and "SwapFree: 123" | ||
150 | * This format exists at least on Debian Linux with a 5.* kernel | ||
151 | */ | ||
152 | else if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%[TotalFre]%*[:] %lu %*[k]%*[B]", str, &tmp_KB)) { | ||
137 | if (verbose >= 3) { | 153 | if (verbose >= 3) { |
138 | printf("Got %s with %f\n", str, tmp_mb); | 154 | printf("Got %s with %lu\n", str, tmp_KB); |
139 | } | 155 | } |
140 | /* I think this part is always in Kb, so convert to mb */ | 156 | /* I think this part is always in Kb, so convert to mb */ |
141 | if (strcmp ("Total", str) == 0) { | 157 | if (strcmp ("Total", str) == 0) { |
142 | dsktotal_mb = tmp_mb / 1024; | 158 | dsktotal_mb = tmp_KB / 1024; |
143 | } | 159 | } |
144 | else if (strcmp ("Free", str) == 0) { | 160 | else if (strcmp ("Free", str) == 0) { |
145 | dskfree_mb = tmp_mb / 1024; | 161 | dskfree_mb = tmp_KB / 1024; |
146 | } | 162 | } |
147 | } | 163 | } |
148 | } | 164 | } |
@@ -227,7 +243,7 @@ main (int argc, char **argv) | |||
227 | free_swap_mb += dskfree_mb; | 243 | free_swap_mb += dskfree_mb; |
228 | if (allswaps) { | 244 | if (allswaps) { |
229 | percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); | 245 | percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); |
230 | result = max_state (result, check_swap (percent, dskfree_mb)); | 246 | result = max_state (result, check_swap (dskfree_mb, dsktotal_mb)); |
231 | if (verbose) | 247 | if (verbose) |
232 | xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); | 248 | xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); |
233 | } | 249 | } |
@@ -289,7 +305,7 @@ main (int argc, char **argv) | |||
289 | 305 | ||
290 | if(allswaps && dsktotal_mb > 0){ | 306 | if(allswaps && dsktotal_mb > 0){ |
291 | percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); | 307 | percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); |
292 | result = max_state (result, check_swap (percent, dskfree_mb)); | 308 | result = max_state (result, check_swap (dskfree_mb, dsktotal_mb)); |
293 | if (verbose) { | 309 | if (verbose) { |
294 | xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); | 310 | xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); |
295 | } | 311 | } |
@@ -328,7 +344,7 @@ main (int argc, char **argv) | |||
328 | 344 | ||
329 | if(allswaps && dsktotal_mb > 0){ | 345 | if(allswaps && dsktotal_mb > 0){ |
330 | percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); | 346 | percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); |
331 | result = max_state (result, check_swap (percent, dskfree_mb)); | 347 | result = max_state (result, check_swap(dskfree_mb, dsktotal_mb)); |
332 | if (verbose) { | 348 | if (verbose) { |
333 | xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); | 349 | xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); |
334 | } | 350 | } |
@@ -355,14 +371,19 @@ main (int argc, char **argv) | |||
355 | status = "- Swap is either disabled, not present, or of zero size. "; | 371 | status = "- Swap is either disabled, not present, or of zero size. "; |
356 | } | 372 | } |
357 | 373 | ||
358 | result = max_state (result, check_swap (percent_used, free_swap_mb)); | 374 | result = max_state (result, check_swap(free_swap_mb, total_swap_mb)); |
359 | printf (_("SWAP %s - %d%% free (%d MB out of %d MB) %s|"), | 375 | printf (_("SWAP %s - %d%% free (%dMB out of %dMB) %s|"), |
360 | state_text (result), | 376 | state_text (result), |
361 | (100 - percent_used), (int) free_swap_mb, (int) total_swap_mb, status); | 377 | (100 - percent_used), (int) free_swap_mb, (int) total_swap_mb, status); |
362 | 378 | ||
363 | puts (perfdata ("swap", (long) free_swap_mb, "MB", | 379 | uint64_t warn_print = warn.value; |
364 | TRUE, (long) max (warn_size_bytes/(1024 * 1024), warn_percent/100.0*total_swap_mb), | 380 | if (warn.is_percentage) warn_print = warn.value * (total_swap_mb *1024 *1024/100); |
365 | TRUE, (long) max (crit_size_bytes/(1024 * 1024), crit_percent/100.0*total_swap_mb), | 381 | uint64_t crit_print = crit.value; |
382 | if (crit.is_percentage) crit_print = crit.value * (total_swap_mb *1024 *1024/100); | ||
383 | |||
384 | puts (perfdata_uint64 ("swap", free_swap_mb *1024 *1024, "B", | ||
385 | TRUE, warn_print, | ||
386 | TRUE, crit_print, | ||
366 | TRUE, 0, | 387 | TRUE, 0, |
367 | TRUE, (long) total_swap_mb)); | 388 | TRUE, (long) total_swap_mb)); |
368 | 389 | ||
@@ -370,26 +391,37 @@ main (int argc, char **argv) | |||
370 | } | 391 | } |
371 | 392 | ||
372 | 393 | ||
373 | |||
374 | int | 394 | int |
375 | check_swap (int usp, float free_swap_mb) | 395 | check_swap(float free_swap_mb, float total_swap_mb) |
376 | { | 396 | { |
377 | 397 | ||
378 | if (!free_swap_mb) return no_swap_state; | 398 | if (!total_swap_mb) return no_swap_state; |
379 | 399 | ||
380 | int result = STATE_UNKNOWN; | 400 | uint64_t free_swap = free_swap_mb * (1024 * 1024); /* Convert back to bytes as warn and crit specified in bytes */ |
381 | float free_swap = free_swap_mb * (1024 * 1024); /* Convert back to bytes as warn and crit specified in bytes */ | 401 | |
382 | if (usp >= 0 && crit_percent != 0 && usp >= (100.0 - crit_percent)) | 402 | if (!crit.is_percentage && crit.value >= free_swap) return STATE_CRITICAL; |
383 | result = STATE_CRITICAL; | 403 | if (!warn.is_percentage && warn.value >= free_swap) return STATE_WARNING; |
384 | else if (crit_size_bytes > 0 && free_swap <= crit_size_bytes) | 404 | |
385 | result = STATE_CRITICAL; | 405 | |
386 | else if (usp >= 0 && warn_percent != 0 && usp >= (100.0 - warn_percent)) | 406 | uint64_t usage_percentage = ((total_swap_mb - free_swap_mb) / total_swap_mb) * 100; |
387 | result = STATE_WARNING; | 407 | |
388 | else if (warn_size_bytes > 0 && free_swap <= warn_size_bytes) | 408 | if (crit.is_percentage && |
389 | result = STATE_WARNING; | 409 | usage_percentage >= 0 && |
390 | else if (usp >= 0.0) | 410 | crit.value != 0 && |
391 | result = STATE_OK; | 411 | usage_percentage >= (100 - crit.value)) |
392 | return result; | 412 | { |
413 | return STATE_CRITICAL; | ||
414 | } | ||
415 | |||
416 | if (warn.is_percentage && | ||
417 | usage_percentage >= 0 && | ||
418 | warn.value != 0 && | ||
419 | usage_percentage >= (100 - warn.value)) | ||
420 | { | ||
421 | return STATE_WARNING; | ||
422 | } | ||
423 | |||
424 | return STATE_OK; | ||
393 | } | 425 | } |
394 | 426 | ||
395 | 427 | ||
@@ -422,42 +454,68 @@ process_arguments (int argc, char **argv) | |||
422 | break; | 454 | break; |
423 | 455 | ||
424 | switch (c) { | 456 | switch (c) { |
425 | case 'w': /* warning size threshold */ | 457 | case 'w': /* warning size threshold */ |
426 | if (is_intnonneg (optarg)) { | 458 | { |
427 | warn_size_bytes = (float) atoi (optarg); | 459 | /* |
428 | break; | 460 | * We expect either a positive integer value without a unit, which means |
429 | } | 461 | * the unit is Bytes or a positive integer value and a percentage sign (%), |
430 | else if (strstr (optarg, ",") && | 462 | * which means the value must be with 0 and 100 and is relative to the total swap |
431 | strstr (optarg, "%") && | 463 | */ |
432 | sscanf (optarg, "%f,%d%%", &warn_size_bytes, &warn_percent) == 2) { | 464 | size_t length; |
433 | warn_size_bytes = floorf(warn_size_bytes); | 465 | length = strlen(optarg); |
434 | break; | 466 | |
435 | } | 467 | if (optarg[length - 1] == '%') { |
436 | else if (strstr (optarg, "%") && | 468 | /* It's percentage */ |
437 | sscanf (optarg, "%d%%", &warn_percent) == 1) { | 469 | warn.is_percentage = 1; |
438 | break; | 470 | optarg[length - 1] = '\0'; |
439 | } | 471 | if (is_uint64(optarg, &warn.value)) { |
440 | else { | 472 | if (warn.value > 100) { |
441 | usage4 (_("Warning threshold must be integer or percentage!")); | 473 | usage4 (_("Warning threshold percentage must be <= 100!")); |
442 | } | 474 | } else { |
443 | case 'c': /* critical size threshold */ | 475 | break; |
444 | if (is_intnonneg (optarg)) { | 476 | } |
445 | crit_size_bytes = (float) atoi (optarg); | 477 | } |
446 | break; | 478 | } else { |
447 | } | 479 | /* It's Bytes */ |
448 | else if (strstr (optarg, ",") && | 480 | warn.is_percentage = 0; |
449 | strstr (optarg, "%") && | 481 | if (is_uint64(optarg, &warn.value)) { |
450 | sscanf (optarg, "%f,%d%%", &crit_size_bytes, &crit_percent) == 2) { | 482 | break; |
451 | crit_size_bytes = floorf(crit_size_bytes); | 483 | } else { |
452 | break; | 484 | usage4 (_("Warning threshold be positive integer or percentage!")); |
453 | } | 485 | } |
454 | else if (strstr (optarg, "%") && | 486 | } |
455 | sscanf (optarg, "%d%%", &crit_percent) == 1) { | ||
456 | break; | ||
457 | } | ||
458 | else { | ||
459 | usage4 (_("Critical threshold must be integer or percentage!")); | ||
460 | } | 487 | } |
488 | case 'c': /* critical size threshold */ | ||
489 | { | ||
490 | /* | ||
491 | * We expect either a positive integer value without a unit, which means | ||
492 | * the unit is Bytes or a positive integer value and a percentage sign (%), | ||
493 | * which means the value must be with 0 and 100 and is relative to the total swap | ||
494 | */ | ||
495 | size_t length; | ||
496 | length = strlen(optarg); | ||
497 | |||
498 | if (optarg[length - 1] == '%') { | ||
499 | /* It's percentage */ | ||
500 | crit.is_percentage = 1; | ||
501 | optarg[length - 1] = '\0'; | ||
502 | if (is_uint64(optarg, &crit.value)) { | ||
503 | if (crit.value> 100) { | ||
504 | usage4 (_("Critical threshold percentage must be <= 100!")); | ||
505 | } else { | ||
506 | break; | ||
507 | } | ||
508 | } | ||
509 | } else { | ||
510 | /* It's Bytes */ | ||
511 | crit.is_percentage = 0; | ||
512 | if (is_uint64(optarg, &crit.value)) { | ||
513 | break; | ||
514 | } else { | ||
515 | usage4 (_("Critical threshold be positive integer or percentage!")); | ||
516 | } | ||
517 | } | ||
518 | } | ||
461 | case 'a': /* all swap */ | 519 | case 'a': /* all swap */ |
462 | allswaps = TRUE; | 520 | allswaps = TRUE; |
463 | break; | 521 | break; |
@@ -482,23 +540,6 @@ process_arguments (int argc, char **argv) | |||
482 | c = optind; | 540 | c = optind; |
483 | if (c == argc) | 541 | if (c == argc) |
484 | return validate_arguments (); | 542 | return validate_arguments (); |
485 | if (warn_percent == 0 && is_intnonneg (argv[c])) | ||
486 | warn_percent = atoi (argv[c++]); | ||
487 | |||
488 | if (c == argc) | ||
489 | return validate_arguments (); | ||
490 | if (crit_percent == 0 && is_intnonneg (argv[c])) | ||
491 | crit_percent = atoi (argv[c++]); | ||
492 | |||
493 | if (c == argc) | ||
494 | return validate_arguments (); | ||
495 | if (warn_size_bytes == 0 && is_intnonneg (argv[c])) | ||
496 | warn_size_bytes = (float) atoi (argv[c++]); | ||
497 | |||
498 | if (c == argc) | ||
499 | return validate_arguments (); | ||
500 | if (crit_size_bytes == 0 && is_intnonneg (argv[c])) | ||
501 | crit_size_bytes = (float) atoi (argv[c++]); | ||
502 | 543 | ||
503 | return validate_arguments (); | 544 | return validate_arguments (); |
504 | } | 545 | } |
@@ -508,17 +549,15 @@ process_arguments (int argc, char **argv) | |||
508 | int | 549 | int |
509 | validate_arguments (void) | 550 | validate_arguments (void) |
510 | { | 551 | { |
511 | if (warn_percent == 0 && crit_percent == 0 && warn_size_bytes == 0 | 552 | if (warn.value == 0 && crit.value == 0) { |
512 | && crit_size_bytes == 0) { | ||
513 | return ERROR; | 553 | return ERROR; |
514 | } | 554 | } |
515 | else if (warn_percent < crit_percent) { | 555 | else if ((warn.is_percentage == crit.is_percentage) && (warn.value < crit.value)) { |
516 | usage4 | 556 | /* This is NOT triggered if warn and crit are different units, e.g warn is percentage |
517 | (_("Warning percentage should be more than critical percentage")); | 557 | * and crit is absolut. We cannot determine the condition at this point since we |
518 | } | 558 | * dont know the value of total swap yet |
519 | else if (warn_size_bytes < crit_size_bytes) { | 559 | */ |
520 | usage4 | 560 | usage4(_("Warning should be more than critical")); |
521 | (_("Warning free space should be more than critical free space")); | ||
522 | } | 561 | } |
523 | return OK; | 562 | return OK; |
524 | } | 563 | } |
@@ -534,7 +573,7 @@ print_help (void) | |||
534 | 573 | ||
535 | printf ("%s\n", _("Check swap space on local machine.")); | 574 | printf ("%s\n", _("Check swap space on local machine.")); |
536 | 575 | ||
537 | printf ("\n\n"); | 576 | printf ("\n\n"); |
538 | 577 | ||
539 | print_usage (); | 578 | print_usage (); |
540 | 579 | ||
@@ -542,33 +581,32 @@ print_help (void) | |||
542 | printf (UT_EXTRA_OPTS); | 581 | printf (UT_EXTRA_OPTS); |
543 | 582 | ||
544 | printf (" %s\n", "-w, --warning=INTEGER"); | 583 | printf (" %s\n", "-w, --warning=INTEGER"); |
545 | printf (" %s\n", _("Exit with WARNING status if less than INTEGER bytes of swap space are free")); | 584 | printf (" %s\n", _("Exit with WARNING status if less than INTEGER bytes of swap space are free")); |
546 | printf (" %s\n", "-w, --warning=PERCENT%%"); | 585 | printf (" %s\n", "-w, --warning=PERCENT%"); |
547 | printf (" %s\n", _("Exit with WARNING status if less than PERCENT of swap space is free")); | 586 | printf (" %s\n", _("Exit with WARNING status if less than PERCENT of swap space is free")); |
548 | printf (" %s\n", "-c, --critical=INTEGER"); | 587 | printf (" %s\n", "-c, --critical=INTEGER"); |
549 | printf (" %s\n", _("Exit with CRITICAL status if less than INTEGER bytes of swap space are free")); | 588 | printf (" %s\n", _("Exit with CRITICAL status if less than INTEGER bytes of swap space are free")); |
550 | printf (" %s\n", "-c, --critical=PERCENT%%"); | 589 | printf (" %s\n", "-c, --critical=PERCENT%"); |
551 | printf (" %s\n", _("Exit with CRITICAL status if less than PERCENT of swap space is free")); | 590 | printf (" %s\n", _("Exit with CRITICAL status if less than PERCENT of swap space is free")); |
552 | printf (" %s\n", "-a, --allswaps"); | 591 | printf (" %s\n", "-a, --allswaps"); |
553 | printf (" %s\n", _("Conduct comparisons for all swap partitions, one by one")); | 592 | printf (" %s\n", _("Conduct comparisons for all swap partitions, one by one")); |
554 | printf (" %s\n", "-n, --no-swap=<ok|warning|critical|unknown>"); | 593 | printf (" %s\n", "-n, --no-swap=<ok|warning|critical|unknown>"); |
555 | printf (" %s %s\n", _("Resulting state when there is no swap regardless of thresholds. Default:"), state_text(no_swap_state)); | 594 | printf (" %s %s\n", _("Resulting state when there is no swap regardless of thresholds. Default:"), state_text(no_swap_state)); |
556 | printf (UT_VERBOSE); | 595 | printf (UT_VERBOSE); |
557 | 596 | ||
558 | printf ("\n"); | 597 | printf ("\n"); |
559 | printf ("%s\n", _("Notes:")); | 598 | printf ("%s\n", _("Notes:")); |
560 | printf (" %s\n", _("Both INTEGER and PERCENT thresholds can be specified, they are all checked.")); | 599 | printf (" %s\n", _("Both INTEGER and PERCENT thresholds can be specified, they are all checked.")); |
561 | printf (" %s\n", _("On AIX, if -a is specified, uses lsps -a, otherwise uses lsps -s.")); | 600 | printf (" %s\n", _("On AIX, if -a is specified, uses lsps -a, otherwise uses lsps -s.")); |
562 | 601 | ||
563 | printf (UT_SUPPORT); | 602 | printf (UT_SUPPORT); |
564 | } | 603 | } |
565 | 604 | ||
566 | 605 | ||
567 | |||
568 | void | 606 | void |
569 | print_usage (void) | 607 | print_usage (void) |
570 | { | 608 | { |
571 | printf ("%s\n", _("Usage:")); | 609 | printf ("%s\n", _("Usage:")); |
572 | printf (" %s [-av] -w <percent_free>%% -c <percent_free>%%\n",progname); | 610 | printf (" %s [-av] -w <percent_free>%% -c <percent_free>%%\n",progname); |
573 | printf (" -w <bytes_free> -c <bytes_free> [-n <state>]\n"); | 611 | printf (" -w <bytes_free> -c <bytes_free> [-n <state>]\n"); |
574 | } | 612 | } |
diff --git a/plugins/check_tcp.c b/plugins/check_tcp.c index 61333bd7..1365b9cb 100644 --- a/plugins/check_tcp.c +++ b/plugins/check_tcp.c | |||
@@ -86,6 +86,11 @@ static char buffer[MAXBUF]; | |||
86 | static int expect_mismatch_state = STATE_WARNING; | 86 | static int expect_mismatch_state = STATE_WARNING; |
87 | static int match_flags = NP_MATCH_EXACT; | 87 | static int match_flags = NP_MATCH_EXACT; |
88 | 88 | ||
89 | #ifdef HAVE_SSL | ||
90 | static char *sni = NULL; | ||
91 | static int sni_specified = FALSE; | ||
92 | #endif | ||
93 | |||
89 | #define FLAG_SSL 0x01 | 94 | #define FLAG_SSL 0x01 |
90 | #define FLAG_VERBOSE 0x02 | 95 | #define FLAG_VERBOSE 0x02 |
91 | #define FLAG_TIME_WARN 0x04 | 96 | #define FLAG_TIME_WARN 0x04 |
@@ -241,7 +246,7 @@ main (int argc, char **argv) | |||
241 | 246 | ||
242 | #ifdef HAVE_SSL | 247 | #ifdef HAVE_SSL |
243 | if (flags & FLAG_SSL){ | 248 | if (flags & FLAG_SSL){ |
244 | result = np_net_ssl_init(sd); | 249 | result = np_net_ssl_init_with_hostname(sd, (sni_specified ? sni : NULL)); |
245 | if (result == STATE_OK && check_cert == TRUE) { | 250 | if (result == STATE_OK && check_cert == TRUE) { |
246 | result = np_net_ssl_check_cert(days_till_exp_warn, days_till_exp_crit); | 251 | result = np_net_ssl_check_cert(days_till_exp_warn, days_till_exp_crit); |
247 | } | 252 | } |
@@ -401,6 +406,10 @@ process_arguments (int argc, char **argv) | |||
401 | int escape = 0; | 406 | int escape = 0; |
402 | char *temp; | 407 | char *temp; |
403 | 408 | ||
409 | enum { | ||
410 | SNI_OPTION = CHAR_MAX + 1 | ||
411 | }; | ||
412 | |||
404 | int option = 0; | 413 | int option = 0; |
405 | static struct option longopts[] = { | 414 | static struct option longopts[] = { |
406 | {"hostname", required_argument, 0, 'H'}, | 415 | {"hostname", required_argument, 0, 'H'}, |
@@ -427,6 +436,7 @@ process_arguments (int argc, char **argv) | |||
427 | {"version", no_argument, 0, 'V'}, | 436 | {"version", no_argument, 0, 'V'}, |
428 | {"help", no_argument, 0, 'h'}, | 437 | {"help", no_argument, 0, 'h'}, |
429 | {"ssl", no_argument, 0, 'S'}, | 438 | {"ssl", no_argument, 0, 'S'}, |
439 | {"sni", required_argument, 0, SNI_OPTION}, | ||
430 | {"certificate", required_argument, 0, 'D'}, | 440 | {"certificate", required_argument, 0, 'D'}, |
431 | {0, 0, 0, 0} | 441 | {0, 0, 0, 0} |
432 | }; | 442 | }; |
@@ -604,6 +614,15 @@ process_arguments (int argc, char **argv) | |||
604 | die (STATE_UNKNOWN, _("Invalid option - SSL is not available")); | 614 | die (STATE_UNKNOWN, _("Invalid option - SSL is not available")); |
605 | #endif | 615 | #endif |
606 | break; | 616 | break; |
617 | case SNI_OPTION: | ||
618 | #ifdef HAVE_SSL | ||
619 | flags |= FLAG_SSL; | ||
620 | sni_specified = TRUE; | ||
621 | sni = optarg; | ||
622 | #else | ||
623 | die (STATE_UNKNOWN, _("Invalid option - SSL is not available")); | ||
624 | #endif | ||
625 | break; | ||
607 | case 'A': | 626 | case 'A': |
608 | match_flags |= NP_MATCH_ALL; | 627 | match_flags |= NP_MATCH_ALL; |
609 | break; | 628 | break; |
@@ -671,6 +690,8 @@ print_help (void) | |||
671 | printf (" %s\n", _("1st is #days for warning, 2nd is critical (if not specified - 0).")); | 690 | printf (" %s\n", _("1st is #days for warning, 2nd is critical (if not specified - 0).")); |
672 | printf (" %s\n", "-S, --ssl"); | 691 | printf (" %s\n", "-S, --ssl"); |
673 | printf (" %s\n", _("Use SSL for the connection.")); | 692 | printf (" %s\n", _("Use SSL for the connection.")); |
693 | printf (" %s\n", "--sni=STRING"); | ||
694 | printf (" %s\n", _("SSL server_name")); | ||
674 | #endif | 695 | #endif |
675 | 696 | ||
676 | printf (UT_WARN_CRIT); | 697 | printf (UT_WARN_CRIT); |
diff --git a/plugins/check_ups.c b/plugins/check_ups.c index e9e56a51..0de37a20 100644 --- a/plugins/check_ups.c +++ b/plugins/check_ups.c | |||
@@ -402,7 +402,10 @@ get_ups_variable (const char *varname, char *buf, size_t buflen) | |||
402 | 402 | ||
403 | /* create the command string to send to the UPS daemon */ | 403 | /* create the command string to send to the UPS daemon */ |
404 | /* Add LOGOUT to avoid read failure logs */ | 404 | /* Add LOGOUT to avoid read failure logs */ |
405 | sprintf (send_buffer, "GET VAR %s %s\nLOGOUT\n", ups_name, varname); | 405 | if (snprintf (send_buffer, sizeof(send_buffer), "GET VAR %s %s\nLOGOUT\n", ups_name, varname) >= sizeof(send_buffer)) { |
406 | printf("%s\n", _("UPS name to long for buffer")); | ||
407 | return ERROR; | ||
408 | } | ||
406 | 409 | ||
407 | /* send the command to the daemon and get a response back */ | 410 | /* send the command to the daemon and get a response back */ |
408 | if (process_tcp_request | 411 | if (process_tcp_request |
diff --git a/plugins/common.h b/plugins/common.h index 8719b502..0f08e2f6 100644 --- a/plugins/common.h +++ b/plugins/common.h | |||
@@ -174,6 +174,11 @@ | |||
174 | * | 174 | * |
175 | */ | 175 | */ |
176 | 176 | ||
177 | /* MariaDB 10.2 client does not set MYSQL_PORT */ | ||
178 | #ifndef MYSQL_PORT | ||
179 | # define MYSQL_PORT 3306 | ||
180 | #endif | ||
181 | |||
177 | enum { | 182 | enum { |
178 | OK = 0, | 183 | OK = 0, |
179 | ERROR = -1 | 184 | ERROR = -1 |
@@ -220,4 +225,18 @@ enum { | |||
220 | # define __attribute__(x) /* do nothing */ | 225 | # define __attribute__(x) /* do nothing */ |
221 | #endif | 226 | #endif |
222 | 227 | ||
228 | /* Try sysconf(_SC_OPEN_MAX) first, as it can be higher than OPEN_MAX. | ||
229 | * If that fails and the macro isn't defined, we fall back to an educated | ||
230 | * guess. There's no guarantee that our guess is adequate and the program | ||
231 | * will die with SIGSEGV if it isn't and the upper boundary is breached. */ | ||
232 | #define DEFAULT_MAXFD 256 /* fallback value if no max open files value is set */ | ||
233 | #define MAXFD_LIMIT 8192 /* upper limit of open files */ | ||
234 | #ifdef _SC_OPEN_MAX | ||
235 | static long maxfd = 0; | ||
236 | #elif defined(OPEN_MAX) | ||
237 | # define maxfd OPEN_MAX | ||
238 | #else /* sysconf macro unavailable, so guess (may be wildly inaccurate) */ | ||
239 | # define maxfd DEFAULT_MAXFD | ||
240 | #endif | ||
241 | |||
223 | #endif /* _COMMON_H_ */ | 242 | #endif /* _COMMON_H_ */ |
diff --git a/plugins/negate.c b/plugins/negate.c index b320e356..50f62d33 100644 --- a/plugins/negate.c +++ b/plugins/negate.c | |||
@@ -86,11 +86,9 @@ main (int argc, char **argv) | |||
86 | result = cmd_run_array (command_line, &chld_out, &chld_err, 0); | 86 | result = cmd_run_array (command_line, &chld_out, &chld_err, 0); |
87 | } | 87 | } |
88 | if (chld_err.lines > 0) { | 88 | if (chld_err.lines > 0) { |
89 | printf ("Error output from command:\n"); | ||
90 | for (i = 0; i < chld_err.lines; i++) { | 89 | for (i = 0; i < chld_err.lines; i++) { |
91 | printf ("%s\n", chld_err.line[i]); | 90 | fprintf (stderr, "%s\n", chld_err.line[i]); |
92 | } | 91 | } |
93 | exit (STATE_WARNING); | ||
94 | } | 92 | } |
95 | 93 | ||
96 | /* Return UNKNOWN or worse if no output is returned */ | 94 | /* Return UNKNOWN or worse if no output is returned */ |
diff --git a/plugins/picohttpparser/Makefile.am b/plugins/picohttpparser/Makefile.am new file mode 100644 index 00000000..87e05313 --- /dev/null +++ b/plugins/picohttpparser/Makefile.am | |||
@@ -0,0 +1,3 @@ | |||
1 | noinst_LIBRARIES = libpicohttpparser.a | ||
2 | |||
3 | libpicohttpparser_a_SOURCES = picohttpparser.c picohttpparser.h | ||
diff --git a/plugins/picohttpparser/picohttpparser.c b/plugins/picohttpparser/picohttpparser.c new file mode 100644 index 00000000..74ccc3ef --- /dev/null +++ b/plugins/picohttpparser/picohttpparser.c | |||
@@ -0,0 +1,645 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2009-2014 Kazuho Oku, Tokuhiro Matsuno, Daisuke Murase, | ||
3 | * Shigeo Mitsunari | ||
4 | * | ||
5 | * The software is licensed under either the MIT License (below) or the Perl | ||
6 | * license. | ||
7 | * | ||
8 | * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
9 | * of this software and associated documentation files (the "Software"), to | ||
10 | * deal in the Software without restriction, including without limitation the | ||
11 | * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | ||
12 | * sell copies of the Software, and to permit persons to whom the Software is | ||
13 | * furnished to do so, subject to the following conditions: | ||
14 | * | ||
15 | * The above copyright notice and this permission notice shall be included in | ||
16 | * all copies or substantial portions of the Software. | ||
17 | * | ||
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
21 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
22 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | ||
23 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | ||
24 | * IN THE SOFTWARE. | ||
25 | */ | ||
26 | |||
27 | #include <assert.h> | ||
28 | #include <stddef.h> | ||
29 | #include <string.h> | ||
30 | #ifdef __SSE4_2__ | ||
31 | #ifdef _MSC_VER | ||
32 | #include <nmmintrin.h> | ||
33 | #else | ||
34 | #include <x86intrin.h> | ||
35 | #endif | ||
36 | #endif | ||
37 | #include "picohttpparser.h" | ||
38 | |||
39 | #if __GNUC__ >= 3 | ||
40 | #define likely(x) __builtin_expect(!!(x), 1) | ||
41 | #define unlikely(x) __builtin_expect(!!(x), 0) | ||
42 | #else | ||
43 | #define likely(x) (x) | ||
44 | #define unlikely(x) (x) | ||
45 | #endif | ||
46 | |||
47 | #ifdef _MSC_VER | ||
48 | #define ALIGNED(n) _declspec(align(n)) | ||
49 | #else | ||
50 | #define ALIGNED(n) __attribute__((aligned(n))) | ||
51 | #endif | ||
52 | |||
53 | #define IS_PRINTABLE_ASCII(c) ((unsigned char)(c)-040u < 0137u) | ||
54 | |||
55 | #define CHECK_EOF() \ | ||
56 | if (buf == buf_end) { \ | ||
57 | *ret = -2; \ | ||
58 | return NULL; \ | ||
59 | } | ||
60 | |||
61 | #define EXPECT_CHAR_NO_CHECK(ch) \ | ||
62 | if (*buf++ != ch) { \ | ||
63 | *ret = -1; \ | ||
64 | return NULL; \ | ||
65 | } | ||
66 | |||
67 | #define EXPECT_CHAR(ch) \ | ||
68 | CHECK_EOF(); \ | ||
69 | EXPECT_CHAR_NO_CHECK(ch); | ||
70 | |||
71 | #define ADVANCE_TOKEN(tok, toklen) \ | ||
72 | do { \ | ||
73 | const char *tok_start = buf; \ | ||
74 | static const char ALIGNED(16) ranges2[16] = "\000\040\177\177"; \ | ||
75 | int found2; \ | ||
76 | buf = findchar_fast(buf, buf_end, ranges2, 4, &found2); \ | ||
77 | if (!found2) { \ | ||
78 | CHECK_EOF(); \ | ||
79 | } \ | ||
80 | while (1) { \ | ||
81 | if (*buf == ' ') { \ | ||
82 | break; \ | ||
83 | } else if (unlikely(!IS_PRINTABLE_ASCII(*buf))) { \ | ||
84 | if ((unsigned char)*buf < '\040' || *buf == '\177') { \ | ||
85 | *ret = -1; \ | ||
86 | return NULL; \ | ||
87 | } \ | ||
88 | } \ | ||
89 | ++buf; \ | ||
90 | CHECK_EOF(); \ | ||
91 | } \ | ||
92 | tok = tok_start; \ | ||
93 | toklen = buf - tok_start; \ | ||
94 | } while (0) | ||
95 | |||
96 | static const char *token_char_map = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" | ||
97 | "\0\1\0\1\1\1\1\1\0\0\1\1\0\1\1\0\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0" | ||
98 | "\0\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\1\1" | ||
99 | "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\1\0\1\0" | ||
100 | "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" | ||
101 | "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" | ||
102 | "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" | ||
103 | "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; | ||
104 | |||
105 | static const char *findchar_fast(const char *buf, const char *buf_end, const char *ranges, size_t ranges_size, int *found) | ||
106 | { | ||
107 | *found = 0; | ||
108 | #if __SSE4_2__ | ||
109 | if (likely(buf_end - buf >= 16)) { | ||
110 | __m128i ranges16 = _mm_loadu_si128((const __m128i *)ranges); | ||
111 | |||
112 | size_t left = (buf_end - buf) & ~15; | ||
113 | do { | ||
114 | __m128i b16 = _mm_loadu_si128((const __m128i *)buf); | ||
115 | int r = _mm_cmpestri(ranges16, ranges_size, b16, 16, _SIDD_LEAST_SIGNIFICANT | _SIDD_CMP_RANGES | _SIDD_UBYTE_OPS); | ||
116 | if (unlikely(r != 16)) { | ||
117 | buf += r; | ||
118 | *found = 1; | ||
119 | break; | ||
120 | } | ||
121 | buf += 16; | ||
122 | left -= 16; | ||
123 | } while (likely(left != 0)); | ||
124 | } | ||
125 | #else | ||
126 | /* suppress unused parameter warning */ | ||
127 | (void)buf_end; | ||
128 | (void)ranges; | ||
129 | (void)ranges_size; | ||
130 | #endif | ||
131 | return buf; | ||
132 | } | ||
133 | |||
134 | static const char *get_token_to_eol(const char *buf, const char *buf_end, const char **token, size_t *token_len, int *ret) | ||
135 | { | ||
136 | const char *token_start = buf; | ||
137 | |||
138 | #ifdef __SSE4_2__ | ||
139 | static const char ALIGNED(16) ranges1[16] = "\0\010" /* allow HT */ | ||
140 | "\012\037" /* allow SP and up to but not including DEL */ | ||
141 | "\177\177"; /* allow chars w. MSB set */ | ||
142 | int found; | ||
143 | buf = findchar_fast(buf, buf_end, ranges1, 6, &found); | ||
144 | if (found) | ||
145 | goto FOUND_CTL; | ||
146 | #else | ||
147 | /* find non-printable char within the next 8 bytes, this is the hottest code; manually inlined */ | ||
148 | while (likely(buf_end - buf >= 8)) { | ||
149 | #define DOIT() \ | ||
150 | do { \ | ||
151 | if (unlikely(!IS_PRINTABLE_ASCII(*buf))) \ | ||
152 | goto NonPrintable; \ | ||
153 | ++buf; \ | ||
154 | } while (0) | ||
155 | DOIT(); | ||
156 | DOIT(); | ||
157 | DOIT(); | ||
158 | DOIT(); | ||
159 | DOIT(); | ||
160 | DOIT(); | ||
161 | DOIT(); | ||
162 | DOIT(); | ||
163 | #undef DOIT | ||
164 | continue; | ||
165 | NonPrintable: | ||
166 | if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) { | ||
167 | goto FOUND_CTL; | ||
168 | } | ||
169 | ++buf; | ||
170 | } | ||
171 | #endif | ||
172 | for (;; ++buf) { | ||
173 | CHECK_EOF(); | ||
174 | if (unlikely(!IS_PRINTABLE_ASCII(*buf))) { | ||
175 | if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) { | ||
176 | goto FOUND_CTL; | ||
177 | } | ||
178 | } | ||
179 | } | ||
180 | FOUND_CTL: | ||
181 | if (likely(*buf == '\015')) { | ||
182 | ++buf; | ||
183 | EXPECT_CHAR('\012'); | ||
184 | *token_len = buf - 2 - token_start; | ||
185 | } else if (*buf == '\012') { | ||
186 | *token_len = buf - token_start; | ||
187 | ++buf; | ||
188 | } else { | ||
189 | *ret = -1; | ||
190 | return NULL; | ||
191 | } | ||
192 | *token = token_start; | ||
193 | |||
194 | return buf; | ||
195 | } | ||
196 | |||
197 | static const char *is_complete(const char *buf, const char *buf_end, size_t last_len, int *ret) | ||
198 | { | ||
199 | int ret_cnt = 0; | ||
200 | buf = last_len < 3 ? buf : buf + last_len - 3; | ||
201 | |||
202 | while (1) { | ||
203 | CHECK_EOF(); | ||
204 | if (*buf == '\015') { | ||
205 | ++buf; | ||
206 | CHECK_EOF(); | ||
207 | EXPECT_CHAR('\012'); | ||
208 | ++ret_cnt; | ||
209 | } else if (*buf == '\012') { | ||
210 | ++buf; | ||
211 | ++ret_cnt; | ||
212 | } else { | ||
213 | ++buf; | ||
214 | ret_cnt = 0; | ||
215 | } | ||
216 | if (ret_cnt == 2) { | ||
217 | return buf; | ||
218 | } | ||
219 | } | ||
220 | |||
221 | *ret = -2; | ||
222 | return NULL; | ||
223 | } | ||
224 | |||
225 | #define PARSE_INT(valp_, mul_) \ | ||
226 | if (*buf < '0' || '9' < *buf) { \ | ||
227 | buf++; \ | ||
228 | *ret = -1; \ | ||
229 | return NULL; \ | ||
230 | } \ | ||
231 | *(valp_) = (mul_) * (*buf++ - '0'); | ||
232 | |||
233 | #define PARSE_INT_3(valp_) \ | ||
234 | do { \ | ||
235 | int res_ = 0; \ | ||
236 | PARSE_INT(&res_, 100) \ | ||
237 | *valp_ = res_; \ | ||
238 | PARSE_INT(&res_, 10) \ | ||
239 | *valp_ += res_; \ | ||
240 | PARSE_INT(&res_, 1) \ | ||
241 | *valp_ += res_; \ | ||
242 | } while (0) | ||
243 | |||
244 | /* returned pointer is always within [buf, buf_end), or null */ | ||
245 | static const char *parse_http_version(const char *buf, const char *buf_end, int *minor_version, int *ret) | ||
246 | { | ||
247 | /* we want at least [HTTP/1.<two chars>] to try to parse */ | ||
248 | if (buf_end - buf < 9) { | ||
249 | *ret = -2; | ||
250 | return NULL; | ||
251 | } | ||
252 | EXPECT_CHAR_NO_CHECK('H'); | ||
253 | EXPECT_CHAR_NO_CHECK('T'); | ||
254 | EXPECT_CHAR_NO_CHECK('T'); | ||
255 | EXPECT_CHAR_NO_CHECK('P'); | ||
256 | EXPECT_CHAR_NO_CHECK('/'); | ||
257 | EXPECT_CHAR_NO_CHECK('1'); | ||
258 | EXPECT_CHAR_NO_CHECK('.'); | ||
259 | PARSE_INT(minor_version, 1); | ||
260 | return buf; | ||
261 | } | ||
262 | |||
263 | static const char *parse_headers(const char *buf, const char *buf_end, struct phr_header *headers, size_t *num_headers, | ||
264 | size_t max_headers, int *ret) | ||
265 | { | ||
266 | for (;; ++*num_headers) { | ||
267 | CHECK_EOF(); | ||
268 | if (*buf == '\015') { | ||
269 | ++buf; | ||
270 | EXPECT_CHAR('\012'); | ||
271 | break; | ||
272 | } else if (*buf == '\012') { | ||
273 | ++buf; | ||
274 | break; | ||
275 | } | ||
276 | if (*num_headers == max_headers) { | ||
277 | *ret = -1; | ||
278 | return NULL; | ||
279 | } | ||
280 | if (!(*num_headers != 0 && (*buf == ' ' || *buf == '\t'))) { | ||
281 | /* parsing name, but do not discard SP before colon, see | ||
282 | * http://www.mozilla.org/security/announce/2006/mfsa2006-33.html */ | ||
283 | headers[*num_headers].name = buf; | ||
284 | static const char ALIGNED(16) ranges1[] = "\x00 " /* control chars and up to SP */ | ||
285 | "\"\"" /* 0x22 */ | ||
286 | "()" /* 0x28,0x29 */ | ||
287 | ",," /* 0x2c */ | ||
288 | "//" /* 0x2f */ | ||
289 | ":@" /* 0x3a-0x40 */ | ||
290 | "[]" /* 0x5b-0x5d */ | ||
291 | "{\377"; /* 0x7b-0xff */ | ||
292 | int found; | ||
293 | buf = findchar_fast(buf, buf_end, ranges1, sizeof(ranges1) - 1, &found); | ||
294 | if (!found) { | ||
295 | CHECK_EOF(); | ||
296 | } | ||
297 | while (1) { | ||
298 | if (*buf == ':') { | ||
299 | break; | ||
300 | } else if (!token_char_map[(unsigned char)*buf]) { | ||
301 | *ret = -1; | ||
302 | return NULL; | ||
303 | } | ||
304 | ++buf; | ||
305 | CHECK_EOF(); | ||
306 | } | ||
307 | if ((headers[*num_headers].name_len = buf - headers[*num_headers].name) == 0) { | ||
308 | *ret = -1; | ||
309 | return NULL; | ||
310 | } | ||
311 | ++buf; | ||
312 | for (;; ++buf) { | ||
313 | CHECK_EOF(); | ||
314 | if (!(*buf == ' ' || *buf == '\t')) { | ||
315 | break; | ||
316 | } | ||
317 | } | ||
318 | } else { | ||
319 | headers[*num_headers].name = NULL; | ||
320 | headers[*num_headers].name_len = 0; | ||
321 | } | ||
322 | const char *value; | ||
323 | size_t value_len; | ||
324 | if ((buf = get_token_to_eol(buf, buf_end, &value, &value_len, ret)) == NULL) { | ||
325 | return NULL; | ||
326 | } | ||
327 | /* remove trailing SPs and HTABs */ | ||
328 | const char *value_end = value + value_len; | ||
329 | for (; value_end != value; --value_end) { | ||
330 | const char c = *(value_end - 1); | ||
331 | if (!(c == ' ' || c == '\t')) { | ||
332 | break; | ||
333 | } | ||
334 | } | ||
335 | headers[*num_headers].value = value; | ||
336 | headers[*num_headers].value_len = value_end - value; | ||
337 | } | ||
338 | return buf; | ||
339 | } | ||
340 | |||
341 | static const char *parse_request(const char *buf, const char *buf_end, const char **method, size_t *method_len, const char **path, | ||
342 | size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers, | ||
343 | size_t max_headers, int *ret) | ||
344 | { | ||
345 | /* skip first empty line (some clients add CRLF after POST content) */ | ||
346 | CHECK_EOF(); | ||
347 | if (*buf == '\015') { | ||
348 | ++buf; | ||
349 | EXPECT_CHAR('\012'); | ||
350 | } else if (*buf == '\012') { | ||
351 | ++buf; | ||
352 | } | ||
353 | |||
354 | /* parse request line */ | ||
355 | ADVANCE_TOKEN(*method, *method_len); | ||
356 | do { | ||
357 | ++buf; | ||
358 | } while (*buf == ' '); | ||
359 | ADVANCE_TOKEN(*path, *path_len); | ||
360 | do { | ||
361 | ++buf; | ||
362 | } while (*buf == ' '); | ||
363 | if (*method_len == 0 || *path_len == 0) { | ||
364 | *ret = -1; | ||
365 | return NULL; | ||
366 | } | ||
367 | if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) { | ||
368 | return NULL; | ||
369 | } | ||
370 | if (*buf == '\015') { | ||
371 | ++buf; | ||
372 | EXPECT_CHAR('\012'); | ||
373 | } else if (*buf == '\012') { | ||
374 | ++buf; | ||
375 | } else { | ||
376 | *ret = -1; | ||
377 | return NULL; | ||
378 | } | ||
379 | |||
380 | return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret); | ||
381 | } | ||
382 | |||
383 | int phr_parse_request(const char *buf_start, size_t len, const char **method, size_t *method_len, const char **path, | ||
384 | size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers, size_t last_len) | ||
385 | { | ||
386 | const char *buf = buf_start, *buf_end = buf_start + len; | ||
387 | size_t max_headers = *num_headers; | ||
388 | int r; | ||
389 | |||
390 | *method = NULL; | ||
391 | *method_len = 0; | ||
392 | *path = NULL; | ||
393 | *path_len = 0; | ||
394 | *minor_version = -1; | ||
395 | *num_headers = 0; | ||
396 | |||
397 | /* if last_len != 0, check if the request is complete (a fast countermeasure | ||
398 | againt slowloris */ | ||
399 | if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) { | ||
400 | return r; | ||
401 | } | ||
402 | |||
403 | if ((buf = parse_request(buf, buf_end, method, method_len, path, path_len, minor_version, headers, num_headers, max_headers, | ||
404 | &r)) == NULL) { | ||
405 | return r; | ||
406 | } | ||
407 | |||
408 | return (int)(buf - buf_start); | ||
409 | } | ||
410 | |||
411 | static const char *parse_response(const char *buf, const char *buf_end, int *minor_version, int *status, const char **msg, | ||
412 | size_t *msg_len, struct phr_header *headers, size_t *num_headers, size_t max_headers, int *ret) | ||
413 | { | ||
414 | /* parse "HTTP/1.x" */ | ||
415 | if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) { | ||
416 | return NULL; | ||
417 | } | ||
418 | /* skip space */ | ||
419 | if (*buf != ' ') { | ||
420 | *ret = -1; | ||
421 | return NULL; | ||
422 | } | ||
423 | do { | ||
424 | ++buf; | ||
425 | } while (*buf == ' '); | ||
426 | /* parse status code, we want at least [:digit:][:digit:][:digit:]<other char> to try to parse */ | ||
427 | if (buf_end - buf < 4) { | ||
428 | *ret = -2; | ||
429 | return NULL; | ||
430 | } | ||
431 | PARSE_INT_3(status); | ||
432 | |||
433 | /* get message includig preceding space */ | ||
434 | if ((buf = get_token_to_eol(buf, buf_end, msg, msg_len, ret)) == NULL) { | ||
435 | return NULL; | ||
436 | } | ||
437 | if (*msg_len == 0) { | ||
438 | /* ok */ | ||
439 | } else if (**msg == ' ') { | ||
440 | /* remove preceding space */ | ||
441 | do { | ||
442 | ++*msg; | ||
443 | --*msg_len; | ||
444 | } while (**msg == ' '); | ||
445 | } else { | ||
446 | /* garbage found after status code */ | ||
447 | *ret = -1; | ||
448 | return NULL; | ||
449 | } | ||
450 | |||
451 | return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret); | ||
452 | } | ||
453 | |||
454 | int phr_parse_response(const char *buf_start, size_t len, int *minor_version, int *status, const char **msg, size_t *msg_len, | ||
455 | struct phr_header *headers, size_t *num_headers, size_t last_len) | ||
456 | { | ||
457 | const char *buf = buf_start, *buf_end = buf + len; | ||
458 | size_t max_headers = *num_headers; | ||
459 | int r; | ||
460 | |||
461 | *minor_version = -1; | ||
462 | *status = 0; | ||
463 | *msg = NULL; | ||
464 | *msg_len = 0; | ||
465 | *num_headers = 0; | ||
466 | |||
467 | /* if last_len != 0, check if the response is complete (a fast countermeasure | ||
468 | against slowloris */ | ||
469 | if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) { | ||
470 | return r; | ||
471 | } | ||
472 | |||
473 | if ((buf = parse_response(buf, buf_end, minor_version, status, msg, msg_len, headers, num_headers, max_headers, &r)) == NULL) { | ||
474 | return r; | ||
475 | } | ||
476 | |||
477 | return (int)(buf - buf_start); | ||
478 | } | ||
479 | |||
480 | int phr_parse_headers(const char *buf_start, size_t len, struct phr_header *headers, size_t *num_headers, size_t last_len) | ||
481 | { | ||
482 | const char *buf = buf_start, *buf_end = buf + len; | ||
483 | size_t max_headers = *num_headers; | ||
484 | int r; | ||
485 | |||
486 | *num_headers = 0; | ||
487 | |||
488 | /* if last_len != 0, check if the response is complete (a fast countermeasure | ||
489 | against slowloris */ | ||
490 | if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) { | ||
491 | return r; | ||
492 | } | ||
493 | |||
494 | if ((buf = parse_headers(buf, buf_end, headers, num_headers, max_headers, &r)) == NULL) { | ||
495 | return r; | ||
496 | } | ||
497 | |||
498 | return (int)(buf - buf_start); | ||
499 | } | ||
500 | |||
501 | enum { | ||
502 | CHUNKED_IN_CHUNK_SIZE, | ||
503 | CHUNKED_IN_CHUNK_EXT, | ||
504 | CHUNKED_IN_CHUNK_DATA, | ||
505 | CHUNKED_IN_CHUNK_CRLF, | ||
506 | CHUNKED_IN_TRAILERS_LINE_HEAD, | ||
507 | CHUNKED_IN_TRAILERS_LINE_MIDDLE | ||
508 | }; | ||
509 | |||
510 | static int decode_hex(int ch) | ||
511 | { | ||
512 | if ('0' <= ch && ch <= '9') { | ||
513 | return ch - '0'; | ||
514 | } else if ('A' <= ch && ch <= 'F') { | ||
515 | return ch - 'A' + 0xa; | ||
516 | } else if ('a' <= ch && ch <= 'f') { | ||
517 | return ch - 'a' + 0xa; | ||
518 | } else { | ||
519 | return -1; | ||
520 | } | ||
521 | } | ||
522 | |||
523 | ssize_t phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf, size_t *_bufsz) | ||
524 | { | ||
525 | size_t dst = 0, src = 0, bufsz = *_bufsz; | ||
526 | ssize_t ret = -2; /* incomplete */ | ||
527 | |||
528 | while (1) { | ||
529 | switch (decoder->_state) { | ||
530 | case CHUNKED_IN_CHUNK_SIZE: | ||
531 | for (;; ++src) { | ||
532 | int v; | ||
533 | if (src == bufsz) | ||
534 | goto Exit; | ||
535 | if ((v = decode_hex(buf[src])) == -1) { | ||
536 | if (decoder->_hex_count == 0) { | ||
537 | ret = -1; | ||
538 | goto Exit; | ||
539 | } | ||
540 | break; | ||
541 | } | ||
542 | if (decoder->_hex_count == sizeof(size_t) * 2) { | ||
543 | ret = -1; | ||
544 | goto Exit; | ||
545 | } | ||
546 | decoder->bytes_left_in_chunk = decoder->bytes_left_in_chunk * 16 + v; | ||
547 | ++decoder->_hex_count; | ||
548 | } | ||
549 | decoder->_hex_count = 0; | ||
550 | decoder->_state = CHUNKED_IN_CHUNK_EXT; | ||
551 | /* fallthru */ | ||
552 | case CHUNKED_IN_CHUNK_EXT: | ||
553 | /* RFC 7230 A.2 "Line folding in chunk extensions is disallowed" */ | ||
554 | for (;; ++src) { | ||
555 | if (src == bufsz) | ||
556 | goto Exit; | ||
557 | if (buf[src] == '\012') | ||
558 | break; | ||
559 | } | ||
560 | ++src; | ||
561 | if (decoder->bytes_left_in_chunk == 0) { | ||
562 | if (decoder->consume_trailer) { | ||
563 | decoder->_state = CHUNKED_IN_TRAILERS_LINE_HEAD; | ||
564 | break; | ||
565 | } else { | ||
566 | goto Complete; | ||
567 | } | ||
568 | } | ||
569 | decoder->_state = CHUNKED_IN_CHUNK_DATA; | ||
570 | /* fallthru */ | ||
571 | case CHUNKED_IN_CHUNK_DATA: { | ||
572 | size_t avail = bufsz - src; | ||
573 | if (avail < decoder->bytes_left_in_chunk) { | ||
574 | if (dst != src) | ||
575 | memmove(buf + dst, buf + src, avail); | ||
576 | src += avail; | ||
577 | dst += avail; | ||
578 | decoder->bytes_left_in_chunk -= avail; | ||
579 | goto Exit; | ||
580 | } | ||
581 | if (dst != src) | ||
582 | memmove(buf + dst, buf + src, decoder->bytes_left_in_chunk); | ||
583 | src += decoder->bytes_left_in_chunk; | ||
584 | dst += decoder->bytes_left_in_chunk; | ||
585 | decoder->bytes_left_in_chunk = 0; | ||
586 | decoder->_state = CHUNKED_IN_CHUNK_CRLF; | ||
587 | } | ||
588 | /* fallthru */ | ||
589 | case CHUNKED_IN_CHUNK_CRLF: | ||
590 | for (;; ++src) { | ||
591 | if (src == bufsz) | ||
592 | goto Exit; | ||
593 | if (buf[src] != '\015') | ||
594 | break; | ||
595 | } | ||
596 | if (buf[src] != '\012') { | ||
597 | ret = -1; | ||
598 | goto Exit; | ||
599 | } | ||
600 | ++src; | ||
601 | decoder->_state = CHUNKED_IN_CHUNK_SIZE; | ||
602 | break; | ||
603 | case CHUNKED_IN_TRAILERS_LINE_HEAD: | ||
604 | for (;; ++src) { | ||
605 | if (src == bufsz) | ||
606 | goto Exit; | ||
607 | if (buf[src] != '\015') | ||
608 | break; | ||
609 | } | ||
610 | if (buf[src++] == '\012') | ||
611 | goto Complete; | ||
612 | decoder->_state = CHUNKED_IN_TRAILERS_LINE_MIDDLE; | ||
613 | /* fallthru */ | ||
614 | case CHUNKED_IN_TRAILERS_LINE_MIDDLE: | ||
615 | for (;; ++src) { | ||
616 | if (src == bufsz) | ||
617 | goto Exit; | ||
618 | if (buf[src] == '\012') | ||
619 | break; | ||
620 | } | ||
621 | ++src; | ||
622 | decoder->_state = CHUNKED_IN_TRAILERS_LINE_HEAD; | ||
623 | break; | ||
624 | default: | ||
625 | assert(!"decoder is corrupt"); | ||
626 | } | ||
627 | } | ||
628 | |||
629 | Complete: | ||
630 | ret = bufsz - src; | ||
631 | Exit: | ||
632 | if (dst != src) | ||
633 | memmove(buf + dst, buf + src, bufsz - src); | ||
634 | *_bufsz = dst; | ||
635 | return ret; | ||
636 | } | ||
637 | |||
638 | int phr_decode_chunked_is_in_data(struct phr_chunked_decoder *decoder) | ||
639 | { | ||
640 | return decoder->_state == CHUNKED_IN_CHUNK_DATA; | ||
641 | } | ||
642 | |||
643 | #undef CHECK_EOF | ||
644 | #undef EXPECT_CHAR | ||
645 | #undef ADVANCE_TOKEN | ||
diff --git a/plugins/picohttpparser/picohttpparser.h b/plugins/picohttpparser/picohttpparser.h new file mode 100644 index 00000000..0849f844 --- /dev/null +++ b/plugins/picohttpparser/picohttpparser.h | |||
@@ -0,0 +1,87 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2009-2014 Kazuho Oku, Tokuhiro Matsuno, Daisuke Murase, | ||
3 | * Shigeo Mitsunari | ||
4 | * | ||
5 | * The software is licensed under either the MIT License (below) or the Perl | ||
6 | * license. | ||
7 | * | ||
8 | * Permission is hereby granted, free of charge, to any person obtaining a copy | ||
9 | * of this software and associated documentation files (the "Software"), to | ||
10 | * deal in the Software without restriction, including without limitation the | ||
11 | * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or | ||
12 | * sell copies of the Software, and to permit persons to whom the Software is | ||
13 | * furnished to do so, subject to the following conditions: | ||
14 | * | ||
15 | * The above copyright notice and this permission notice shall be included in | ||
16 | * all copies or substantial portions of the Software. | ||
17 | * | ||
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
21 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
22 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | ||
23 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | ||
24 | * IN THE SOFTWARE. | ||
25 | */ | ||
26 | |||
27 | #ifndef picohttpparser_h | ||
28 | #define picohttpparser_h | ||
29 | |||
30 | #include <sys/types.h> | ||
31 | |||
32 | #ifdef _MSC_VER | ||
33 | #define ssize_t intptr_t | ||
34 | #endif | ||
35 | |||
36 | #ifdef __cplusplus | ||
37 | extern "C" { | ||
38 | #endif | ||
39 | |||
40 | /* contains name and value of a header (name == NULL if is a continuing line | ||
41 | * of a multiline header */ | ||
42 | struct phr_header { | ||
43 | const char *name; | ||
44 | size_t name_len; | ||
45 | const char *value; | ||
46 | size_t value_len; | ||
47 | }; | ||
48 | |||
49 | /* returns number of bytes consumed if successful, -2 if request is partial, | ||
50 | * -1 if failed */ | ||
51 | int phr_parse_request(const char *buf, size_t len, const char **method, size_t *method_len, const char **path, size_t *path_len, | ||
52 | int *minor_version, struct phr_header *headers, size_t *num_headers, size_t last_len); | ||
53 | |||
54 | /* ditto */ | ||
55 | int phr_parse_response(const char *_buf, size_t len, int *minor_version, int *status, const char **msg, size_t *msg_len, | ||
56 | struct phr_header *headers, size_t *num_headers, size_t last_len); | ||
57 | |||
58 | /* ditto */ | ||
59 | int phr_parse_headers(const char *buf, size_t len, struct phr_header *headers, size_t *num_headers, size_t last_len); | ||
60 | |||
61 | /* should be zero-filled before start */ | ||
62 | struct phr_chunked_decoder { | ||
63 | size_t bytes_left_in_chunk; /* number of bytes left in current chunk */ | ||
64 | char consume_trailer; /* if trailing headers should be consumed */ | ||
65 | char _hex_count; | ||
66 | char _state; | ||
67 | }; | ||
68 | |||
69 | /* the function rewrites the buffer given as (buf, bufsz) removing the chunked- | ||
70 | * encoding headers. When the function returns without an error, bufsz is | ||
71 | * updated to the length of the decoded data available. Applications should | ||
72 | * repeatedly call the function while it returns -2 (incomplete) every time | ||
73 | * supplying newly arrived data. If the end of the chunked-encoded data is | ||
74 | * found, the function returns a non-negative number indicating the number of | ||
75 | * octets left undecoded at the tail of the supplied buffer. Returns -1 on | ||
76 | * error. | ||
77 | */ | ||
78 | ssize_t phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf, size_t *bufsz); | ||
79 | |||
80 | /* returns if the chunked decoder is in middle of chunked data */ | ||
81 | int phr_decode_chunked_is_in_data(struct phr_chunked_decoder *decoder); | ||
82 | |||
83 | #ifdef __cplusplus | ||
84 | } | ||
85 | #endif | ||
86 | |||
87 | #endif | ||
diff --git a/plugins/popen.c b/plugins/popen.c index 592263fd..9eb49b62 100644 --- a/plugins/popen.c +++ b/plugins/popen.c | |||
@@ -39,9 +39,9 @@ | |||
39 | *****************************************************************************/ | 39 | *****************************************************************************/ |
40 | 40 | ||
41 | #include "common.h" | 41 | #include "common.h" |
42 | #include "utils.h" | ||
42 | 43 | ||
43 | /* extern so plugin has pid to kill exec'd process on timeouts */ | 44 | /* extern so plugin has pid to kill exec'd process on timeouts */ |
44 | extern int timeout_interval; | ||
45 | extern pid_t *childpid; | 45 | extern pid_t *childpid; |
46 | extern int *child_stderr_array; | 46 | extern int *child_stderr_array; |
47 | extern FILE *child_process; | 47 | extern FILE *child_process; |
@@ -76,18 +76,9 @@ RETSIGTYPE popen_timeout_alarm_handler (int); | |||
76 | #define SIG_ERR ((Sigfunc *)-1) | 76 | #define SIG_ERR ((Sigfunc *)-1) |
77 | #endif | 77 | #endif |
78 | 78 | ||
79 | #define min(a,b) ((a) < (b) ? (a) : (b)) | ||
80 | #define max(a,b) ((a) > (b) ? (a) : (b)) | ||
81 | int open_max (void); /* {Prog openmax} */ | ||
82 | static void err_sys (const char *, ...) __attribute__((noreturn,format(printf, 1, 2))); | ||
83 | char *rtrim (char *, const char *); | ||
84 | 79 | ||
85 | char *pname = NULL; /* caller can set this from argv[0] */ | 80 | char *pname = NULL; /* caller can set this from argv[0] */ |
86 | 81 | ||
87 | /*int *childerr = NULL;*//* ptr to array allocated at run-time */ | ||
88 | /*extern pid_t *childpid = NULL; *//* ptr to array allocated at run-time */ | ||
89 | static int maxfd; /* from our open_max(), {Prog openmax} */ | ||
90 | |||
91 | #ifdef REDHAT_SPOPEN_ERROR | 82 | #ifdef REDHAT_SPOPEN_ERROR |
92 | static volatile int childtermd = 0; | 83 | static volatile int childtermd = 0; |
93 | #endif | 84 | #endif |
@@ -186,14 +177,15 @@ spopen (const char *cmdstring) | |||
186 | } | 177 | } |
187 | argv[i] = NULL; | 178 | argv[i] = NULL; |
188 | 179 | ||
180 | if(maxfd == 0) | ||
181 | maxfd = open_max(); | ||
182 | |||
189 | if (childpid == NULL) { /* first time through */ | 183 | if (childpid == NULL) { /* first time through */ |
190 | maxfd = open_max (); /* allocate zeroed out array for child pids */ | ||
191 | if ((childpid = calloc ((size_t)maxfd, sizeof (pid_t))) == NULL) | 184 | if ((childpid = calloc ((size_t)maxfd, sizeof (pid_t))) == NULL) |
192 | return (NULL); | 185 | return (NULL); |
193 | } | 186 | } |
194 | 187 | ||
195 | if (child_stderr_array == NULL) { /* first time through */ | 188 | if (child_stderr_array == NULL) { /* first time through */ |
196 | maxfd = open_max (); /* allocate zeroed out array for child pids */ | ||
197 | if ((child_stderr_array = calloc ((size_t)maxfd, sizeof (int))) == NULL) | 189 | if ((child_stderr_array = calloc ((size_t)maxfd, sizeof (int))) == NULL) |
198 | return (NULL); | 190 | return (NULL); |
199 | } | 191 | } |
@@ -273,15 +265,6 @@ spclose (FILE * fp) | |||
273 | return (1); | 265 | return (1); |
274 | } | 266 | } |
275 | 267 | ||
276 | #ifdef OPEN_MAX | ||
277 | static int openmax = OPEN_MAX; | ||
278 | #else | ||
279 | static int openmax = 0; | ||
280 | #endif | ||
281 | |||
282 | #define OPEN_MAX_GUESS 256 /* if OPEN_MAX is indeterminate */ | ||
283 | /* no guarantee this is adequate */ | ||
284 | |||
285 | #ifdef REDHAT_SPOPEN_ERROR | 268 | #ifdef REDHAT_SPOPEN_ERROR |
286 | RETSIGTYPE | 269 | RETSIGTYPE |
287 | popen_sigchld_handler (int signo) | 270 | popen_sigchld_handler (int signo) |
@@ -309,63 +292,3 @@ popen_timeout_alarm_handler (int signo) | |||
309 | exit (STATE_CRITICAL); | 292 | exit (STATE_CRITICAL); |
310 | } | 293 | } |
311 | } | 294 | } |
312 | |||
313 | |||
314 | int | ||
315 | open_max (void) | ||
316 | { | ||
317 | if (openmax == 0) { /* first time through */ | ||
318 | errno = 0; | ||
319 | if ((openmax = sysconf (_SC_OPEN_MAX)) < 0) { | ||
320 | if (errno == 0) | ||
321 | openmax = OPEN_MAX_GUESS; /* it's indeterminate */ | ||
322 | else | ||
323 | err_sys (_("sysconf error for _SC_OPEN_MAX")); | ||
324 | } | ||
325 | } | ||
326 | return (openmax); | ||
327 | } | ||
328 | |||
329 | |||
330 | /* Fatal error related to a system call. | ||
331 | * Print a message and die. */ | ||
332 | |||
333 | #define MAXLINE 2048 | ||
334 | static void | ||
335 | err_sys (const char *fmt, ...) | ||
336 | { | ||
337 | int errnoflag = 1; | ||
338 | int errno_save; | ||
339 | char buf[MAXLINE]; | ||
340 | |||
341 | va_list ap; | ||
342 | |||
343 | va_start (ap, fmt); | ||
344 | /* err_doit (1, fmt, ap); */ | ||
345 | errno_save = errno; /* value caller might want printed */ | ||
346 | vsprintf (buf, fmt, ap); | ||
347 | if (errnoflag) | ||
348 | sprintf (buf + strlen (buf), ": %s", strerror (errno_save)); | ||
349 | strcat (buf, "\n"); | ||
350 | fflush (stdout); /* in case stdout and stderr are the same */ | ||
351 | fputs (buf, stderr); | ||
352 | fflush (NULL); /* flushes all stdio output streams */ | ||
353 | va_end (ap); | ||
354 | exit (1); | ||
355 | } | ||
356 | |||
357 | char * | ||
358 | rtrim (char *str, const char *tok) | ||
359 | { | ||
360 | int i = 0; | ||
361 | int j = sizeof (str); | ||
362 | |||
363 | while (str != NULL && i < j) { | ||
364 | if (*(str + i) == *tok) { | ||
365 | sprintf (str + i, "%s", "\0"); | ||
366 | return str; | ||
367 | } | ||
368 | i++; | ||
369 | } | ||
370 | return str; | ||
371 | } | ||
diff --git a/plugins/popen.h b/plugins/popen.h index fc7e78e2..a5dd8fa7 100644 --- a/plugins/popen.h +++ b/plugins/popen.h | |||
@@ -7,7 +7,6 @@ FILE *spopen (const char *); | |||
7 | int spclose (FILE *); | 7 | int spclose (FILE *); |
8 | RETSIGTYPE popen_timeout_alarm_handler (int); | 8 | RETSIGTYPE popen_timeout_alarm_handler (int); |
9 | 9 | ||
10 | extern unsigned int timeout_interval; | ||
11 | pid_t *childpid=NULL; | 10 | pid_t *childpid=NULL; |
12 | int *child_stderr_array=NULL; | 11 | int *child_stderr_array=NULL; |
13 | FILE *child_process=NULL; | 12 | FILE *child_process=NULL; |
diff --git a/plugins/runcmd.c b/plugins/runcmd.c index 1a7c904f..a7155d27 100644 --- a/plugins/runcmd.c +++ b/plugins/runcmd.c | |||
@@ -67,19 +67,6 @@ | |||
67 | * occur in any number of threads simultaneously. */ | 67 | * occur in any number of threads simultaneously. */ |
68 | static pid_t *np_pids = NULL; | 68 | static pid_t *np_pids = NULL; |
69 | 69 | ||
70 | /* Try sysconf(_SC_OPEN_MAX) first, as it can be higher than OPEN_MAX. | ||
71 | * If that fails and the macro isn't defined, we fall back to an educated | ||
72 | * guess. There's no guarantee that our guess is adequate and the program | ||
73 | * will die with SIGSEGV if it isn't and the upper boundary is breached. */ | ||
74 | #ifdef _SC_OPEN_MAX | ||
75 | static long maxfd = 0; | ||
76 | #elif defined(OPEN_MAX) | ||
77 | # define maxfd OPEN_MAX | ||
78 | #else /* sysconf macro unavailable, so guess (may be wildly inaccurate) */ | ||
79 | # define maxfd 256 | ||
80 | #endif | ||
81 | |||
82 | |||
83 | /** prototypes **/ | 70 | /** prototypes **/ |
84 | static int np_runcmd_open(const char *, int *, int *) | 71 | static int np_runcmd_open(const char *, int *, int *) |
85 | __attribute__((__nonnull__(1, 2, 3))); | 72 | __attribute__((__nonnull__(1, 2, 3))); |
@@ -99,14 +86,8 @@ extern void die (int, const char *, ...) | |||
99 | * through this api and thus achieve async-safeness throughout the api */ | 86 | * through this api and thus achieve async-safeness throughout the api */ |
100 | void np_runcmd_init(void) | 87 | void np_runcmd_init(void) |
101 | { | 88 | { |
102 | #ifndef maxfd | 89 | if(maxfd == 0) |
103 | if(!maxfd && (maxfd = sysconf(_SC_OPEN_MAX)) < 0) { | 90 | maxfd = open_max(); |
104 | /* possibly log or emit a warning here, since there's no | ||
105 | * guarantee that our guess at maxfd will be adequate */ | ||
106 | maxfd = 256; | ||
107 | } | ||
108 | #endif | ||
109 | |||
110 | if(!np_pids) np_pids = calloc(maxfd, sizeof(pid_t)); | 91 | if(!np_pids) np_pids = calloc(maxfd, sizeof(pid_t)); |
111 | } | 92 | } |
112 | 93 | ||
diff --git a/plugins/sslutils.c b/plugins/sslutils.c index e38947e3..14f6579d 100644 --- a/plugins/sslutils.c +++ b/plugins/sslutils.c | |||
@@ -1,29 +1,29 @@ | |||
1 | /***************************************************************************** | 1 | /***************************************************************************** |
2 | * | 2 | * |
3 | * Monitoring Plugins SSL utilities | 3 | * Monitoring Plugins SSL utilities |
4 | * | 4 | * |
5 | * License: GPL | 5 | * License: GPL |
6 | * Copyright (c) 2005-2010 Monitoring Plugins Development Team | 6 | * Copyright (c) 2005-2010 Monitoring Plugins Development Team |
7 | * | 7 | * |
8 | * Description: | 8 | * Description: |
9 | * | 9 | * |
10 | * This file contains common functions for plugins that require SSL. | 10 | * This file contains common functions for plugins that require SSL. |
11 | * | 11 | * |
12 | * | 12 | * |
13 | * This program is free software: you can redistribute it and/or modify | 13 | * This program is free software: you can redistribute it and/or modify |
14 | * it under the terms of the GNU General Public License as published by | 14 | * it under the terms of the GNU General Public License as published by |
15 | * the Free Software Foundation, either version 3 of the License, or | 15 | * the Free Software Foundation, either version 3 of the License, or |
16 | * (at your option) any later version. | 16 | * (at your option) any later version. |
17 | * | 17 | * |
18 | * This program is distributed in the hope that it will be useful, | 18 | * This program is distributed in the hope that it will be useful, |
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | 19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | 20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
21 | * GNU General Public License for more details. | 21 | * GNU General Public License for more details. |
22 | * | 22 | * |
23 | * You should have received a copy of the GNU General Public License | 23 | * You should have received a copy of the GNU General Public License |
24 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | 24 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
25 | * | 25 | * |
26 | * | 26 | * |
27 | *****************************************************************************/ | 27 | *****************************************************************************/ |
28 | 28 | ||
29 | #define MAX_CN_LENGTH 256 | 29 | #define MAX_CN_LENGTH 256 |
@@ -193,12 +193,22 @@ int np_net_ssl_read(void *buf, int num) { | |||
193 | 193 | ||
194 | int np_net_ssl_check_cert(int days_till_exp_warn, int days_till_exp_crit){ | 194 | int np_net_ssl_check_cert(int days_till_exp_warn, int days_till_exp_crit){ |
195 | # ifdef USE_OPENSSL | 195 | # ifdef USE_OPENSSL |
196 | X509 *certificate=NULL; | 196 | X509 *certificate = NULL; |
197 | certificate=SSL_get_peer_certificate(s); | ||
198 | return(np_net_ssl_check_certificate(certificate, days_till_exp_warn, days_till_exp_crit)); | ||
199 | # else /* ifndef USE_OPENSSL */ | ||
200 | printf("%s\n", _("WARNING - Plugin does not support checking certificates.")); | ||
201 | return STATE_WARNING; | ||
202 | # endif /* USE_OPENSSL */ | ||
203 | } | ||
204 | |||
205 | int np_net_ssl_check_certificate(X509 *certificate, int days_till_exp_warn, int days_till_exp_crit){ | ||
206 | # ifdef USE_OPENSSL | ||
197 | X509_NAME *subj=NULL; | 207 | X509_NAME *subj=NULL; |
198 | char timestamp[50] = ""; | 208 | char timestamp[50] = ""; |
199 | char cn[MAX_CN_LENGTH]= ""; | 209 | char cn[MAX_CN_LENGTH]= ""; |
200 | char *tz; | 210 | char *tz; |
201 | 211 | ||
202 | int cnlen =-1; | 212 | int cnlen =-1; |
203 | int status=STATE_UNKNOWN; | 213 | int status=STATE_UNKNOWN; |
204 | 214 | ||
@@ -210,7 +220,6 @@ int np_net_ssl_check_cert(int days_till_exp_warn, int days_till_exp_crit){ | |||
210 | int time_remaining; | 220 | int time_remaining; |
211 | time_t tm_t; | 221 | time_t tm_t; |
212 | 222 | ||
213 | certificate=SSL_get_peer_certificate(s); | ||
214 | if (!certificate) { | 223 | if (!certificate) { |
215 | printf("%s\n",_("CRITICAL - Cannot retrieve server certificate.")); | 224 | printf("%s\n",_("CRITICAL - Cannot retrieve server certificate.")); |
216 | return STATE_CRITICAL; | 225 | return STATE_CRITICAL; |
diff --git a/plugins/t/NPTest.cache.travis b/plugins/t/NPTest.cache.travis deleted file mode 100644 index e9705f3b..00000000 --- a/plugins/t/NPTest.cache.travis +++ /dev/null | |||
@@ -1,62 +0,0 @@ | |||
1 | { | ||
2 | 'MYSQL_LOGIN_DETAILS' => '-u root -d test', | ||
3 | 'NP_ALLOW_SUDO' => 'yes', | ||
4 | 'NP_DNS_SERVER' => '8.8.8.8', | ||
5 | 'NP_GOOD_NTP_SERVICE' => '', | ||
6 | 'NP_HOSTNAME_INVALID' => 'nosuchhost', | ||
7 | 'NP_HOSTNAME_VALID' => 'monitoring-plugins.org', | ||
8 | 'NP_HOSTNAME_VALID_IP' => '130.133.8.40', | ||
9 | 'NP_HOSTNAME_VALID_CIDR' => '130.133.8.41/30', | ||
10 | 'NP_HOSTNAME_INVALID_CIDR' => '130.133.8.39/30', | ||
11 | 'NP_HOSTNAME_VALID_REVERSE' => 'orwell.monitoring-plugins.org.', | ||
12 | 'NP_HOST_DHCP_RESPONSIVE' => '', | ||
13 | 'NP_HOST_NONRESPONSIVE' => '10.0.0.1', | ||
14 | 'NP_HOST_RESPONSIVE' => 'localhost', | ||
15 | 'NP_HOST_SMB' => '', | ||
16 | 'NP_HOST_SNMP' => 'localhost', | ||
17 | 'NP_HOST_TCP_FTP' => '', | ||
18 | 'NP_HOST_TCP_HPJD' => '', | ||
19 | 'NP_HOST_HPJD_PORT_INVALID' => '161', | ||
20 | 'NP_HOST_HPJD_PORT_VALID' => '', | ||
21 | 'NP_HOST_TCP_HTTP' => 'localhost', | ||
22 | 'NP_HOST_TCP_HTTP2' => 'test.monitoring-plugins.org', | ||
23 | 'NP_HOST_TCP_IMAP' => 'imap.web.de', | ||
24 | 'NP_HOST_TCP_LDAP' => 'localhost', | ||
25 | 'NP_HOST_TCP_POP' => 'pop.web.de', | ||
26 | 'NP_HOST_TCP_SMTP' => 'localhost', | ||
27 | 'NP_HOST_TCP_SMTP_NOTLS' => '', | ||
28 | 'NP_HOST_TCP_SMTP_TLS' => '', | ||
29 | 'NP_INTERNET_ACCESS' => 'yes', | ||
30 | 'NP_LDAP_BASE_DN' => 'cn=admin,dc=nodomain', | ||
31 | 'NP_MOUNTPOINT2_VALID' => '/media/ramdisk', | ||
32 | 'NP_MOUNTPOINT_VALID' => '/', | ||
33 | 'NP_MYSQL_SERVER' => 'localhost', | ||
34 | 'NP_HOST_UDP_TIME' => 'localhost', | ||
35 | 'NP_MYSQL_SOCKET' => '/var/run/mysqld/mysqld.sock', | ||
36 | 'NP_MYSQL_WITH_SLAVE' => '', | ||
37 | 'NP_MYSQL_WITH_SLAVE_LOGIN' => '', | ||
38 | 'NP_NO_NTP_SERVICE' => 'localhost', | ||
39 | 'NP_SMB_SHARE' => '', | ||
40 | 'NP_SMB_SHARE_DENY' => '', | ||
41 | 'NP_SMB_SHARE_SPC' => '', | ||
42 | 'NP_SMB_VALID_USER' => '', | ||
43 | 'NP_SMB_VALID_USER_PASS' => '', | ||
44 | 'NP_SNMP_COMMUNITY' => 'public', | ||
45 | 'NP_SSH_CONFIGFILE' => '~/.ssh/config', | ||
46 | 'NP_SSH_HOST' => 'localhost', | ||
47 | 'NP_SSH_IDENTITY' => '~/.ssh/id_dsa', | ||
48 | 'NP_HOST_TCP_JABBER' => 'jabber.org', | ||
49 | 'host_nonresponsive' => '10.0.0.1', | ||
50 | 'host_responsive' => 'localhost', | ||
51 | 'host_snmp' => '', | ||
52 | 'host_tcp_ftp' => '', | ||
53 | 'host_tcp_http' => 'localhost', | ||
54 | 'host_tcp_imap' => 'imap.nierlein.de', | ||
55 | 'host_tcp_smtp' => 'localhost', | ||
56 | 'hostname_invalid' => 'nosuchhost', | ||
57 | 'snmp_community' => '', | ||
58 | 'user_snmp' => '', | ||
59 | 'host_udp_time' => 'none', | ||
60 | 'host_tls_http' => 'localhost', | ||
61 | 'host_tls_cert' => 'localhost', | ||
62 | } | ||
diff --git a/plugins/t/check_by_ssh.t b/plugins/t/check_by_ssh.t index 4797390d..1d2939e9 100644 --- a/plugins/t/check_by_ssh.t +++ b/plugins/t/check_by_ssh.t | |||
@@ -9,17 +9,9 @@ use Test::More; | |||
9 | use NPTest; | 9 | use NPTest; |
10 | 10 | ||
11 | # Required parameters | 11 | # Required parameters |
12 | my $ssh_service = getTestParameter( "NP_SSH_HOST", | 12 | my $ssh_service = getTestParameter("NP_SSH_HOST", "A host providing SSH service", "localhost"); |
13 | "A host providing SSH service", | 13 | my $ssh_key = getTestParameter("NP_SSH_IDENTITY", "A key allowing access to NP_SSH_HOST", "~/.ssh/id_dsa"); |
14 | "localhost"); | 14 | my $ssh_conf = getTestParameter( "NP_SSH_CONFIGFILE", "A config file with ssh settings", "~/.ssh/config"); |
15 | |||
16 | my $ssh_key = getTestParameter( "NP_SSH_IDENTITY", | ||
17 | "A key allowing access to NP_SSH_HOST", | ||
18 | "~/.ssh/id_dsa"); | ||
19 | |||
20 | my $ssh_conf = getTestParameter( "NP_SSH_CONFIGFILE", | ||
21 | "A config file with ssh settings", | ||
22 | "~/.ssh/config"); | ||
23 | 15 | ||
24 | 16 | ||
25 | plan skip_all => "SSH_HOST and SSH_IDENTITY must be defined" unless ($ssh_service && $ssh_key); | 17 | plan skip_all => "SSH_HOST and SSH_IDENTITY must be defined" unless ($ssh_service && $ssh_key); |
diff --git a/plugins/t/check_curl.t b/plugins/t/check_curl.t new file mode 100644 index 00000000..ada6a045 --- /dev/null +++ b/plugins/t/check_curl.t | |||
@@ -0,0 +1,201 @@ | |||
1 | #! /usr/bin/perl -w -I .. | ||
2 | # | ||
3 | # HyperText Transfer Protocol (HTTP) Test via check_http | ||
4 | # | ||
5 | # | ||
6 | |||
7 | use strict; | ||
8 | use Test::More; | ||
9 | use POSIX qw/mktime strftime/; | ||
10 | use NPTest; | ||
11 | |||
12 | plan tests => 58; | ||
13 | |||
14 | my $successOutput = '/OK.*HTTP.*second/'; | ||
15 | |||
16 | my $res; | ||
17 | my $plugin = 'check_http'; | ||
18 | $plugin = 'check_curl' if $0 =~ m/check_curl/mx; | ||
19 | |||
20 | my $host_tcp_http = getTestParameter("NP_HOST_TCP_HTTP", "A host providing the HTTP Service (a web server)", "localhost"); | ||
21 | my $host_tls_http = getTestParameter("NP_HOST_TLS_HTTP", "A host providing the HTTPS Service (a tls web server)", "localhost"); | ||
22 | my $host_tls_cert = getTestParameter("NP_HOST_TLS_CERT", "the common name of the certificate.", "localhost"); | ||
23 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1"); | ||
24 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost"); | ||
25 | my $internet_access = getTestParameter("NP_INTERNET_ACCESS", "Is this system directly connected to the internet?", "yes"); | ||
26 | my $host_tcp_http2 = getTestParameter("NP_HOST_TCP_HTTP2", "A host providing an index page containing the string 'monitoring'", "test.monitoring-plugins.org"); | ||
27 | my $host_tcp_proxy = getTestParameter("NP_HOST_TCP_PROXY", "A host providing a HTTP proxy with CONNECT support", "localhost"); | ||
28 | my $port_tcp_proxy = getTestParameter("NP_PORT_TCP_PROXY", "Port of the proxy with HTTP and CONNECT support", "3128"); | ||
29 | |||
30 | my $faketime = -x '/usr/bin/faketime' ? 1 : 0; | ||
31 | |||
32 | |||
33 | $res = NPTest->testCmd( | ||
34 | "./$plugin $host_tcp_http -wt 300 -ct 600" | ||
35 | ); | ||
36 | cmp_ok( $res->return_code, '==', 0, "Webserver $host_tcp_http responded" ); | ||
37 | like( $res->output, $successOutput, "Output OK" ); | ||
38 | |||
39 | $res = NPTest->testCmd( | ||
40 | "./$plugin $host_tcp_http -wt 300 -ct 600 -v -v -v -k 'bob:there' -k 'carl:frown'" | ||
41 | ); | ||
42 | like( $res->output, '/bob:there\r\ncarl:frown\r\n/', "Got headers with multiple -k options" ); | ||
43 | |||
44 | $res = NPTest->testCmd( | ||
45 | "./$plugin $host_nonresponsive -wt 1 -ct 2 -t 3" | ||
46 | ); | ||
47 | cmp_ok( $res->return_code, '==', 2, "Webserver $host_nonresponsive not responding" ); | ||
48 | # was CRITICAL only, but both check_curl and check_http print HTTP CRITICAL (puzzle?!) | ||
49 | like( $res->output, "/HTTP CRITICAL - Invalid HTTP response received from host on port 80: cURL returned 28 - Connection timed out after/", "Output OK"); | ||
50 | |||
51 | $res = NPTest->testCmd( | ||
52 | "./$plugin $hostname_invalid -wt 1 -ct 2" | ||
53 | ); | ||
54 | cmp_ok( $res->return_code, '==', 2, "Webserver $hostname_invalid not valid" ); | ||
55 | # The first part of the message comes from the OS catalogue, so cannot check this. | ||
56 | # On Debian, it is Name or service not known, on Darwin, it is No address associated with nodename | ||
57 | # Is also possible to get a socket timeout if DNS is not responding fast enough | ||
58 | # cURL gives us consistent strings from it's own 'lib/strerror.c' | ||
59 | like( $res->output, "/cURL returned 6 - Could not resolve host:/", "Output OK"); | ||
60 | |||
61 | # host header checks | ||
62 | $res = NPTest->testCmd("./$plugin -v -H $host_tcp_http"); | ||
63 | like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" ); | ||
64 | like( $res->output, '/CURLOPT_URL: http:\/\/'.$host_tcp_http.':80\//ms', "Url OK" ); | ||
65 | |||
66 | $res = NPTest->testCmd("./$plugin -v -H $host_tcp_http -p 80"); | ||
67 | like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" ); | ||
68 | like( $res->output, '/CURLOPT_URL: http:\/\/'.$host_tcp_http.':80\//ms', "Url OK" ); | ||
69 | |||
70 | $res = NPTest->testCmd("./$plugin -v -H $host_tcp_http:8080 -p 80"); | ||
71 | like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" ); | ||
72 | like( $res->output, '/CURLOPT_URL: http:\/\/'.$host_tcp_http.':80\//ms', "Url OK" ); | ||
73 | |||
74 | $res = NPTest->testCmd("./$plugin -v -H $host_tcp_http:8080 -p 80"); | ||
75 | like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" ); | ||
76 | like( $res->output, '/CURLOPT_URL: http:\/\/'.$host_tcp_http.':80\//ms', "Url OK" ); | ||
77 | |||
78 | $res = NPTest->testCmd("./$plugin -v -H $host_tcp_http:8080 -p 80 -k 'Host: testhost:8001'"); | ||
79 | like( $res->output, '/^Host: testhost:8001\s*$/ms', "Host Header OK" ); | ||
80 | like( $res->output, '/CURLOPT_URL: http:\/\/'.$host_tcp_http.':80\//ms', "Url OK" ); | ||
81 | |||
82 | $res = NPTest->testCmd("./$plugin -v -I $host_tcp_http -p 80 -k 'Host: testhost:8001'"); | ||
83 | like( $res->output, '/^Host: testhost:8001\s*$/ms', "Host Header OK" ); | ||
84 | like( $res->output, '/CURLOPT_URL: http:\/\/'.$host_tcp_http.':80\//ms', "Url OK" ); | ||
85 | |||
86 | SKIP: { | ||
87 | skip "No internet access", 4 if $internet_access eq "no"; | ||
88 | |||
89 | $res = NPTest->testCmd("./$plugin -v -H $host_tls_http -S"); | ||
90 | like( $res->output, '/^Host: '.$host_tls_http.'\s*$/ms', "Host Header OK" ); | ||
91 | |||
92 | $res = NPTest->testCmd("./$plugin -v -H $host_tls_http:8080 -S -p 443"); | ||
93 | like( $res->output, '/^Host: '.$host_tls_http.':8080\s*$/ms', "Host Header OK" ); | ||
94 | |||
95 | $res = NPTest->testCmd("./$plugin -v -H $host_tls_http:443 -S -p 443"); | ||
96 | like( $res->output, '/^Host: '.$host_tls_http.'\s*$/ms', "Host Header OK" ); | ||
97 | |||
98 | $res = NPTest->testCmd("./$plugin -v -H $host_tls_http -D -S -p 443"); | ||
99 | like( $res->output, '/(^Host: '.$host_tls_http.'\s*$)|(cURL returned 60)/ms', "Host Header OK" ); | ||
100 | }; | ||
101 | |||
102 | SKIP: { | ||
103 | skip "No host serving monitoring in index file", 7 unless $host_tcp_http2; | ||
104 | |||
105 | $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'monitoring'" ); | ||
106 | cmp_ok( $res->return_code, "==", 0, "Got a reference to 'monitoring'"); | ||
107 | |||
108 | $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'mONiTORing'" ); | ||
109 | cmp_ok( $res->return_code, "==", 2, "Not got 'mONiTORing'"); | ||
110 | like ( $res->output, "/pattern not found/", "Error message says 'pattern not found'"); | ||
111 | |||
112 | $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -R 'mONiTORing'" ); | ||
113 | cmp_ok( $res->return_code, "==", 0, "But case insensitive doesn't mind 'mONiTORing'"); | ||
114 | |||
115 | $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'monitoring' --invert-regex" ); | ||
116 | cmp_ok( $res->return_code, "==", 2, "Invert results work when found"); | ||
117 | like ( $res->output, "/pattern found/", "Error message says 'pattern found'"); | ||
118 | |||
119 | $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'mONiTORing' --invert-regex" ); | ||
120 | cmp_ok( $res->return_code, "==", 0, "And also when not found"); | ||
121 | } | ||
122 | SKIP: { | ||
123 | skip "No internet access", 28 if $internet_access eq "no"; | ||
124 | |||
125 | $res = NPTest->testCmd( | ||
126 | "./$plugin --ssl $host_tls_http" | ||
127 | ); | ||
128 | cmp_ok( $res->return_code, '==', 0, "Can read https for $host_tls_http" ); | ||
129 | |||
130 | $res = NPTest->testCmd( "./$plugin -C 1 --ssl $host_tls_http" ); | ||
131 | cmp_ok( $res->return_code, '==', 0, "Checking certificate for $host_tls_http"); | ||
132 | like ( $res->output, "/Certificate '$host_tls_cert' will expire on/", "Output OK" ); | ||
133 | my $saved_cert_output = $res->output; | ||
134 | |||
135 | $res = NPTest->testCmd( "./$plugin -C 8000,1 --ssl $host_tls_http" ); | ||
136 | cmp_ok( $res->return_code, '==', 1, "Checking certificate for $host_tls_http"); | ||
137 | like ( $res->output, qr/WARNING - Certificate '$host_tls_cert' expires in \d+ day/, "Output Warning" ); | ||
138 | |||
139 | $res = NPTest->testCmd( "./$plugin $host_tls_http -C 1" ); | ||
140 | is( $res->return_code, 0, "Old syntax for cert checking okay" ); | ||
141 | is( $res->output, $saved_cert_output, "Same output as new syntax" ); | ||
142 | |||
143 | $res = NPTest->testCmd( "./$plugin -H $host_tls_http -C 1" ); | ||
144 | is( $res->return_code, 0, "Updated syntax for cert checking okay" ); | ||
145 | is( $res->output, $saved_cert_output, "Same output as new syntax" ); | ||
146 | |||
147 | $res = NPTest->testCmd( "./$plugin -C 1 $host_tls_http" ); | ||
148 | cmp_ok( $res->output, 'eq', $saved_cert_output, "--ssl option automatically added"); | ||
149 | |||
150 | $res = NPTest->testCmd( "./$plugin $host_tls_http -C 1" ); | ||
151 | cmp_ok( $res->output, 'eq', $saved_cert_output, "Old syntax for cert checking still works"); | ||
152 | |||
153 | # run some certificate checks with faketime | ||
154 | SKIP: { | ||
155 | skip "No faketime binary found", 12 if !$faketime; | ||
156 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC ./$plugin -C 1 $host_tls_http"); | ||
157 | like($res->output, qr/OK - Certificate '$host_tls_cert' will expire on/, "Catch cert output"); | ||
158 | is( $res->return_code, 0, "Catch cert output exit code" ); | ||
159 | my($mon,$day,$hour,$min,$sec,$year) = ($res->output =~ /(\w+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+(\d+)/); | ||
160 | if(!defined $year) { | ||
161 | die("parsing date failed from: ".$res->output); | ||
162 | } | ||
163 | my $months = {'Jan' => 0, 'Feb' => 1, 'Mar' => 2, 'Apr' => 3, 'May' => 4, 'Jun' => 5, 'Jul' => 6, 'Aug' => 7, 'Sep' => 8, 'Oct' => 9, 'Nov' => 10, 'Dec' => 11}; | ||
164 | my $ts = mktime($sec, $min, $hour, $day, $months->{$mon}, $year-1900); | ||
165 | my $time = strftime("%Y-%m-%d %H:%M:%S", localtime($ts)); | ||
166 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./$plugin -C 1 $host_tls_http"); | ||
167 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' just expired/, "Output on expire date"); | ||
168 | is( $res->return_code, 2, "Output on expire date" ); | ||
169 | |||
170 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-1))."' ./$plugin -C 1 $host_tls_http"); | ||
171 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 0 minutes/, "cert expires in 1 second output"); | ||
172 | is( $res->return_code, 2, "cert expires in 1 second exit code" ); | ||
173 | |||
174 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-120))."' ./$plugin -C 1 $host_tls_http"); | ||
175 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 minutes/, "cert expires in 2 minutes output"); | ||
176 | is( $res->return_code, 2, "cert expires in 2 minutes exit code" ); | ||
177 | |||
178 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-7200))."' ./$plugin -C 1 $host_tls_http"); | ||
179 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 hours/, "cert expires in 2 hours output"); | ||
180 | is( $res->return_code, 2, "cert expires in 2 hours exit code" ); | ||
181 | |||
182 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./$plugin -C 1 $host_tls_http"); | ||
183 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expired on/, "Certificate expired output"); | ||
184 | is( $res->return_code, 2, "Certificate expired exit code" ); | ||
185 | }; | ||
186 | |||
187 | $res = NPTest->testCmd( "./$plugin --ssl $host_tls_http -E" ); | ||
188 | like ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' ); | ||
189 | like ( $res->output, '/time_ssl=[\d\.]+/', 'Extended Performance Data SSL Output OK' ); | ||
190 | |||
191 | $res = NPTest->testCmd( | ||
192 | "./$plugin --ssl -H www.e-paycobalt.com" | ||
193 | ); | ||
194 | cmp_ok( $res->return_code, "==", 0, "Can read https for www.e-paycobalt.com (uses AES certificate)" ); | ||
195 | |||
196 | $res = NPTest->testCmd( "./$plugin -H www.mozilla.com -u /firefox -f curl" ); | ||
197 | is( $res->return_code, 0, "Redirection based on location is okay"); | ||
198 | |||
199 | $res = NPTest->testCmd( "./$plugin -H www.mozilla.com --extended-perfdata" ); | ||
200 | like ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' ); | ||
201 | } | ||
diff --git a/plugins/t/check_disk.t b/plugins/t/check_disk.t index fdd8769b..ec527e7f 100644 --- a/plugins/t/check_disk.t +++ b/plugins/t/check_disk.t | |||
@@ -88,8 +88,9 @@ $result = NPTest->testCmd( | |||
88 | ); | 88 | ); |
89 | $_ = $result->perf_output; | 89 | $_ = $result->perf_output; |
90 | my ($warn_absth_data, $crit_absth_data, $total_absth_data) = (m/=.[^;]*;(\d+);(\d+);\d+;(\d+)/); | 90 | my ($warn_absth_data, $crit_absth_data, $total_absth_data) = (m/=.[^;]*;(\d+);(\d+);\d+;(\d+)/); |
91 | is ($warn_absth_data, $total_absth_data - 20, "Wrong warning in perf data using absolute thresholds"); | 91 | # default unit is MiB, but perfdata is always bytes |
92 | is ($crit_absth_data, $total_absth_data - 10, "Wrong critical in perf data using absolute thresholds"); | 92 | is ($warn_absth_data, $total_absth_data - (20 * (2 ** 20)), "Wrong warning in perf data using absolute thresholds"); |
93 | is ($crit_absth_data, $total_absth_data - (10 * (2 ** 20)), "Wrong critical in perf data using absolute thresholds"); | ||
93 | 94 | ||
94 | # Then check percent thresholds. | 95 | # Then check percent thresholds. |
95 | $result = NPTest->testCmd( | 96 | $result = NPTest->testCmd( |
@@ -119,7 +120,7 @@ like ( $result->only_output, qr/$more_free/, "Have disk name in text"); | |||
119 | $result = NPTest->testCmd( "./check_disk -w 1 -c 1 -p $more_free -p $less_free" ); | 120 | $result = NPTest->testCmd( "./check_disk -w 1 -c 1 -p $more_free -p $less_free" ); |
120 | cmp_ok( $result->return_code, '==', 0, "At least 1 MB available on $more_free and $less_free"); | 121 | cmp_ok( $result->return_code, '==', 0, "At least 1 MB available on $more_free and $less_free"); |
121 | $_ = $result->output; | 122 | $_ = $result->output; |
122 | my ($free_mb_on_mp1, $free_mb_on_mp2) = (m/(\d+) MB .* (\d+) MB /g); | 123 | my ($free_mb_on_mp1, $free_mb_on_mp2) = (m/(\d+)MiB .* (\d+)MiB /g); |
123 | my $free_mb_on_all = $free_mb_on_mp1 + $free_mb_on_mp2; | 124 | my $free_mb_on_all = $free_mb_on_mp1 + $free_mb_on_mp2; |
124 | 125 | ||
125 | 126 | ||
diff --git a/plugins/t/check_dns.t b/plugins/t/check_dns.t index cdfbe60d..afb2062d 100644 --- a/plugins/t/check_dns.t +++ b/plugins/t/check_dns.t | |||
@@ -10,7 +10,7 @@ use NPTest; | |||
10 | 10 | ||
11 | plan skip_all => "check_dns not compiled" unless (-x "check_dns"); | 11 | plan skip_all => "check_dns not compiled" unless (-x "check_dns"); |
12 | 12 | ||
13 | plan tests => 19; | 13 | plan tests => 23; |
14 | 14 | ||
15 | my $successOutput = '/DNS OK: [\.0-9]+ seconds? response time/'; | 15 | my $successOutput = '/DNS OK: [\.0-9]+ seconds? response time/'; |
16 | 16 | ||
@@ -105,3 +105,11 @@ cmp_ok( $res->return_code, '==', 0, "Got expected address"); | |||
105 | $res = NPTest->testCmd("./check_dns -H $hostname_valid -a $hostname_invalid_cidr -t 5"); | 105 | $res = NPTest->testCmd("./check_dns -H $hostname_valid -a $hostname_invalid_cidr -t 5"); |
106 | cmp_ok( $res->return_code, '==', 2, "Got wrong address"); | 106 | cmp_ok( $res->return_code, '==', 2, "Got wrong address"); |
107 | like ( $res->output, "/^DNS CRITICAL.*expected '$hostname_invalid_cidr' but got '$hostname_valid_ip'".'$/', "Output OK"); | 107 | like ( $res->output, "/^DNS CRITICAL.*expected '$hostname_invalid_cidr' but got '$hostname_valid_ip'".'$/', "Output OK"); |
108 | |||
109 | $res = NPTest->testCmd("./check_dns -H $hostname_valid -n"); | ||
110 | cmp_ok( $res->return_code, '==', 2, "Found $hostname_valid"); | ||
111 | like ( $res->output, "/^DNS CRITICAL.*Domain '$hostname_valid' was found by the server:/", "Output OK"); | ||
112 | |||
113 | $res = NPTest->testCmd("./check_dns -H $hostname_invalid -n"); | ||
114 | cmp_ok( $res->return_code, '==', 0, "Did not find $hostname_invalid"); | ||
115 | like ( $res->output, $successOutput, "Output OK" ); | ||
diff --git a/plugins/t/check_fping.t b/plugins/t/check_fping.t index 08692e46..67b357b2 100644 --- a/plugins/t/check_fping.t +++ b/plugins/t/check_fping.t | |||
@@ -5,40 +5,30 @@ | |||
5 | # | 5 | # |
6 | 6 | ||
7 | use strict; | 7 | use strict; |
8 | use Test; | 8 | use Test::More; |
9 | use NPTest; | 9 | use NPTest; |
10 | 10 | ||
11 | use vars qw($tests); | 11 | my $host_responsive = getTestParameter("NP_HOST_RESPONSIVE", "The hostname of system responsive to network requests", "localhost"); |
12 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1"); | ||
13 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost"); | ||
12 | 14 | ||
13 | BEGIN {$tests = 4; plan tests => $tests} | 15 | my $res; |
14 | |||
15 | my $successOutput = '/^FPING OK - /'; | ||
16 | my $failureOutput = '/^FPING CRITICAL - /'; | ||
17 | |||
18 | my $host_responsive = getTestParameter( "host_responsive", "NP_HOST_RESPONSIVE", "localhost", | ||
19 | "The hostname of system responsive to network requests" ); | ||
20 | |||
21 | my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1", | ||
22 | "The hostname of system not responsive to network requests" ); | ||
23 | |||
24 | my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost", | ||
25 | "An invalid (not known to DNS) hostname" ); | ||
26 | |||
27 | |||
28 | my $t; | ||
29 | 16 | ||
30 | my $fping = qx(which fping 2> /dev/null); | 17 | my $fping = qx(which fping 2> /dev/null); |
31 | chomp($fping); | 18 | chomp($fping); |
32 | if( ! -x "./check_fping") { | 19 | if( ! -x "./check_fping") { |
33 | $t += skipMissingCmd( "./check_fping", $tests ); | 20 | plan skip_all => "check_fping not found, skipping tests"; |
34 | } | 21 | } |
35 | elsif ( $> != 0 && (!$fping || ! -u $fping)) { | 22 | elsif ( !$fping || !-x $fping ) { |
36 | $t += skipMsg( "./check_fping", $tests ); | 23 | plan skip_all => "fping not found or cannot be executed, skipping tests"; |
37 | } else { | 24 | } else { |
38 | $t += checkCmd( "./check_fping $host_responsive", 0, $successOutput ); | 25 | plan tests => 3; |
39 | $t += checkCmd( "./check_fping $host_nonresponsive", [ 1, 2 ] ); | 26 | $res = NPTest->testCmd( "./check_fping $host_responsive" ); |
40 | $t += checkCmd( "./check_fping $hostname_invalid", [ 1, 2 ] ); | 27 | cmp_ok( $res->return_code, '==', 0, "Responsive host returns OK"); |
41 | } | ||
42 | 28 | ||
43 | exit(0) if defined($Test::Harness::VERSION); | 29 | $res = NPTest->testCmd( "./check_fping $host_nonresponsive" ); |
44 | exit($tests - $t); | 30 | cmp_ok( $res->return_code, '==', 2, "Non-Responsive host returns Critical"); |
31 | |||
32 | $res = NPTest->testCmd( "./check_fping $hostname_invalid" ); | ||
33 | cmp_ok( $res->return_code, '==', 3, "Invalid host returns Unknown"); | ||
34 | } | ||
diff --git a/plugins/t/check_ftp.t b/plugins/t/check_ftp.t index de6831ba..93a7d7c3 100644 --- a/plugins/t/check_ftp.t +++ b/plugins/t/check_ftp.t | |||
@@ -11,14 +11,9 @@ use NPTest; | |||
11 | use vars qw($tests); | 11 | use vars qw($tests); |
12 | BEGIN {$tests = 4; plan tests => $tests} | 12 | BEGIN {$tests = 4; plan tests => $tests} |
13 | 13 | ||
14 | my $host_tcp_ftp = getTestParameter( "host_tcp_ftp", "NP_HOST_TCP_FTP", "localhost", | 14 | my $host_tcp_ftp = getTestParameter("NP_HOST_TCP_FTP", "A host providing the FTP Service (an FTP server)", "localhost"); |
15 | "A host providing the FTP Service (an FTP server)"); | 15 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1"); |
16 | 16 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost"); | |
17 | my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1", | ||
18 | "The hostname of system not responsive to network requests" ); | ||
19 | |||
20 | my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost", | ||
21 | "An invalid (not known to DNS) hostname" ); | ||
22 | 17 | ||
23 | my $successOutput = '/FTP OK -\s+[0-9]?\.?[0-9]+ second response time/'; | 18 | my $successOutput = '/FTP OK -\s+[0-9]?\.?[0-9]+ second response time/'; |
24 | 19 | ||
diff --git a/plugins/t/check_http.t b/plugins/t/check_http.t index 8bd484a0..c137f7b4 100644 --- a/plugins/t/check_http.t +++ b/plugins/t/check_http.t | |||
@@ -9,61 +9,46 @@ use Test::More; | |||
9 | use POSIX qw/mktime strftime/; | 9 | use POSIX qw/mktime strftime/; |
10 | use NPTest; | 10 | use NPTest; |
11 | 11 | ||
12 | plan tests => 49; | 12 | plan tests => 50; |
13 | 13 | ||
14 | my $successOutput = '/OK.*HTTP.*second/'; | 14 | my $successOutput = '/OK.*HTTP.*second/'; |
15 | 15 | ||
16 | my $res; | 16 | my $res; |
17 | 17 | my $plugin = 'check_http'; | |
18 | my $host_tcp_http = getTestParameter( "NP_HOST_TCP_HTTP", | 18 | $plugin = 'check_curl' if $0 =~ m/check_curl/mx; |
19 | "A host providing the HTTP Service (a web server)", | 19 | |
20 | "localhost" ); | 20 | my $host_tcp_http = getTestParameter("NP_HOST_TCP_HTTP", "A host providing the HTTP Service (a web server)", "localhost"); |
21 | 21 | my $host_tls_http = getTestParameter("NP_HOST_TLS_HTTP", "A host providing the HTTPS Service (a tls web server)", "localhost"); | |
22 | my $host_tls_http = getTestParameter( "host_tls_http", "NP_HOST_TLS_HTTP", "localhost", | 22 | my $host_tls_cert = getTestParameter("NP_HOST_TLS_CERT", "the common name of the certificate.", "localhost"); |
23 | "A host providing the HTTPS Service (a tls web server)" ); | 23 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1"); |
24 | 24 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost"); | |
25 | my $host_tls_cert = getTestParameter( "host_tls_cert", "NP_HOST_TLS_CERT", "localhost", | 25 | my $internet_access = getTestParameter("NP_INTERNET_ACCESS", "Is this system directly connected to the internet?", "yes"); |
26 | "the common name of the certificate." ); | 26 | my $host_tcp_http2 = getTestParameter("NP_HOST_TCP_HTTP2", "A host providing an index page containing the string 'monitoring'", "test.monitoring-plugins.org"); |
27 | 27 | my $host_tcp_proxy = getTestParameter("NP_HOST_TCP_PROXY", "A host providing a HTTP proxy with CONNECT support", "localhost"); | |
28 | 28 | my $port_tcp_proxy = getTestParameter("NP_PORT_TCP_PROXY", "Port of the proxy with HTTP and CONNECT support", "3128"); | |
29 | my $host_nonresponsive = getTestParameter( "NP_HOST_NONRESPONSIVE", | ||
30 | "The hostname of system not responsive to network requests", | ||
31 | "10.0.0.1" ); | ||
32 | |||
33 | my $hostname_invalid = getTestParameter( "NP_HOSTNAME_INVALID", | ||
34 | "An invalid (not known to DNS) hostname", | ||
35 | "nosuchhost"); | ||
36 | |||
37 | my $internet_access = getTestParameter( "NP_INTERNET_ACCESS", | ||
38 | "Is this system directly connected to the internet?", | ||
39 | "yes"); | ||
40 | |||
41 | my $host_tcp_http2 = getTestParameter( "NP_HOST_TCP_HTTP2", | ||
42 | "A host providing an index page containing the string 'monitoring'", | ||
43 | "test.monitoring-plugins.org" ); | ||
44 | 29 | ||
45 | my $faketime = -x '/usr/bin/faketime' ? 1 : 0; | 30 | my $faketime = -x '/usr/bin/faketime' ? 1 : 0; |
46 | 31 | ||
47 | 32 | ||
48 | $res = NPTest->testCmd( | 33 | $res = NPTest->testCmd( |
49 | "./check_http $host_tcp_http -wt 300 -ct 600" | 34 | "./$plugin $host_tcp_http -wt 300 -ct 600" |
50 | ); | 35 | ); |
51 | cmp_ok( $res->return_code, '==', 0, "Webserver $host_tcp_http responded" ); | 36 | cmp_ok( $res->return_code, '==', 0, "Webserver $host_tcp_http responded" ); |
52 | like( $res->output, $successOutput, "Output OK" ); | 37 | like( $res->output, $successOutput, "Output OK" ); |
53 | 38 | ||
54 | $res = NPTest->testCmd( | 39 | $res = NPTest->testCmd( |
55 | "./check_http $host_tcp_http -wt 300 -ct 600 -v -v -v -k 'bob:there' -k 'carl:frown'" | 40 | "./$plugin $host_tcp_http -wt 300 -ct 600 -v -v -v -k 'bob:there' -k 'carl:frown'" |
56 | ); | 41 | ); |
57 | like( $res->output, '/bob:there\r\ncarl:frown\r\n/', "Got headers with multiple -k options" ); | 42 | like( $res->output, '/bob:there\r\ncarl:frown\r\n/', "Got headers with multiple -k options" ); |
58 | 43 | ||
59 | $res = NPTest->testCmd( | 44 | $res = NPTest->testCmd( |
60 | "./check_http $host_nonresponsive -wt 1 -ct 2 -t 3" | 45 | "./$plugin $host_nonresponsive -wt 1 -ct 2 -t 3" |
61 | ); | 46 | ); |
62 | cmp_ok( $res->return_code, '==', 2, "Webserver $host_nonresponsive not responding" ); | 47 | cmp_ok( $res->return_code, '==', 2, "Webserver $host_nonresponsive not responding" ); |
63 | cmp_ok( $res->output, 'eq', "CRITICAL - Socket timeout after 3 seconds", "Output OK"); | 48 | cmp_ok( $res->output, 'eq', "CRITICAL - Socket timeout after 3 seconds", "Output OK"); |
64 | 49 | ||
65 | $res = NPTest->testCmd( | 50 | $res = NPTest->testCmd( |
66 | "./check_http $hostname_invalid -wt 1 -ct 2" | 51 | "./$plugin $hostname_invalid -wt 1 -ct 2" |
67 | ); | 52 | ); |
68 | cmp_ok( $res->return_code, '==', 2, "Webserver $hostname_invalid not valid" ); | 53 | cmp_ok( $res->return_code, '==', 2, "Webserver $hostname_invalid not valid" ); |
69 | # The first part of the message comes from the OS catalogue, so cannot check this. | 54 | # The first part of the message comes from the OS catalogue, so cannot check this. |
@@ -72,86 +57,86 @@ cmp_ok( $res->return_code, '==', 2, "Webserver $hostname_invalid not valid" ); | |||
72 | like( $res->output, "/Unable to open TCP socket|Socket timeout after/", "Output OK"); | 57 | like( $res->output, "/Unable to open TCP socket|Socket timeout after/", "Output OK"); |
73 | 58 | ||
74 | # host header checks | 59 | # host header checks |
75 | $res = NPTest->testCmd("./check_http -v -H $host_tcp_http"); | 60 | $res = NPTest->testCmd("./$plugin -v -H $host_tcp_http"); |
76 | like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" ); | 61 | like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" ); |
77 | 62 | ||
78 | $res = NPTest->testCmd("./check_http -v -H $host_tcp_http -p 80"); | 63 | $res = NPTest->testCmd("./$plugin -v -H $host_tcp_http -p 80"); |
79 | like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" ); | 64 | like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" ); |
80 | 65 | ||
81 | $res = NPTest->testCmd("./check_http -v -H $host_tcp_http:8080 -p 80"); | 66 | $res = NPTest->testCmd("./$plugin -v -H $host_tcp_http:8080 -p 80"); |
82 | like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" ); | 67 | like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" ); |
83 | 68 | ||
84 | $res = NPTest->testCmd("./check_http -v -H $host_tcp_http:8080 -p 80"); | 69 | $res = NPTest->testCmd("./$plugin -v -H $host_tcp_http:8080 -p 80"); |
85 | like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" ); | 70 | like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" ); |
86 | 71 | ||
87 | SKIP: { | 72 | SKIP: { |
88 | skip "No internet access", 3 if $internet_access eq "no"; | 73 | skip "No internet access", 3 if $internet_access eq "no"; |
89 | 74 | ||
90 | $res = NPTest->testCmd("./check_http -v -H $host_tls_http -S"); | 75 | $res = NPTest->testCmd("./$plugin -v -H $host_tls_http -S"); |
91 | like( $res->output, '/^Host: '.$host_tls_http.'\s*$/ms', "Host Header OK" ); | 76 | like( $res->output, '/^Host: '.$host_tls_http.'\s*$/ms', "Host Header OK" ); |
92 | 77 | ||
93 | $res = NPTest->testCmd("./check_http -v -H $host_tls_http:8080 -S -p 443"); | 78 | $res = NPTest->testCmd("./$plugin -v -H $host_tls_http:8080 -S -p 443"); |
94 | like( $res->output, '/^Host: '.$host_tls_http.':8080\s*$/ms', "Host Header OK" ); | 79 | like( $res->output, '/^Host: '.$host_tls_http.':8080\s*$/ms', "Host Header OK" ); |
95 | 80 | ||
96 | $res = NPTest->testCmd("./check_http -v -H $host_tls_http:443 -S -p 443"); | 81 | $res = NPTest->testCmd("./$plugin -v -H $host_tls_http:443 -S -p 443"); |
97 | like( $res->output, '/^Host: '.$host_tls_http.'\s*$/ms', "Host Header OK" ); | 82 | like( $res->output, '/^Host: '.$host_tls_http.'\s*$/ms', "Host Header OK" ); |
98 | }; | 83 | }; |
99 | 84 | ||
100 | SKIP: { | 85 | SKIP: { |
101 | skip "No host serving monitoring in index file", 7 unless $host_tcp_http2; | 86 | skip "No host serving monitoring in index file", 7 unless $host_tcp_http2; |
102 | 87 | ||
103 | $res = NPTest->testCmd( "./check_http -H $host_tcp_http2 -r 'monitoring'" ); | 88 | $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'monitoring'" ); |
104 | cmp_ok( $res->return_code, "==", 0, "Got a reference to 'monitoring'"); | 89 | cmp_ok( $res->return_code, "==", 0, "Got a reference to 'monitoring'"); |
105 | 90 | ||
106 | $res = NPTest->testCmd( "./check_http -H $host_tcp_http2 -r 'mONiTORing'" ); | 91 | $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'mONiTORing'" ); |
107 | cmp_ok( $res->return_code, "==", 2, "Not got 'mONiTORing'"); | 92 | cmp_ok( $res->return_code, "==", 2, "Not got 'mONiTORing'"); |
108 | like ( $res->output, "/pattern not found/", "Error message says 'pattern not found'"); | 93 | like ( $res->output, "/pattern not found/", "Error message says 'pattern not found'"); |
109 | 94 | ||
110 | $res = NPTest->testCmd( "./check_http -H $host_tcp_http2 -R 'mONiTORing'" ); | 95 | $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -R 'mONiTORing'" ); |
111 | cmp_ok( $res->return_code, "==", 0, "But case insensitive doesn't mind 'mONiTORing'"); | 96 | cmp_ok( $res->return_code, "==", 0, "But case insensitive doesn't mind 'mONiTORing'"); |
112 | 97 | ||
113 | $res = NPTest->testCmd( "./check_http -H $host_tcp_http2 -r 'monitoring' --invert-regex" ); | 98 | $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'monitoring' --invert-regex" ); |
114 | cmp_ok( $res->return_code, "==", 2, "Invert results work when found"); | 99 | cmp_ok( $res->return_code, "==", 2, "Invert results work when found"); |
115 | like ( $res->output, "/pattern found/", "Error message says 'pattern found'"); | 100 | like ( $res->output, "/pattern found/", "Error message says 'pattern found'"); |
116 | 101 | ||
117 | $res = NPTest->testCmd( "./check_http -H $host_tcp_http2 -r 'mONiTORing' --invert-regex" ); | 102 | $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'mONiTORing' --invert-regex" ); |
118 | cmp_ok( $res->return_code, "==", 0, "And also when not found"); | 103 | cmp_ok( $res->return_code, "==", 0, "And also when not found"); |
119 | } | 104 | } |
120 | SKIP: { | 105 | SKIP: { |
121 | skip "No internet access", 16 if $internet_access eq "no"; | 106 | skip "No internet access", 23 if $internet_access eq "no"; |
122 | 107 | ||
123 | $res = NPTest->testCmd( | 108 | $res = NPTest->testCmd( |
124 | "./check_http --ssl $host_tls_http" | 109 | "./$plugin --ssl $host_tls_http" |
125 | ); | 110 | ); |
126 | cmp_ok( $res->return_code, '==', 0, "Can read https for $host_tls_http" ); | 111 | cmp_ok( $res->return_code, '==', 0, "Can read https for $host_tls_http" ); |
127 | 112 | ||
128 | $res = NPTest->testCmd( "./check_http -C 1 --ssl $host_tls_http" ); | 113 | $res = NPTest->testCmd( "./$plugin -C 1 --ssl $host_tls_http" ); |
129 | cmp_ok( $res->return_code, '==', 0, "Checking certificate for $host_tls_http"); | 114 | cmp_ok( $res->return_code, '==', 0, "Checking certificate for $host_tls_http"); |
130 | like ( $res->output, "/Certificate '$host_tls_cert' will expire on/", "Output OK" ); | 115 | like ( $res->output, "/Certificate '$host_tls_cert' will expire on/", "Output OK" ); |
131 | my $saved_cert_output = $res->output; | 116 | my $saved_cert_output = $res->output; |
132 | 117 | ||
133 | $res = NPTest->testCmd( "./check_http -C 8000,1 --ssl $host_tls_http" ); | 118 | $res = NPTest->testCmd( "./$plugin -C 8000,1 --ssl $host_tls_http" ); |
134 | cmp_ok( $res->return_code, '==', 1, "Checking certificate for $host_tls_http"); | 119 | cmp_ok( $res->return_code, '==', 1, "Checking certificate for $host_tls_http"); |
135 | like ( $res->output, qr/WARNING - Certificate '$host_tls_cert' expires in \d+ day/, "Output Warning" ); | 120 | like ( $res->output, qr/WARNING - Certificate '$host_tls_cert' expires in \d+ day/, "Output Warning" ); |
136 | 121 | ||
137 | $res = NPTest->testCmd( "./check_http $host_tls_http -C 1" ); | 122 | $res = NPTest->testCmd( "./$plugin $host_tls_http -C 1" ); |
138 | is( $res->return_code, 0, "Old syntax for cert checking okay" ); | 123 | is( $res->return_code, 0, "Old syntax for cert checking okay" ); |
139 | is( $res->output, $saved_cert_output, "Same output as new syntax" ); | 124 | is( $res->output, $saved_cert_output, "Same output as new syntax" ); |
140 | 125 | ||
141 | $res = NPTest->testCmd( "./check_http -H $host_tls_http -C 1" ); | 126 | $res = NPTest->testCmd( "./$plugin -H $host_tls_http -C 1" ); |
142 | is( $res->return_code, 0, "Updated syntax for cert checking okay" ); | 127 | is( $res->return_code, 0, "Updated syntax for cert checking okay" ); |
143 | is( $res->output, $saved_cert_output, "Same output as new syntax" ); | 128 | is( $res->output, $saved_cert_output, "Same output as new syntax" ); |
144 | 129 | ||
145 | $res = NPTest->testCmd( "./check_http -C 1 $host_tls_http" ); | 130 | $res = NPTest->testCmd( "./$plugin -C 1 $host_tls_http" ); |
146 | cmp_ok( $res->output, 'eq', $saved_cert_output, "--ssl option automatically added"); | 131 | cmp_ok( $res->output, 'eq', $saved_cert_output, "--ssl option automatically added"); |
147 | 132 | ||
148 | $res = NPTest->testCmd( "./check_http $host_tls_http -C 1" ); | 133 | $res = NPTest->testCmd( "./$plugin $host_tls_http -C 1" ); |
149 | cmp_ok( $res->output, 'eq', $saved_cert_output, "Old syntax for cert checking still works"); | 134 | cmp_ok( $res->output, 'eq', $saved_cert_output, "Old syntax for cert checking still works"); |
150 | 135 | ||
151 | # run some certificate checks with faketime | 136 | # run some certificate checks with faketime |
152 | SKIP: { | 137 | SKIP: { |
153 | skip "No faketime binary found", 12 if !$faketime; | 138 | skip "No faketime binary found", 7 if !$faketime; |
154 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC ./check_http -C 1 $host_tls_http"); | 139 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC ./$plugin -C 1 $host_tls_http"); |
155 | like($res->output, qr/OK - Certificate '$host_tls_cert' will expire on/, "Catch cert output"); | 140 | like($res->output, qr/OK - Certificate '$host_tls_cert' will expire on/, "Catch cert output"); |
156 | is( $res->return_code, 0, "Catch cert output exit code" ); | 141 | is( $res->return_code, 0, "Catch cert output exit code" ); |
157 | my($mon,$day,$hour,$min,$sec,$year) = ($res->output =~ /(\w+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+(\d+)/); | 142 | my($mon,$day,$hour,$min,$sec,$year) = ($res->output =~ /(\w+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+(\d+)/); |
@@ -161,40 +146,51 @@ SKIP: { | |||
161 | my $months = {'Jan' => 0, 'Feb' => 1, 'Mar' => 2, 'Apr' => 3, 'May' => 4, 'Jun' => 5, 'Jul' => 6, 'Aug' => 7, 'Sep' => 8, 'Oct' => 9, 'Nov' => 10, 'Dec' => 11}; | 146 | my $months = {'Jan' => 0, 'Feb' => 1, 'Mar' => 2, 'Apr' => 3, 'May' => 4, 'Jun' => 5, 'Jul' => 6, 'Aug' => 7, 'Sep' => 8, 'Oct' => 9, 'Nov' => 10, 'Dec' => 11}; |
162 | my $ts = mktime($sec, $min, $hour, $day, $months->{$mon}, $year-1900); | 147 | my $ts = mktime($sec, $min, $hour, $day, $months->{$mon}, $year-1900); |
163 | my $time = strftime("%Y-%m-%d %H:%M:%S", localtime($ts)); | 148 | my $time = strftime("%Y-%m-%d %H:%M:%S", localtime($ts)); |
164 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./check_http -C 1 $host_tls_http"); | 149 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./$plugin -C 1 $host_tls_http"); |
165 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' just expired/, "Output on expire date"); | 150 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' just expired/, "Output on expire date"); |
166 | is( $res->return_code, 2, "Output on expire date" ); | ||
167 | 151 | ||
168 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-1))."' ./check_http -C 1 $host_tls_http"); | 152 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-1))."' ./$plugin -C 1 $host_tls_http"); |
169 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 0 minutes/, "cert expires in 1 second output"); | 153 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 0 minutes/, "cert expires in 1 second output"); |
170 | is( $res->return_code, 2, "cert expires in 1 second exit code" ); | ||
171 | 154 | ||
172 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-120))."' ./check_http -C 1 $host_tls_http"); | 155 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-120))."' ./$plugin -C 1 $host_tls_http"); |
173 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 minutes/, "cert expires in 2 minutes output"); | 156 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 minutes/, "cert expires in 2 minutes output"); |
174 | is( $res->return_code, 2, "cert expires in 2 minutes exit code" ); | ||
175 | 157 | ||
176 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-7200))."' ./check_http -C 1 $host_tls_http"); | 158 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts-7200))."' ./$plugin -C 1 $host_tls_http"); |
177 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 hours/, "cert expires in 2 hours output"); | 159 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 hours/, "cert expires in 2 hours output"); |
178 | is( $res->return_code, 2, "cert expires in 2 hours exit code" ); | ||
179 | 160 | ||
180 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./check_http -C 1 $host_tls_http"); | 161 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./$plugin -C 1 $host_tls_http"); |
181 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expired on/, "Certificate expired output"); | 162 | like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expired on/, "Certificate expired output"); |
182 | is( $res->return_code, 2, "Certificate expired exit code" ); | ||
183 | }; | 163 | }; |
184 | 164 | ||
185 | $res = NPTest->testCmd( "./check_http --ssl $host_tls_http -E" ); | 165 | $res = NPTest->testCmd( "./$plugin --ssl $host_tls_http -E" ); |
186 | like ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' ); | 166 | like ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' ); |
187 | like ( $res->output, '/time_ssl=[\d\.]+/', 'Extended Performance Data SSL Output OK' ); | 167 | like ( $res->output, '/time_ssl=[\d\.]+/', 'Extended Performance Data SSL Output OK' ); |
188 | 168 | ||
189 | $res = NPTest->testCmd( | 169 | $res = NPTest->testCmd( |
190 | "./check_http --ssl -H www.e-paycobalt.com" | 170 | "./$plugin --ssl -H www.e-paycobalt.com" |
191 | ); | 171 | ); |
192 | cmp_ok( $res->return_code, "==", 0, "Can read https for www.e-paycobalt.com (uses AES certificate)" ); | 172 | cmp_ok( $res->return_code, "==", 0, "Can read https for www.e-paycobalt.com (uses AES certificate)" ); |
193 | 173 | ||
194 | 174 | ||
195 | $res = NPTest->testCmd( "./check_http -H www.mozilla.com -u /firefox -f follow" ); | 175 | $res = NPTest->testCmd( "./$plugin -H www.mozilla.com -u /firefox -f follow" ); |
196 | is( $res->return_code, 0, "Redirection based on location is okay"); | 176 | is( $res->return_code, 0, "Redirection based on location is okay"); |
197 | 177 | ||
198 | $res = NPTest->testCmd( "./check_http -H www.mozilla.com --extended-perfdata" ); | 178 | $res = NPTest->testCmd( "./$plugin -H www.mozilla.com --extended-perfdata" ); |
199 | like ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' ); | 179 | like ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' ); |
200 | } | 180 | } |
181 | |||
182 | SKIP: { | ||
183 | skip "No internet access or proxy configured", 6 if $internet_access eq "no" or ! $host_tcp_proxy; | ||
184 | |||
185 | $res = NPTest->testCmd( "./$plugin -I $host_tcp_proxy -p $port_tcp_proxy -u http://$host_tcp_http -e 200,301,302"); | ||
186 | is( $res->return_code, 0, "Proxy HTTP works"); | ||
187 | like($res->output, qr/OK: Status line output matched/, "Proxy HTTP Output is sufficent"); | ||
188 | |||
189 | $res = NPTest->testCmd( "./$plugin -I $host_tcp_proxy -p $port_tcp_proxy -H $host_tls_http -S -j CONNECT"); | ||
190 | is( $res->return_code, 0, "Proxy HTTP CONNECT works"); | ||
191 | like($res->output, qr/HTTP OK:/, "Proxy HTTP CONNECT output sufficent"); | ||
192 | |||
193 | $res = NPTest->testCmd( "./$plugin -I $host_tcp_proxy -p $port_tcp_proxy -H $host_tls_http -S -j CONNECT:HEAD"); | ||
194 | is( $res->return_code, 0, "Proxy HTTP CONNECT works with override method"); | ||
195 | like($res->output, qr/HTTP OK:/, "Proxy HTTP CONNECT output sufficent"); | ||
196 | } | ||
diff --git a/plugins/t/check_imap.t b/plugins/t/check_imap.t index 9c6eae1f..7c74e564 100644 --- a/plugins/t/check_imap.t +++ b/plugins/t/check_imap.t | |||
@@ -8,17 +8,10 @@ use strict; | |||
8 | use Test::More tests => 7; | 8 | use Test::More tests => 7; |
9 | use NPTest; | 9 | use NPTest; |
10 | 10 | ||
11 | my $host_tcp_smtp = getTestParameter( "host_tcp_smtp", "NP_HOST_TCP_SMTP", "mailhost", | 11 | my $host_tcp_smtp = getTestParameter("NP_HOST_TCP_SMTP", "A host providing an STMP Service (a mail server)", "mailhost"); |
12 | "A host providing an STMP Service (a mail server)"); | 12 | my $host_tcp_imap = getTestParameter("NP_HOST_TCP_IMAP", "A host providing an IMAP Service (a mail server)", $host_tcp_smtp); |
13 | 13 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1"); | |
14 | my $host_tcp_imap = getTestParameter( "host_tcp_imap", "NP_HOST_TCP_IMAP", $host_tcp_smtp, | 14 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost"); |
15 | "A host providing an IMAP Service (a mail server)"); | ||
16 | |||
17 | my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1", | ||
18 | "The hostname of system not responsive to network requests" ); | ||
19 | |||
20 | my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost", | ||
21 | "An invalid (not known to DNS) hostname" ); | ||
22 | 15 | ||
23 | my $t; | 16 | my $t; |
24 | 17 | ||
diff --git a/plugins/t/check_jabber.t b/plugins/t/check_jabber.t index 7a708d5b..fcdae179 100644 --- a/plugins/t/check_jabber.t +++ b/plugins/t/check_jabber.t | |||
@@ -10,23 +10,9 @@ use NPTest; | |||
10 | 10 | ||
11 | plan tests => 10; | 11 | plan tests => 10; |
12 | 12 | ||
13 | my $host_tcp_jabber = getTestParameter( | 13 | my $host_tcp_jabber = getTestParameter("NP_HOST_TCP_JABBER", "A host providing the Jabber Service", "jabber.de"); |
14 | "NP_HOST_TCP_JABBER", | 14 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1"); |
15 | "A host providing the Jabber Service", | 15 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost"); |
16 | "jabber.org" | ||
17 | ); | ||
18 | |||
19 | my $host_nonresponsive = getTestParameter( | ||
20 | "NP_HOST_NONRESPONSIVE", | ||
21 | "The hostname of system not responsive to network requests", | ||
22 | "10.0.0.1", | ||
23 | ); | ||
24 | |||
25 | my $hostname_invalid = getTestParameter( | ||
26 | "NP_HOSTNAME_INVALID", | ||
27 | "An invalid (not known to DNS) hostname", | ||
28 | "nosuchhost", | ||
29 | ); | ||
30 | 16 | ||
31 | 17 | ||
32 | my $jabberOK = '/JABBER OK\s-\s\d+\.\d+\ssecond response time on '.$host_tcp_jabber.' port 5222/'; | 18 | my $jabberOK = '/JABBER OK\s-\s\d+\.\d+\ssecond response time on '.$host_tcp_jabber.' port 5222/'; |
diff --git a/plugins/t/check_ldap.t b/plugins/t/check_ldap.t index b8944d4b..b8a4a766 100644 --- a/plugins/t/check_ldap.t +++ b/plugins/t/check_ldap.t | |||
@@ -9,19 +9,10 @@ use warnings; | |||
9 | use Test::More; | 9 | use Test::More; |
10 | use NPTest; | 10 | use NPTest; |
11 | 11 | ||
12 | my $host_tcp_ldap = getTestParameter("NP_HOST_TCP_LDAP", | 12 | my $host_tcp_ldap = getTestParameter("NP_HOST_TCP_LDAP", "A host providing the LDAP Service", "localhost"); |
13 | "A host providing the LDAP Service", | 13 | my $ldap_base_dn = getTestParameter("NP_LDAP_BASE_DN", "A base dn for the LDAP Service", "cn=admin"); |
14 | "localhost" ); | 14 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1"); |
15 | 15 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost"); | |
16 | my $ldap_base_dn = getTestParameter("NP_LDAP_BASE_DN", | ||
17 | "A base dn for the LDAP Service", | ||
18 | "cn=admin" ); | ||
19 | |||
20 | my $host_nonresponsive = getTestParameter("host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1", | ||
21 | "The hostname of system not responsive to network requests" ); | ||
22 | |||
23 | my $hostname_invalid = getTestParameter("hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost", | ||
24 | "An invalid (not known to DNS) hostname" ); | ||
25 | 16 | ||
26 | my($result, $cmd); | 17 | my($result, $cmd); |
27 | my $command = './check_ldap'; | 18 | my $command = './check_ldap'; |
diff --git a/plugins/t/check_load.t b/plugins/t/check_load.t index 55f6f752..60837ef6 100644 --- a/plugins/t/check_load.t +++ b/plugins/t/check_load.t | |||
@@ -11,8 +11,8 @@ use NPTest; | |||
11 | my $res; | 11 | my $res; |
12 | 12 | ||
13 | my $loadValue = "[0-9]+\.?[0-9]+"; | 13 | my $loadValue = "[0-9]+\.?[0-9]+"; |
14 | my $successOutput = "/^OK - load average: $loadValue, $loadValue, $loadValue/"; | 14 | my $successOutput = "/^LOAD OK - load average: $loadValue, $loadValue, $loadValue/"; |
15 | my $failureOutput = "/^CRITICAL - load average: $loadValue, $loadValue, $loadValue/"; | 15 | my $failureOutput = "/^LOAD CRITICAL - load average: $loadValue, $loadValue, $loadValue/"; |
16 | 16 | ||
17 | plan tests => 11; | 17 | plan tests => 11; |
18 | 18 | ||
diff --git a/plugins/t/check_mysql.t b/plugins/t/check_mysql.t index 28cd4cd0..e426bf59 100644 --- a/plugins/t/check_mysql.t +++ b/plugins/t/check_mysql.t | |||
@@ -21,30 +21,11 @@ plan skip_all => "check_mysql not compiled" unless (-x "check_mysql"); | |||
21 | plan tests => 15; | 21 | plan tests => 15; |
22 | 22 | ||
23 | my $bad_login_output = '/Access denied for user /'; | 23 | my $bad_login_output = '/Access denied for user /'; |
24 | my $mysqlserver = getTestParameter( | 24 | my $mysqlserver = getTestParameter("NP_MYSQL_SERVER", "A MySQL Server hostname or IP with no slaves setup"); |
25 | "NP_MYSQL_SERVER", | 25 | my $mysqlsocket = getTestParameter("NP_MYSQL_SOCKET", "Full path to a MySQL Server socket with no slaves setup"); |
26 | "A MySQL Server hostname or IP with no slaves setup" | 26 | my $mysql_login_details = getTestParameter("NP_MYSQL_LOGIN_DETAILS", "Command line parameters to specify login access (requires REPLICATION CLIENT privleges)", "-u test -ptest"); |
27 | ); | 27 | my $with_slave = getTestParameter("NP_MYSQL_WITH_SLAVE", "MySQL server with slaves setup"); |
28 | my $mysqlsocket = getTestParameter( | 28 | my $with_slave_login = getTestParameter("NP_MYSQL_WITH_SLAVE_LOGIN", "Login details for server with slave (requires REPLICATION CLIENT privleges)", $mysql_login_details || "-u test -ptest"); |
29 | "NP_MYSQL_SOCKET", | ||
30 | "Full path to a MySQL Server socket with no slaves setup" | ||
31 | ); | ||
32 | my $mysql_login_details = getTestParameter( | ||
33 | "MYSQL_LOGIN_DETAILS", | ||
34 | "Command line parameters to specify login access (requires " . | ||
35 | "REPLICATION CLIENT privleges)", | ||
36 | "-u test -ptest", | ||
37 | ); | ||
38 | my $with_slave = getTestParameter( | ||
39 | "NP_MYSQL_WITH_SLAVE", | ||
40 | "MySQL server with slaves setup" | ||
41 | ); | ||
42 | my $with_slave_login = getTestParameter( | ||
43 | "NP_MYSQL_WITH_SLAVE_LOGIN", | ||
44 | "Login details for server with slave (requires REPLICATION CLIENT " . | ||
45 | "privleges)", | ||
46 | $mysql_login_details || "-u test -ptest" | ||
47 | ); | ||
48 | 29 | ||
49 | my $result; | 30 | my $result; |
50 | 31 | ||
diff --git a/plugins/t/check_mysql_query.t b/plugins/t/check_mysql_query.t index 407af881..96899ac6 100644 --- a/plugins/t/check_mysql_query.t +++ b/plugins/t/check_mysql_query.t | |||
@@ -17,15 +17,8 @@ use vars qw($tests); | |||
17 | 17 | ||
18 | plan skip_all => "check_mysql_query not compiled" unless (-x "check_mysql_query"); | 18 | plan skip_all => "check_mysql_query not compiled" unless (-x "check_mysql_query"); |
19 | 19 | ||
20 | my $mysqlserver = getTestParameter( | 20 | my $mysqlserver = getTestParameter("NP_MYSQL_SERVER", "A MySQL Server with no slaves setup"); |
21 | "NP_MYSQL_SERVER", | 21 | my $mysql_login_details = getTestParameter("NP_MYSQL_LOGIN_DETAILS", "Command line parameters to specify login access", "-u user -ppw -d db"); |
22 | "A MySQL Server with no slaves setup" | ||
23 | ); | ||
24 | my $mysql_login_details = getTestParameter( | ||
25 | "MYSQL_LOGIN_DETAILS", | ||
26 | "Command line parameters to specify login access", | ||
27 | "-u user -ppw -d db", | ||
28 | ); | ||
29 | my $result; | 22 | my $result; |
30 | 23 | ||
31 | if (! $mysqlserver) { | 24 | if (! $mysqlserver) { |
diff --git a/plugins/t/check_snmp.t b/plugins/t/check_snmp.t index 9a6cd2bb..f2f218fd 100644 --- a/plugins/t/check_snmp.t +++ b/plugins/t/check_snmp.t | |||
@@ -15,18 +15,12 @@ BEGIN { | |||
15 | 15 | ||
16 | my $res; | 16 | my $res; |
17 | 17 | ||
18 | my $host_snmp = getTestParameter( "host_snmp", "NP_HOST_SNMP", "localhost", | 18 | my $host_snmp = getTestParameter("NP_HOST_SNMP", "A host providing an SNMP Service", "localhost"); |
19 | "A host providing an SNMP Service"); | 19 | my $snmp_community = getTestParameter("NP_SNMP_COMMUNITY", "The SNMP Community string for SNMP Testing (assumes snmp v1)", "public"); |
20 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1"); | ||
21 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost"); | ||
22 | my $user_snmp = getTestParameter("NP_SNMP_USER", "An SNMP user", "auth_md5"); | ||
20 | 23 | ||
21 | my $snmp_community = getTestParameter( "snmp_community", "NP_SNMP_COMMUNITY", "public", | ||
22 | "The SNMP Community string for SNMP Testing (assumes snmp v1)" ); | ||
23 | |||
24 | my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1", | ||
25 | "The hostname of system not responsive to network requests" ); | ||
26 | |||
27 | my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost", | ||
28 | "An invalid (not known to DNS) hostname" ); | ||
29 | my $user_snmp = getTestParameter( "user_snmp", "NP_SNMP_USER", "auth_md5", "An SNMP user"); | ||
30 | 24 | ||
31 | $res = NPTest->testCmd( "./check_snmp -t 1" ); | 25 | $res = NPTest->testCmd( "./check_snmp -t 1" ); |
32 | is( $res->return_code, 3, "No host name" ); | 26 | is( $res->return_code, 3, "No host name" ); |
diff --git a/plugins/t/check_ssh.t b/plugins/t/check_ssh.t index 80083492..a5cd23ce 100644 --- a/plugins/t/check_ssh.t +++ b/plugins/t/check_ssh.t | |||
@@ -9,17 +9,9 @@ use Test::More; | |||
9 | use NPTest; | 9 | use NPTest; |
10 | 10 | ||
11 | # Required parameters | 11 | # Required parameters |
12 | my $ssh_host = getTestParameter("NP_SSH_HOST", | 12 | my $ssh_host = getTestParameter("NP_SSH_HOST", "A host providing SSH service", "localhost"); |
13 | "A host providing SSH service", | 13 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1" ); |
14 | "localhost"); | 14 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost" ); |
15 | |||
16 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", | ||
17 | "The hostname of system not responsive to network requests", | ||
18 | "10.0.0.1" ); | ||
19 | |||
20 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", | ||
21 | "An invalid (not known to DNS) hostname", | ||
22 | "nosuchhost" ); | ||
23 | 15 | ||
24 | 16 | ||
25 | plan skip_all => "SSH_HOST must be defined" unless $ssh_host; | 17 | plan skip_all => "SSH_HOST must be defined" unless $ssh_host; |
diff --git a/plugins/t/check_swap.t b/plugins/t/check_swap.t index e44adc90..de9e0f05 100644 --- a/plugins/t/check_swap.t +++ b/plugins/t/check_swap.t | |||
@@ -8,9 +8,9 @@ use strict; | |||
8 | use Test::More tests => 8; | 8 | use Test::More tests => 8; |
9 | use NPTest; | 9 | use NPTest; |
10 | 10 | ||
11 | my $successOutput = '/^SWAP OK - [0-9]+\% free \([0-9]+ MB out of [0-9]+ MB\)/'; | 11 | my $successOutput = '/^SWAP OK - [0-9]+\% free \([0-9]+MB out of [0-9]+MB\)/'; |
12 | my $failureOutput = '/^SWAP CRITICAL - [0-9]+\% free \([0-9]+ MB out of [0-9]+ MB\)/'; | 12 | my $failureOutput = '/^SWAP CRITICAL - [0-9]+\% free \([0-9]+MB out of [0-9]+MB\)/'; |
13 | my $warnOutput = '/^SWAP WARNING - [0-9]+\% free \([0-9]+ MB out of [0-9]+ MB\)/'; | 13 | my $warnOutput = '/^SWAP WARNING - [0-9]+\% free \([0-9]+MB out of [0-9]+MB\)/'; |
14 | 14 | ||
15 | my $result; | 15 | my $result; |
16 | 16 | ||
diff --git a/plugins/t/check_tcp.t b/plugins/t/check_tcp.t index 121b0cb3..cb4de53d 100644 --- a/plugins/t/check_tcp.t +++ b/plugins/t/check_tcp.t | |||
@@ -15,21 +15,11 @@ BEGIN { | |||
15 | } | 15 | } |
16 | 16 | ||
17 | 17 | ||
18 | my $host_tcp_http = getTestParameter( "host_tcp_http", "NP_HOST_TCP_HTTP", "localhost", | 18 | my $host_tcp_http = getTestParameter("NP_HOST_TCP_HTTP", "A host providing the HTTP Service (a web server)", "localhost"); |
19 | "A host providing the HTTP Service (a web server)" ); | 19 | my $host_tls_http = getTestParameter("NP_HOST_TLS_HTTP", "A host providing the HTTPS Service (a tls web server)", "localhost"); |
20 | 20 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1"); | |
21 | my $host_tls_http = getTestParameter( "host_tls_http", "NP_HOST_TLS_HTTP", "localhost", | 21 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost"); |
22 | "A host providing the HTTPS Service (a tls web server)" ); | 22 | my $internet_access = getTestParameter("NP_INTERNET_ACCESS", "Is this system directly connected to the internet?", "yes"); |
23 | |||
24 | my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1", | ||
25 | "The hostname of system not responsive to network requests" ); | ||
26 | |||
27 | my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost", | ||
28 | "An invalid (not known to DNS) hostname" ); | ||
29 | |||
30 | my $internet_access = getTestParameter( "NP_INTERNET_ACCESS", | ||
31 | "Is this system directly connected to the internet?", | ||
32 | "yes"); | ||
33 | 23 | ||
34 | my $successOutput = '/^TCP OK\s-\s+[0-9]?\.?[0-9]+ second response time on port [0-9]+/'; | 24 | my $successOutput = '/^TCP OK\s-\s+[0-9]?\.?[0-9]+ second response time on port [0-9]+/'; |
35 | 25 | ||
diff --git a/plugins/t/check_time.t b/plugins/t/check_time.t index 961f56e6..92c2f891 100644 --- a/plugins/t/check_time.t +++ b/plugins/t/check_time.t | |||
@@ -11,14 +11,9 @@ use NPTest; | |||
11 | use vars qw($tests); | 11 | use vars qw($tests); |
12 | BEGIN {$tests = 8; plan tests => $tests} | 12 | BEGIN {$tests = 8; plan tests => $tests} |
13 | 13 | ||
14 | my $host_udp_time = getTestParameter( "host_udp_time", "NP_HOST_UDP_TIME", "localhost", | 14 | my $host_udp_time = getTestParameter("NP_HOST_UDP_TIME", "A host providing the UDP Time Service", "localhost"); |
15 | "A host providing the UDP Time Service" ); | 15 | my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1"); |
16 | 16 | my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost"); | |
17 | my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1", | ||
18 | "The hostname of system not responsive to network requests" ); | ||
19 | |||
20 | my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost", | ||
21 | "An invalid (not known to DNS) hostname" ); | ||
22 | 17 | ||
23 | my $successOutput = '/^TIME OK - [0-9]+ second time difference/'; | 18 | my $successOutput = '/^TIME OK - [0-9]+ second time difference/'; |
24 | 19 | ||
diff --git a/plugins/tests/certs/expired-cert.pem b/plugins/tests/certs/expired-cert.pem index 40324cf8..77a9166e 100644 --- a/plugins/tests/certs/expired-cert.pem +++ b/plugins/tests/certs/expired-cert.pem | |||
@@ -1,21 +1,24 @@ | |||
1 | -----BEGIN CERTIFICATE----- | 1 | -----BEGIN CERTIFICATE----- |
2 | MIIDYzCCAsygAwIBAgIJAJISzcX71f5pMA0GCSqGSIb3DQEBBAUAMH8xCzAJBgNV | 2 | MIIEETCCAvmgAwIBAgIUFDsP6WnV/uqeQMpD/DYSqouE13kwDQYJKoZIhvcNAQEL |
3 | BAYTAlVLMRMwEQYDVQQIEwpEZXJieXNoaXJlMQ8wDQYDVQQHEwZCZWxwZXIxFzAV | 3 | BQAwgZcxCzAJBgNVBAYTAkRFMRAwDgYDVQQIDAdCYXZhcmlhMQ8wDQYDVQQHDAZN |
4 | BgNVBAoTDk5hZ2lvcyBQbHVnaW5zMREwDwYDVQQDEwhUb24gVm9vbjEeMBwGCSqG | 4 | dW5pY2gxGzAZBgNVBAoMEk1vbml0b3JpbmcgUGx1Z2luczEbMBkGA1UEAwwSTW9u |
5 | SIb3DQEJARYPdG9udm9vbkBtYWMuY29tMB4XDTA5MDMwNjAwMTMxNVoXDTA5MDMw | 5 | aXRvcmluZyBQbHVnaW5zMSswKQYJKoZIhvcNAQkBFhxkZXZlbEBtb25pdG9yaW5n |
6 | NTAwMTMxNlowfzELMAkGA1UEBhMCVUsxEzARBgNVBAgTCkRlcmJ5c2hpcmUxDzAN | 6 | LXBsdWdpbnMub3JnMB4XDTA4MDEwMTExMDAyNloXDTA4MDEwMjExMDAyNlowgZcx |
7 | BgNVBAcTBkJlbHBlcjEXMBUGA1UEChMOTmFnaW9zIFBsdWdpbnMxETAPBgNVBAMT | 7 | CzAJBgNVBAYTAkRFMRAwDgYDVQQIDAdCYXZhcmlhMQ8wDQYDVQQHDAZNdW5pY2gx |
8 | CFRvbiBWb29uMR4wHAYJKoZIhvcNAQkBFg90b252b29uQG1hYy5jb20wgZ8wDQYJ | 8 | GzAZBgNVBAoMEk1vbml0b3JpbmcgUGx1Z2luczEbMBkGA1UEAwwSTW9uaXRvcmlu |
9 | KoZIhvcNAQEBBQADgY0AMIGJAoGBAOQHP4JnzACi4q6quXAiK+gTSffG6yyjEV+K | 9 | ZyBQbHVnaW5zMSswKQYJKoZIhvcNAQkBFhxkZXZlbEBtb25pdG9yaW5nLXBsdWdp |
10 | iyutRgBF2MdF03X5ls0wENw/5fnMTrHynl4XoGoV/rD4CR2hGT0m7dv7Vu0MRLlP | 10 | bnMub3JnMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyeHKwKFjJWUX |
11 | J1SCiFeMuQS30zzLMJr0A7IW869qRlKQmzxs1JT6XDbSoNQuF154zoxwNsKlMjoX | 11 | YHKsisypUf9dHlIPQAISyGP1BX6UL26ZLvE6kKbx3LFQ9W2POGoQWlzFiB1soGeV |
12 | tJSHN2YpAgMBAAGjgeYwgeMwHQYDVR0OBBYEFHWjM9OQldrDLMcAfPnUVfGxlzOp | 12 | WDd0U0JtWdCKmOXWdcXpupQlTSUtRCMDQkfqLN8GR5TBTd73rezp5mz08nMfLwu0 |
13 | MIGzBgNVHSMEgaswgaiAFHWjM9OQldrDLMcAfPnUVfGxlzOpoYGEpIGBMH8xCzAJ | 13 | p5VQ191Ui8JHFgrAOalAn8Uw5De8vj4VmTXmU5NJ2UFoC0ddU/Th/lwRCayHc1cn |
14 | BgNVBAYTAlVLMRMwEQYDVQQIEwpEZXJieXNoaXJlMQ8wDQYDVQQHEwZCZWxwZXIx | 14 | MVq2F7c/uhMUUQYNBmJy0pxoHawp+j9NKl/xIYsjgQNgahQyNuswuGHjaEwhPu+7 |
15 | FzAVBgNVBAoTDk5hZ2lvcyBQbHVnaW5zMREwDwYDVQQDEwhUb24gVm9vbjEeMBwG | 15 | G03XsW4ehu+H1898M/MkSln6LQAU1syoJ8ypPM8tV+zgx4uwj7udnZ2hceN95uW7 |
16 | CSqGSIb3DQEJARYPdG9udm9vbkBtYWMuY29tggkAkhLNxfvV/mkwDAYDVR0TBAUw | 16 | 0PWg5DQyUwIDAQABo1MwUTAdBgNVHQ4EFgQUt9ps3KJ1XiMuy/ijFBjMzf6jgwkw |
17 | AwEB/zANBgkqhkiG9w0BAQQFAAOBgQDHjoXoGwBamCiNplTt93jH/TO08RATdZP5 | 17 | HwYDVR0jBBgwFoAUt9ps3KJ1XiMuy/ijFBjMzf6jgwkwDwYDVR0TAQH/BAUwAwEB |
18 | 45hlxv2+PKCjjTiFa2mjAvopFiqmYsr40XYEmpeYMiaOzOW5rBjtqBAT/JJWyfda | 18 | /zANBgkqhkiG9w0BAQsFAAOCAQEAVPBZwMHbrnHFbmhbcPuvYd5cxk0uSVNAUzsl |
19 | SCmj3swqyKus63rv/iuokIhZzBdhbB+eOJJrmwT2SEc5KdRaipH0QAGF1nZAAGzo | 19 | 2biCq5P+ZHo10VHGygXtdV4utqk/IrAt2u5qSxycWPStCtAgTd3Q8ncfjOkaHM4z |
20 | 6xW7hkzYog== | 20 | 2bxTkhLyQeU8NWPuDBqDszo2GOaFTv+lm36LEKiAfqB1tjQVePSkycdrWIhkamBV |
21 | EgMe6uHLdU7QQk1ajQfrBdakN1beqki/dKieA6gm+XF/QS4SSYINmsHB/2X5cT9U | ||
22 | b/KMB8xurCnuJQuk1P4VsSkJCOSeHjWZgK9pKNdsIJZr4wDVfhjQgU0XT6xakSf7 | ||
23 | eCaHtO0VKsbLZoiTmpxidjsdYiXyeKYIQNtUpTjyJ5V/cZsq9w== | ||
21 | -----END CERTIFICATE----- | 24 | -----END CERTIFICATE----- |
diff --git a/plugins/tests/certs/expired-key.pem b/plugins/tests/certs/expired-key.pem index af0e24da..c1510b2d 100644 --- a/plugins/tests/certs/expired-key.pem +++ b/plugins/tests/certs/expired-key.pem | |||
@@ -1,15 +1,28 @@ | |||
1 | -----BEGIN RSA PRIVATE KEY----- | 1 | -----BEGIN PRIVATE KEY----- |
2 | MIICXAIBAAKBgQDkBz+CZ8wAouKuqrlwIivoE0n3xussoxFfiosrrUYARdjHRdN1 | 2 | MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDJ4crAoWMlZRdg |
3 | +ZbNMBDcP+X5zE6x8p5eF6BqFf6w+AkdoRk9Ju3b+1btDES5TydUgohXjLkEt9M8 | 3 | cqyKzKlR/10eUg9AAhLIY/UFfpQvbpku8TqQpvHcsVD1bY84ahBaXMWIHWygZ5VY |
4 | yzCa9AOyFvOvakZSkJs8bNSU+lw20qDULhdeeM6McDbCpTI6F7SUhzdmKQIDAQAB | 4 | N3RTQm1Z0IqY5dZ1xem6lCVNJS1EIwNCR+os3wZHlMFN3vet7OnmbPTycx8vC7Sn |
5 | AoGARgI3rHjjuDpKMGg4IMZNBqaNaiZHY9/44IVvrww21rSbFqtIfgsQEpU0R/rS | 5 | lVDX3VSLwkcWCsA5qUCfxTDkN7y+PhWZNeZTk0nZQWgLR11T9OH+XBEJrIdzVycx |
6 | R7xDWPztRGQqmwd/t6OfYNpqHbjO1MWzasVBVnzue5P59Y1xy1h0LZF8+a9GY++0 | 6 | WrYXtz+6ExRRBg0GYnLSnGgdrCn6P00qX/EhiyOBA2BqFDI26zC4YeNoTCE+77sb |
7 | uAGUC24jsXSmypNVzoX+ZKyinA3oYV/etdPYx1W8Ms5XIzUCQQD7xwhMuLok6Kbq | 7 | Tdexbh6G74fXz3wz8yRKWfotABTWzKgnzKk8zy1X7ODHi7CPu52dnaFx433m5bvQ |
8 | UEgiSfBTbx+haP3IiqqMF14z8QoEyD3jchydNaXEYdQxN8jEl2aPrMqTc6x8Jq4/ | 8 | 9aDkNDJTAgMBAAECggEACrLFfNnQmD24NGs/S4e2/VpsA9xTZI/3kNkDNgxULANP |
9 | ai0OkB+fAkEA59pAmN81HylV7+CsVjLOSbJqzau7NDxSs2uutxhHZRwz0e25wVer | 9 | aNZtxRajwI9A/BCXQ2UTgsZhzWnJxOJYXrlpl7PweY78mUesysb3MOUC6QisUm0M |
10 | fA03l08u0ebC/TDHkmHV6ikCryM5HU2FNwJAVZJFzd2S1myEHmr+uTisB49jDrbi | 10 | kimfdktHWOnAKLFFLNleN9DUVjjVkTeslijqhNX80f80py1grG2UuCLKCX4OqYIm |
11 | WkBWypo+mCS6JPnxntXvx7auClq9haTSBY73eqldiFPuMZvr6P2rJqHxPQJBAOTM | 11 | qACE8TMmSZLz42AO96TndNtKplQ8LuGLEmByW95wEfhx3Gm4ckkL7qII/U3DnQXr |
12 | quaxjti7kATy8N73sD9mBKQGju1TgkFxSK+DFCGhnTnToXY9MAtxd6SoDYoyccYu | 12 | 0T+3xLaj+eNJzYDpIFZiw4sNzOuAyCz+4Cc4sPDuMnzquXF+enpkemoycC1RmEpG |
13 | dyPrzJAR/IYc+mYCdC0CQDKlZuMPVXEgvGaQapzMQ++5yJRvMZF4tWvONBs0OCE9 | 13 | KIDTwmFsc8TrbGV0qifC6fsCrDivdYLqL7R/q3IBQQKBgQDmfvO3VYTEKY8NA+AT |
14 | QYarsTi5M20cymMBXHOLZIjqwsni4G/C9kqJSvC75Vg= | 14 | 5s6+7NTxRsXxJUCEhCNBWimSH3EzmBAvrodLY6A0oYg8i81bgNX1I9GPVXJZ/QA7 |
15 | -----END RSA PRIVATE KEY----- | 15 | ukd84HUIQoGS5Usmo4rp+kz4P6KkLXDemZtWPU5GXxicfajHRQlkbW6St6SpV7IS |
16 | ibJcDADeoiaPL1xvue1ToP/LoQKBgQDgOFHjYpep00gabvjXfYW7vhrg1vVwaKUM | ||
17 | rf0+UW8Exk4nbBw0eEC2YjxIwzdktlkdbzGaXYULnhg8GnfxYesMOpCLPw1JdB8o | ||
18 | ixETAFpW5bKrUsjEFRUGhzWnsCSFIQ4smpmtGLTxOQ8AkoDdORY5Z+Wv7JtFF6Do | ||
19 | PSoblckZcwKBgB3TD3YJesRnHDty5OuuUdIikuslXTd2uoJrFqS+JeLibqNeabnB | ||
20 | u3/lxDULMbWj4U6VvRmbKOKDC+jY887Gq7lc0cff0yROxwqY3sCnwo3crg7QUmp7 | ||
21 | Nb5S8G3qoCSfndcq96wm/Me/O28uCbycVJfUdchY8uRUHIHYbP0FOBQBAoGBAMgh | ||
22 | fPX4imaKr1DovDObVkK87EDDnU84GBm5MtDs3qrkVd3aIVK0Aw7HoAdSN58tI12i | ||
23 | YiPmVVqJQhhjh6tsOuAvZdTj8ngdrbICbrsHFZt6an+A5LIgHyQ0iy+hiPdLCdvG | ||
24 | ImTeKKMmyr04Bs1upueWVO0xw2VoMbcY4Py+NUEBAoGASQqedfCSKGLT+5lLZrhP | ||
25 | CbFVMmswEPjBcRb1trcuA09vfExn9FfUNFnnw3i9miprED5kufvAjb+6nduXizKg | ||
26 | 7HQYHCwVvakgtXgbiDMaNgYZcjWm+MdnfiwLJjJTO3DfI1JF2PJ8y9R95DPlAkDm | ||
27 | xH3OV8KV4UiTEVxS7ksmGzY= | ||
28 | -----END PRIVATE KEY----- | ||
diff --git a/plugins/tests/certs/server-cert.pem b/plugins/tests/certs/server-cert.pem index 549e4f7e..b84b91d2 100644 --- a/plugins/tests/certs/server-cert.pem +++ b/plugins/tests/certs/server-cert.pem | |||
@@ -1,21 +1,24 @@ | |||
1 | -----BEGIN CERTIFICATE----- | 1 | -----BEGIN CERTIFICATE----- |
2 | MIIDYzCCAsygAwIBAgIJAL8LkpNwzYdxMA0GCSqGSIb3DQEBBAUAMH8xCzAJBgNV | 2 | MIIEBjCCAu6gAwIBAgIJANbQ5QQrKhUGMA0GCSqGSIb3DQEBCwUAMIGXMQswCQYD |
3 | BAYTAlVLMRMwEQYDVQQIEwpEZXJieXNoaXJlMQ8wDQYDVQQHEwZCZWxwZXIxFzAV | 3 | VQQGEwJERTEQMA4GA1UECAwHQmF2YXJpYTEPMA0GA1UEBwwGTXVuaWNoMRswGQYD |
4 | BgNVBAoTDk5hZ2lvcyBQbHVnaW5zMREwDwYDVQQDEwhUb24gVm9vbjEeMBwGCSqG | 4 | VQQKDBJNb25pdG9yaW5nIFBsdWdpbnMxGzAZBgNVBAMMEk1vbml0b3JpbmcgUGx1 |
5 | SIb3DQEJARYPdG9udm9vbkBtYWMuY29tMB4XDTA5MDMwNTIxNDEyOFoXDTE5MDMw | 5 | Z2luczErMCkGCSqGSIb3DQEJARYcZGV2ZWxAbW9uaXRvcmluZy1wbHVnaW5zLm9y |
6 | MzIxNDEyOFowfzELMAkGA1UEBhMCVUsxEzARBgNVBAgTCkRlcmJ5c2hpcmUxDzAN | 6 | ZzAeFw0xOTAyMTkxNTMxNDRaFw0yOTAyMTYxNTMxNDRaMIGXMQswCQYDVQQGEwJE |
7 | BgNVBAcTBkJlbHBlcjEXMBUGA1UEChMOTmFnaW9zIFBsdWdpbnMxETAPBgNVBAMT | 7 | RTEQMA4GA1UECAwHQmF2YXJpYTEPMA0GA1UEBwwGTXVuaWNoMRswGQYDVQQKDBJN |
8 | CFRvbiBWb29uMR4wHAYJKoZIhvcNAQkBFg90b252b29uQG1hYy5jb20wgZ8wDQYJ | 8 | b25pdG9yaW5nIFBsdWdpbnMxGzAZBgNVBAMMEk1vbml0b3JpbmcgUGx1Z2luczEr |
9 | KoZIhvcNAQEBBQADgY0AMIGJAoGBAKcWMBtNtfY8vZXk0SN6/EYTVN/LOvaOSegy | 9 | MCkGCSqGSIb3DQEJARYcZGV2ZWxAbW9uaXRvcmluZy1wbHVnaW5zLm9yZzCCASIw |
10 | oVdLoGwuwjagk+XmCzvCqHZRp8lnCLay7AO8AQI7TSN02ihCcSrgGA9OT+HciIJ1 | 10 | DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKgV2yp8pQvJuN+aJGdAe6Hd0tja |
11 | l5/kEYUAuA1PR6YKK/T713zUAlMzy2tsugx5+xSsSEwsXkmne52jJiG/wuE5CLT0 | 11 | uteCPcNIcM92WLOF69TLTSYon1XDon4tHTh4Z5d4lD8bfsGzFVBmDSgWidhAUf+v |
12 | 9pF8HQqHAgMBAAGjgeYwgeMwHQYDVR0OBBYEFGioSPQ/rdE19+zaeY2YvHTXlUDI | 12 | EqEXwbp293ej/Frc0pXCvmrz6kI1tWrLtQhL/VdbxFYxhV7JjKb+PY3SxGFpSLPe |
13 | MIGzBgNVHSMEgaswgaiAFGioSPQ/rdE19+zaeY2YvHTXlUDIoYGEpIGBMH8xCzAJ | 13 | PQ/5SwVndv7rZIwcjseL22K5Uy2TIrkgzzm2pRs/IvoxRybYr/+LGoHyrtJC6AO8 |
14 | BgNVBAYTAlVLMRMwEQYDVQQIEwpEZXJieXNoaXJlMQ8wDQYDVQQHEwZCZWxwZXIx | 14 | ylp8A/etL0gwtUvRnrnZeTQ2pA1uZ5QN3anTL8JP/ZRZYNegIkaawqMtTKbhM6pi |
15 | FzAVBgNVBAoTDk5hZ2lvcyBQbHVnaW5zMREwDwYDVQQDEwhUb24gVm9vbjEeMBwG | 15 | u3/4a3Uppvt0y7vmGfQlYejxCpICnMrvHMpw8L58zv/98AbCGjDU3UwCt6MCAwEA |
16 | CSqGSIb3DQEJARYPdG9udm9vbkBtYWMuY29tggkAvwuSk3DNh3EwDAYDVR0TBAUw | 16 | AaNTMFEwHQYDVR0OBBYEFG/UH6nGYPlVcM75UXzXBF5GZyrcMB8GA1UdIwQYMBaA |
17 | AwEB/zANBgkqhkiG9w0BAQQFAAOBgQCdqasaIO6JiV5ONFG6Tr1++85UfEdZKMUX | 17 | FG/UH6nGYPlVcM75UXzXBF5GZyrcMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcN |
18 | N2NHiNNUunolIZEYR+dW99ezKmHlDiQ/tMgoLVYpl2Ubho2pAkLGQR+W0ZASgWQ1 | 18 | AQELBQADggEBAGwitJPOnlIKLndNf+iCLMIs0dxsl8kAaejFcjoT0n4ja7Y6Zrqz |
19 | NjfV27Rv0y6lYQMTA0lVAU93L1x9reo3FMedmL5+H+lIEpLCxEPtAJNISrJOneZB | 19 | VSIidzz9vQWvy24xKJpAOdj/iLRHCUOG+Pf5fA6+/FiuqXr6gE2/lm0eC58BNONr |
20 | W5jDadwkoQ== | 20 | E5OzjQ/VoQ8RX4hDntgu6FYbaVa/vhwn16igt9qmdNGGZXf2/+DM3JADwyaA4EK8 |
21 | vm7KdofX9zkxXecHPNvf3jiVLPiDDt6tkGpHPEsyP/yc+RUdltUeZvHfliV0cCuC | ||
22 | jJX+Fm9ysjSpHIFFr+jUMuMHibWoOD8iy3eYxfCDoWsH488pCbj8MNuAq6vd6DBk | ||
23 | bOZxDz43vjWuYMkwXJTxJQh7Pne6kK0vE1g= | ||
21 | -----END CERTIFICATE----- | 24 | -----END CERTIFICATE----- |
diff --git a/plugins/tests/certs/server-key.pem b/plugins/tests/certs/server-key.pem index eacaeaa3..11947555 100644 --- a/plugins/tests/certs/server-key.pem +++ b/plugins/tests/certs/server-key.pem | |||
@@ -1,15 +1,28 @@ | |||
1 | -----BEGIN RSA PRIVATE KEY----- | 1 | -----BEGIN PRIVATE KEY----- |
2 | MIICWwIBAAKBgQCnFjAbTbX2PL2V5NEjevxGE1Tfyzr2jknoMqFXS6BsLsI2oJPl | 2 | MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCoFdsqfKULybjf |
3 | 5gs7wqh2UafJZwi2suwDvAECO00jdNooQnEq4BgPTk/h3IiCdZef5BGFALgNT0em | 3 | miRnQHuh3dLY2rrXgj3DSHDPdlizhevUy00mKJ9Vw6J+LR04eGeXeJQ/G37BsxVQ |
4 | Civ0+9d81AJTM8trbLoMefsUrEhMLF5Jp3udoyYhv8LhOQi09PaRfB0KhwIDAQAB | 4 | Zg0oFonYQFH/rxKhF8G6dvd3o/xa3NKVwr5q8+pCNbVqy7UIS/1XW8RWMYVeyYym |
5 | AoGAfpxclcP8N3vteXErXURrd7pcXT0GECDgNjhvc9PV20RPXM+vYs1AA+fMeeQE | 5 | /j2N0sRhaUiz3j0P+UsFZ3b+62SMHI7Hi9tiuVMtkyK5IM85tqUbPyL6MUcm2K// |
6 | TaRqwO6x016aMRO4rz5ztYArecTBznkds1k59pkN/Ne/nsueU4tvGK8MNyS2o986 | 6 | ixqB8q7SQugDvMpafAP3rS9IMLVL0Z652Xk0NqQNbmeUDd2p0y/CT/2UWWDXoCJG |
7 | Voohqkaq4Lcy1bcHJb9su1ELjegEr1R76Mz452Hsy+uTbAECQQDcg/tZWKVeh5CQ | 7 | msKjLUym4TOqYrt/+Gt1Kab7dMu75hn0JWHo8QqSApzK7xzKcPC+fM7//fAGwhow |
8 | dOEB3YWHwfn0NDgfPm/X2i2kAZ7n7URaUy/ffdlfsrr1mBtHCfedLoOxmmlNfEpM | 8 | 1N1MArejAgMBAAECggEANuvdTwanTzC8jaNqHaq+OuemS2E9B8nwsGxtH/zFgvNR |
9 | hXAAurSHAkEAwfk7fEb0iN0Sj9gTozO7c6Ky10KwePZyjVzqSQIiJq3NX8BEaIeb | 9 | WZiMPtmrJnTkFWJcV+VPw/iMSAqN4nDHmBugVOb4Z4asxGTKK4T9shXJSnh0rqPU |
10 | 51TXxE5VxaLjjMLRkA0hWTYXClgERFZ6AQJAN7ChPqwzf08PRFwwIw911JY5cOHr | 10 | 00ZsvbmxY6z0+E5TesCJqQ+9GYTY1V357V7JchvaOxIRxWPqg9urHbru8OCtW/I5 |
11 | NoDHMCUql5vNLNdwBruxgGjBB/kUXEfgw60RusFvgt/zLh1wiii844JDawJAGQBF | 11 | Fh5HPUZlgCvlMpjlhyjydIf/oXyVA3RNsXlwe8+2cKuGIrjEzm2j9o3VF0sctTX0 |
12 | sYP3urg7zzx7c3qUe5gJ0wLuefjR1PSX4ecbfb7DDMdcSdjIuG1QDiZGmd2f1KG7 | 12 | ItP8A9qDmDQN7GIWX0MW6gncojpS1omC2wcFsdjj/xfPyiDal1X4aq/2YqG8351c |
13 | nwSCOtxk5dloW2KGAQJAQh/iBn0QhfKLFAP5eZBVk8E8XlZuw+S2DLy5SnBlIiYJ | 13 | YlM/+6Va0u9WWE/i64gASTAVqpMV4Yg8y0gGycuA0QKBgQDbgI2QeLd3FvMcURiU |
14 | GB5I2OClgtudXMv1labFrcST8O9eFrtsrhU1iUGUOw== | 14 | l3w9qJgw/Jp3jaNC/9LkVGGz4f4lKKB67lPZvI4noMK8GqO/LcXgqP/RY1oJojoA |
15 | -----END RSA PRIVATE KEY----- | 15 | /6JKVvzYGASZ7VgMoG9bk1AneP1PGdibuTUEwimGlcObxnDFIC/yjwPFu3jIdqdS |
16 | zZi1RZzyqAogN5y3SBEypSmn9wKBgQDECKsqqlcizmCl8v5aVk875AzGN+DOHZqx | ||
17 | bkmztlnLO/2e2Fmk3G5Vvnui0FYisf8Eq19tUTQCF6lSfJlGQeFAT119wkFZhLu+ | ||
18 | FfLGqoEMH0ijJg/8PpdpFRK3I94YcISoTNN6yxMvE6xdDGfKCt5a+IX5bwQi9Zdc | ||
19 | B242gEc6tQKBgA6tM8n7KFlAIZU9HuWgk2AUC8kKutFPmSD7tgAqXDYI4FNfugs+ | ||
20 | MEEYyHCB4UNujJBV4Ss6YZCAkh6eyD4U2aca1eElCfm40vBVMdzvpqZdAqLtWXxg | ||
21 | D9l3mgszrFaYGCY2Fr6jLV9lP5g3xsxUjudf9jSLY9HvpfzjRrMaNATVAoGBALTl | ||
22 | /vYfPMucwKlC5B7++J0e4/7iv6vUu9SyHocdZh1anb9AjPDKjXLIlZT4RhQ8R0XK | ||
23 | 0wOw5JpttU2uN08TKkbLNk3/vYhbKVjPLjrQSseh8sjDLgsqw1QwIxYnniLVakVY | ||
24 | p+rvjSNrNyqicQCMKQavwgocvSd5lJRTMwxOMezlAoGBAKWj71BX+0CK00/2S6lC | ||
25 | TcNcuUPG0d8y1czZ4q6tUlG4htwq1FMOpaghATXjkdsOGTLS+H1aA0Kt7Ai9zDhc | ||
26 | /bzOJEJ+jvBXV4Gcs7jl1r/HTKv0tT9ZSI5Vzkida0rfqxDGzcMVlLuCdH0cb8Iu | ||
27 | N0wdmCAqlQwHR13+F1zrAD7V | ||
28 | -----END PRIVATE KEY----- | ||
diff --git a/plugins/tests/check_curl.t b/plugins/tests/check_curl.t new file mode 100755 index 00000000..29cb03f2 --- /dev/null +++ b/plugins/tests/check_curl.t | |||
@@ -0,0 +1,509 @@ | |||
1 | #! /usr/bin/perl -w -I .. | ||
2 | # | ||
3 | # Test check_http by having an actual HTTP server running | ||
4 | # | ||
5 | # To create the https server certificate: | ||
6 | # openssl req -new -x509 -keyout server-key.pem -out server-cert.pem -days 3650 -nodes | ||
7 | # to create a new expired certificate: | ||
8 | # faketime '2008-01-01 12:00:00' openssl req -new -x509 -keyout expired-key.pem -out expired-cert.pem -days 1 -nodes | ||
9 | # Country Name (2 letter code) [AU]:DE | ||
10 | # State or Province Name (full name) [Some-State]:Bavaria | ||
11 | # Locality Name (eg, city) []:Munich | ||
12 | # Organization Name (eg, company) [Internet Widgits Pty Ltd]:Monitoring Plugins | ||
13 | # Organizational Unit Name (eg, section) []: | ||
14 | # Common Name (e.g. server FQDN or YOUR name) []:Monitoring Plugins | ||
15 | # Email Address []:devel@monitoring-plugins.org | ||
16 | |||
17 | use strict; | ||
18 | use Test::More; | ||
19 | use NPTest; | ||
20 | use FindBin qw($Bin); | ||
21 | |||
22 | $ENV{'LC_TIME'} = "C"; | ||
23 | |||
24 | my $common_tests = 72; | ||
25 | my $ssl_only_tests = 8; | ||
26 | # Check that all dependent modules are available | ||
27 | eval "use HTTP::Daemon 6.01;"; | ||
28 | plan skip_all => 'HTTP::Daemon >= 6.01 required' if $@; | ||
29 | eval { | ||
30 | require HTTP::Status; | ||
31 | require HTTP::Response; | ||
32 | }; | ||
33 | |||
34 | my $plugin = 'check_http'; | ||
35 | $plugin = 'check_curl' if $0 =~ m/check_curl/mx; | ||
36 | |||
37 | # look for libcurl version to see if some advanced checks are possible (>= 7.49.0) | ||
38 | my $advanced_checks = 12; | ||
39 | my $use_advanced_checks = 0; | ||
40 | my $required_version = '7.49.0'; | ||
41 | my $virtual_host = 'www.somefunnyhost.com'; | ||
42 | my $virtual_port = 42; | ||
43 | my $curl_version = ''; | ||
44 | open (my $fh, '-|', "./$plugin --version") or die; | ||
45 | while (<$fh>) { | ||
46 | if (m{libcurl/([\d.]+)\s}) { | ||
47 | $curl_version = $1; | ||
48 | last; | ||
49 | } | ||
50 | } | ||
51 | close ($fh); | ||
52 | if ($curl_version) { | ||
53 | my ($major, $minor, $release) = split (/\./, $curl_version); | ||
54 | my ($req_major, $req_minor, $req_release) = split (/\./, $required_version); | ||
55 | my $check = ($major <=> $req_major or $minor <=> $req_minor or $release <=> $req_release); | ||
56 | if ($check >= 0) { | ||
57 | $use_advanced_checks = 1; | ||
58 | print "Found libcurl $major.$minor.$release. Using advanced checks\n"; | ||
59 | } | ||
60 | } | ||
61 | |||
62 | if ($@) { | ||
63 | plan skip_all => "Missing required module for test: $@"; | ||
64 | } else { | ||
65 | if (-x "./$plugin") { | ||
66 | plan tests => $common_tests * 2 + $ssl_only_tests + $advanced_checks; | ||
67 | } else { | ||
68 | plan skip_all => "No $plugin compiled"; | ||
69 | } | ||
70 | } | ||
71 | |||
72 | my $servers = { http => 0 }; # HTTP::Daemon should always be available | ||
73 | eval { require HTTP::Daemon::SSL }; | ||
74 | if ($@) { | ||
75 | diag "Cannot load HTTP::Daemon::SSL: $@"; | ||
76 | } else { | ||
77 | $servers->{https} = 0; | ||
78 | } | ||
79 | |||
80 | # set a fixed version, so the header size doesn't vary | ||
81 | $HTTP::Daemon::VERSION = "1.00"; | ||
82 | |||
83 | my $port_http = 50000 + int(rand(1000)); | ||
84 | my $port_https = $port_http + 1; | ||
85 | my $port_https_expired = $port_http + 2; | ||
86 | |||
87 | # This array keeps sockets around for implementing timeouts | ||
88 | my @persist; | ||
89 | |||
90 | # Start up all servers | ||
91 | my @pids; | ||
92 | my $pid = fork(); | ||
93 | if ($pid) { | ||
94 | # Parent | ||
95 | push @pids, $pid; | ||
96 | if (exists $servers->{https}) { | ||
97 | # Fork a normal HTTPS server | ||
98 | $pid = fork(); | ||
99 | if ($pid) { | ||
100 | # Parent | ||
101 | push @pids, $pid; | ||
102 | # Fork an expired cert server | ||
103 | $pid = fork(); | ||
104 | if ($pid) { | ||
105 | push @pids, $pid; | ||
106 | } else { | ||
107 | my $d = HTTP::Daemon::SSL->new( | ||
108 | LocalPort => $port_https_expired, | ||
109 | LocalAddr => "127.0.0.1", | ||
110 | SSL_cert_file => "$Bin/certs/expired-cert.pem", | ||
111 | SSL_key_file => "$Bin/certs/expired-key.pem", | ||
112 | ) || die; | ||
113 | print "Please contact https expired at: <URL:", $d->url, ">\n"; | ||
114 | run_server( $d ); | ||
115 | exit; | ||
116 | } | ||
117 | } else { | ||
118 | my $d = HTTP::Daemon::SSL->new( | ||
119 | LocalPort => $port_https, | ||
120 | LocalAddr => "127.0.0.1", | ||
121 | SSL_cert_file => "$Bin/certs/server-cert.pem", | ||
122 | SSL_key_file => "$Bin/certs/server-key.pem", | ||
123 | ) || die; | ||
124 | print "Please contact https at: <URL:", $d->url, ">\n"; | ||
125 | run_server( $d ); | ||
126 | exit; | ||
127 | } | ||
128 | } | ||
129 | } else { | ||
130 | # Child | ||
131 | #print "child\n"; | ||
132 | my $d = HTTP::Daemon->new( | ||
133 | LocalPort => $port_http, | ||
134 | LocalAddr => "127.0.0.1", | ||
135 | ) || die; | ||
136 | print "Please contact http at: <URL:", $d->url, ">\n"; | ||
137 | run_server( $d ); | ||
138 | exit; | ||
139 | } | ||
140 | |||
141 | # give our webservers some time to startup | ||
142 | sleep(3); | ||
143 | |||
144 | # Run the same server on http and https | ||
145 | sub run_server { | ||
146 | my $d = shift; | ||
147 | MAINLOOP: while (my $c = $d->accept ) { | ||
148 | while (my $r = $c->get_request) { | ||
149 | if ($r->method eq "GET" and $r->url->path =~ m^/statuscode/(\d+)^) { | ||
150 | $c->send_basic_header($1); | ||
151 | $c->send_crlf; | ||
152 | } elsif ($r->method eq "GET" and $r->url->path =~ m^/file/(.*)^) { | ||
153 | $c->send_basic_header; | ||
154 | $c->send_crlf; | ||
155 | $c->send_file_response("$Bin/var/$1"); | ||
156 | } elsif ($r->method eq "GET" and $r->url->path eq "/slow") { | ||
157 | $c->send_basic_header; | ||
158 | $c->send_crlf; | ||
159 | sleep 1; | ||
160 | $c->send_response("slow"); | ||
161 | } elsif ($r->url->path eq "/method") { | ||
162 | if ($r->method eq "DELETE") { | ||
163 | $c->send_error(HTTP::Status->RC_METHOD_NOT_ALLOWED); | ||
164 | } elsif ($r->method eq "foo") { | ||
165 | $c->send_error(HTTP::Status->RC_NOT_IMPLEMENTED); | ||
166 | } else { | ||
167 | $c->send_status_line(200, $r->method); | ||
168 | } | ||
169 | } elsif ($r->url->path eq "/postdata") { | ||
170 | $c->send_basic_header; | ||
171 | $c->send_crlf; | ||
172 | $c->send_response($r->method.":".$r->content); | ||
173 | } elsif ($r->url->path eq "/redirect") { | ||
174 | $c->send_redirect( "/redirect2" ); | ||
175 | } elsif ($r->url->path eq "/redir_external") { | ||
176 | $c->send_redirect(($d->isa('HTTP::Daemon::SSL') ? "https" : "http") . "://169.254.169.254/redirect2" ); | ||
177 | } elsif ($r->url->path eq "/redirect2") { | ||
178 | $c->send_basic_header; | ||
179 | $c->send_crlf; | ||
180 | $c->send_response(HTTP::Response->new( 200, 'OK', undef, 'redirected' )); | ||
181 | } elsif ($r->url->path eq "/redir_timeout") { | ||
182 | $c->send_redirect( "/timeout" ); | ||
183 | } elsif ($r->url->path eq "/timeout") { | ||
184 | # Keep $c from being destroyed, but prevent severe leaks | ||
185 | unshift @persist, $c; | ||
186 | delete($persist[1000]); | ||
187 | next MAINLOOP; | ||
188 | } elsif ($r->url->path eq "/header_check") { | ||
189 | $c->send_basic_header; | ||
190 | $c->send_header('foo'); | ||
191 | $c->send_crlf; | ||
192 | } elsif ($r->url->path eq "/header_broken_check") { | ||
193 | $c->send_basic_header; | ||
194 | $c->send_header('foo'); | ||
195 | print $c "Test1:: broken\n"; | ||
196 | print $c " Test2: leading whitespace\n"; | ||
197 | $c->send_crlf; | ||
198 | } elsif ($r->url->path eq "/virtual_port") { | ||
199 | # return sent Host header | ||
200 | $c->send_basic_header; | ||
201 | $c->send_crlf; | ||
202 | $c->send_response(HTTP::Response->new( 200, 'OK', undef, $r->header ('Host'))); | ||
203 | } else { | ||
204 | $c->send_error(HTTP::Status->RC_FORBIDDEN); | ||
205 | } | ||
206 | $c->close; | ||
207 | } | ||
208 | } | ||
209 | } | ||
210 | |||
211 | END { | ||
212 | foreach my $pid (@pids) { | ||
213 | if ($pid) { print "Killing $pid\n"; kill "INT", $pid } | ||
214 | } | ||
215 | }; | ||
216 | |||
217 | if ($ARGV[0] && $ARGV[0] eq "-d") { | ||
218 | while (1) { | ||
219 | sleep 100; | ||
220 | } | ||
221 | } | ||
222 | |||
223 | my $result; | ||
224 | my $command = "./$plugin -H 127.0.0.1"; | ||
225 | |||
226 | run_common_tests( { command => "$command -p $port_http" } ); | ||
227 | SKIP: { | ||
228 | skip "HTTP::Daemon::SSL not installed", $common_tests + $ssl_only_tests if ! exists $servers->{https}; | ||
229 | run_common_tests( { command => "$command -p $port_https", ssl => 1 } ); | ||
230 | |||
231 | $result = NPTest->testCmd( "$command -p $port_https -S -C 14" ); | ||
232 | is( $result->return_code, 0, "$command -p $port_https -S -C 14" ); | ||
233 | is( $result->output, "OK - Certificate 'Monitoring Plugins' will expire on Fri Feb 16 15:31:44 2029 +0000.", "output ok" ); | ||
234 | |||
235 | $result = NPTest->testCmd( "$command -p $port_https -S -C 14000" ); | ||
236 | is( $result->return_code, 1, "$command -p $port_https -S -C 14000" ); | ||
237 | like( $result->output, '/WARNING - Certificate \'Monitoring Plugins\' expires in \d+ day\(s\) \(Fri Feb 16 15:31:44 2029 \+0000\)./', "output ok" ); | ||
238 | |||
239 | # Expired cert tests | ||
240 | $result = NPTest->testCmd( "$command -p $port_https -S -C 13960,14000" ); | ||
241 | is( $result->return_code, 2, "$command -p $port_https -S -C 13960,14000" ); | ||
242 | like( $result->output, '/CRITICAL - Certificate \'Monitoring Plugins\' expires in \d+ day\(s\) \(Fri Feb 16 15:31:44 2029 \+0000\)./', "output ok" ); | ||
243 | |||
244 | $result = NPTest->testCmd( "$command -p $port_https_expired -S -C 7" ); | ||
245 | is( $result->return_code, 2, "$command -p $port_https_expired -S -C 7" ); | ||
246 | is( $result->output, | ||
247 | 'CRITICAL - Certificate \'Monitoring Plugins\' expired on Wed Jan 2 11:00:26 2008 +0000.', | ||
248 | "output ok" ); | ||
249 | |||
250 | } | ||
251 | |||
252 | my $cmd; | ||
253 | |||
254 | # advanced checks with virtual hostname and virtual port | ||
255 | SKIP: { | ||
256 | skip "libcurl version is smaller than $required_version", 6 unless $use_advanced_checks; | ||
257 | |||
258 | # http without virtual port | ||
259 | $cmd = "./$plugin -H $virtual_host -I 127.0.0.1 -p $port_http -u /virtual_port -r ^$virtual_host:$port_http\$"; | ||
260 | $result = NPTest->testCmd( $cmd ); | ||
261 | is( $result->return_code, 0, $cmd); | ||
262 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
263 | |||
264 | # http with virtual port (!= 80) | ||
265 | $cmd = "./$plugin -H $virtual_host:$virtual_port -I 127.0.0.1 -p $port_http -u /virtual_port -r ^$virtual_host:$virtual_port\$"; | ||
266 | $result = NPTest->testCmd( $cmd ); | ||
267 | is( $result->return_code, 0, $cmd); | ||
268 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
269 | |||
270 | # http with virtual port (80) | ||
271 | $cmd = "./$plugin -H $virtual_host:80 -I 127.0.0.1 -p $port_http -u /virtual_port -r ^$virtual_host\$"; | ||
272 | $result = NPTest->testCmd( $cmd ); | ||
273 | is( $result->return_code, 0, $cmd); | ||
274 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
275 | } | ||
276 | |||
277 | # and the same for SSL | ||
278 | SKIP: { | ||
279 | skip "libcurl version is smaller than $required_version and/or HTTP::Daemon::SSL not installed", 6 if ! exists $servers->{https} or not $use_advanced_checks; | ||
280 | # https without virtual port | ||
281 | $cmd = "./$plugin -H $virtual_host -I 127.0.0.1 -p $port_https --ssl -u /virtual_port -r ^$virtual_host:$port_https\$"; | ||
282 | $result = NPTest->testCmd( $cmd ); | ||
283 | is( $result->return_code, 0, $cmd); | ||
284 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
285 | |||
286 | # https with virtual port (!= 443) | ||
287 | $cmd = "./$plugin -H $virtual_host:$virtual_port -I 127.0.0.1 -p $port_https --ssl -u /virtual_port -r ^$virtual_host:$virtual_port\$"; | ||
288 | $result = NPTest->testCmd( $cmd ); | ||
289 | is( $result->return_code, 0, $cmd); | ||
290 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
291 | |||
292 | # https with virtual port (443) | ||
293 | $cmd = "./$plugin -H $virtual_host:443 -I 127.0.0.1 -p $port_https --ssl -u /virtual_port -r ^$virtual_host\$"; | ||
294 | $result = NPTest->testCmd( $cmd ); | ||
295 | is( $result->return_code, 0, $cmd); | ||
296 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
297 | } | ||
298 | |||
299 | |||
300 | sub run_common_tests { | ||
301 | my ($opts) = @_; | ||
302 | my $command = $opts->{command}; | ||
303 | if ($opts->{ssl}) { | ||
304 | $command .= " --ssl"; | ||
305 | } | ||
306 | |||
307 | $result = NPTest->testCmd( "$command -u /file/root" ); | ||
308 | is( $result->return_code, 0, "/file/root"); | ||
309 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 274 bytes in [\d\.]+ second/', "Output correct" ); | ||
310 | |||
311 | $result = NPTest->testCmd( "$command -u /file/root -s Root" ); | ||
312 | is( $result->return_code, 0, "/file/root search for string"); | ||
313 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 274 bytes in [\d\.]+ second/', "Output correct" ); | ||
314 | |||
315 | $result = NPTest->testCmd( "$command -u /file/root -s NonRoot" ); | ||
316 | is( $result->return_code, 2, "Missing string check"); | ||
317 | like( $result->output, qr%^HTTP CRITICAL: HTTP/1\.1 200 OK - string 'NonRoot' not found on 'https?://127\.0\.0\.1:\d+/file/root'%, "Shows search string and location"); | ||
318 | |||
319 | $result = NPTest->testCmd( "$command -u /file/root -s NonRootWithOver30charsAndMoreFunThanAWetFish" ); | ||
320 | is( $result->return_code, 2, "Missing string check"); | ||
321 | like( $result->output, qr%HTTP CRITICAL: HTTP/1\.1 200 OK - string 'NonRootWithOver30charsAndM...' not found on 'https?://127\.0\.0\.1:\d+/file/root'%, "Shows search string and location"); | ||
322 | |||
323 | $result = NPTest->testCmd( "$command -u /header_check -d foo" ); | ||
324 | is( $result->return_code, 0, "header_check search for string"); | ||
325 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 96 bytes in [\d\.]+ second/', "Output correct" ); | ||
326 | |||
327 | $result = NPTest->testCmd( "$command -u /header_check -d bar" ); | ||
328 | is( $result->return_code, 2, "Missing header string check"); | ||
329 | like( $result->output, qr%^HTTP CRITICAL: HTTP/1\.1 200 OK - header 'bar' not found on 'https?://127\.0\.0\.1:\d+/header_check'%, "Shows search string and location"); | ||
330 | |||
331 | $result = NPTest->testCmd( "$command -u /header_broken_check" ); | ||
332 | is( $result->return_code, 0, "header_check search for string"); | ||
333 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 138 bytes in [\d\.]+ second/', "Output correct" ); | ||
334 | |||
335 | my $cmd; | ||
336 | $cmd = "$command -u /slow"; | ||
337 | $result = NPTest->testCmd( $cmd ); | ||
338 | is( $result->return_code, 0, "$cmd"); | ||
339 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
340 | $result->output =~ /in ([\d\.]+) second/; | ||
341 | cmp_ok( $1, ">", 1, "Time is > 1 second" ); | ||
342 | |||
343 | $cmd = "$command -u /statuscode/200"; | ||
344 | $result = NPTest->testCmd( $cmd ); | ||
345 | is( $result->return_code, 0, $cmd); | ||
346 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
347 | |||
348 | $cmd = "$command -u /statuscode/200 -e 200"; | ||
349 | $result = NPTest->testCmd( $cmd ); | ||
350 | is( $result->return_code, 0, $cmd); | ||
351 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - Status line output matched "200" - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
352 | |||
353 | $cmd = "$command -u /statuscode/201"; | ||
354 | $result = NPTest->testCmd( $cmd ); | ||
355 | is( $result->return_code, 0, $cmd); | ||
356 | like( $result->output, '/^HTTP OK: HTTP/1.1 201 Created - \d+ bytes in [\d\.]+ second /', "Output correct: ".$result->output ); | ||
357 | |||
358 | $cmd = "$command -u /statuscode/201 -e 201"; | ||
359 | $result = NPTest->testCmd( $cmd ); | ||
360 | is( $result->return_code, 0, $cmd); | ||
361 | like( $result->output, '/^HTTP OK: HTTP/1.1 201 Created - Status line output matched "201" - \d+ bytes in [\d\.]+ second /', "Output correct: ".$result->output ); | ||
362 | |||
363 | $cmd = "$command -u /statuscode/201 -e 200"; | ||
364 | $result = NPTest->testCmd( $cmd ); | ||
365 | is( $result->return_code, 2, $cmd); | ||
366 | like( $result->output, '/^HTTP CRITICAL - Invalid HTTP response received from host on port \d+: HTTP/1.1 201 Created/', "Output correct: ".$result->output ); | ||
367 | |||
368 | $cmd = "$command -u /statuscode/200 -e 200,201,202"; | ||
369 | $result = NPTest->testCmd( $cmd ); | ||
370 | is( $result->return_code, 0, $cmd); | ||
371 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - Status line output matched "200,201,202" - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
372 | |||
373 | $cmd = "$command -u /statuscode/201 -e 200,201,202"; | ||
374 | $result = NPTest->testCmd( $cmd ); | ||
375 | is( $result->return_code, 0, $cmd); | ||
376 | like( $result->output, '/^HTTP OK: HTTP/1.1 201 Created - Status line output matched "200,201,202" - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
377 | |||
378 | $cmd = "$command -u /statuscode/203 -e 200,201,202"; | ||
379 | $result = NPTest->testCmd( $cmd ); | ||
380 | is( $result->return_code, 2, $cmd); | ||
381 | like( $result->output, '/^HTTP CRITICAL - Invalid HTTP response received from host on port (\d+): HTTP/1.1 203 Non-Authoritative Information/', "Output correct: ".$result->output ); | ||
382 | |||
383 | $cmd = "$command -j HEAD -u /method"; | ||
384 | $result = NPTest->testCmd( $cmd ); | ||
385 | is( $result->return_code, 0, $cmd); | ||
386 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 HEAD - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
387 | |||
388 | $cmd = "$command -j POST -u /method"; | ||
389 | $result = NPTest->testCmd( $cmd ); | ||
390 | is( $result->return_code, 0, $cmd); | ||
391 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 POST - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
392 | |||
393 | $cmd = "$command -j GET -u /method"; | ||
394 | $result = NPTest->testCmd( $cmd ); | ||
395 | is( $result->return_code, 0, $cmd); | ||
396 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 GET - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
397 | |||
398 | $cmd = "$command -u /method"; | ||
399 | $result = NPTest->testCmd( $cmd ); | ||
400 | is( $result->return_code, 0, $cmd); | ||
401 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 GET - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
402 | |||
403 | $cmd = "$command -P foo -u /method"; | ||
404 | $result = NPTest->testCmd( $cmd ); | ||
405 | is( $result->return_code, 0, $cmd); | ||
406 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 POST - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
407 | |||
408 | $cmd = "$command -j DELETE -u /method"; | ||
409 | $result = NPTest->testCmd( $cmd ); | ||
410 | is( $result->return_code, 1, $cmd); | ||
411 | like( $result->output, '/^HTTP WARNING: HTTP/1.1 405 Method Not Allowed/', "Output correct: ".$result->output ); | ||
412 | |||
413 | $cmd = "$command -j foo -u /method"; | ||
414 | $result = NPTest->testCmd( $cmd ); | ||
415 | is( $result->return_code, 2, $cmd); | ||
416 | like( $result->output, '/^HTTP CRITICAL: HTTP/1.1 501 Not Implemented/', "Output correct: ".$result->output ); | ||
417 | |||
418 | $cmd = "$command -P stufftoinclude -u /postdata -s POST:stufftoinclude"; | ||
419 | $result = NPTest->testCmd( $cmd ); | ||
420 | is( $result->return_code, 0, $cmd); | ||
421 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
422 | |||
423 | $cmd = "$command -j PUT -P stufftoinclude -u /postdata -s PUT:stufftoinclude"; | ||
424 | $result = NPTest->testCmd( $cmd ); | ||
425 | is( $result->return_code, 0, $cmd); | ||
426 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
427 | |||
428 | # To confirm that the free doesn't segfault | ||
429 | $cmd = "$command -P stufftoinclude -j PUT -u /postdata -s PUT:stufftoinclude"; | ||
430 | $result = NPTest->testCmd( $cmd ); | ||
431 | is( $result->return_code, 0, $cmd); | ||
432 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
433 | |||
434 | $cmd = "$command -u /redirect"; | ||
435 | $result = NPTest->testCmd( $cmd ); | ||
436 | is( $result->return_code, 0, $cmd); | ||
437 | like( $result->output, '/^HTTP OK: HTTP/1.1 301 Moved Permanently - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
438 | |||
439 | $cmd = "$command -f follow -u /redirect"; | ||
440 | $result = NPTest->testCmd( $cmd ); | ||
441 | is( $result->return_code, 0, $cmd); | ||
442 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
443 | |||
444 | $cmd = "$command -u /redirect -k 'follow: me'"; | ||
445 | $result = NPTest->testCmd( $cmd ); | ||
446 | is( $result->return_code, 0, $cmd); | ||
447 | like( $result->output, '/^HTTP OK: HTTP/1.1 301 Moved Permanently - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
448 | |||
449 | $cmd = "$command -f follow -u /redirect -k 'follow: me'"; | ||
450 | $result = NPTest->testCmd( $cmd ); | ||
451 | is( $result->return_code, 0, $cmd); | ||
452 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
453 | |||
454 | $cmd = "$command -f sticky -u /redirect -k 'follow: me'"; | ||
455 | $result = NPTest->testCmd( $cmd ); | ||
456 | is( $result->return_code, 0, $cmd); | ||
457 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
458 | |||
459 | $cmd = "$command -f stickyport -u /redirect -k 'follow: me'"; | ||
460 | $result = NPTest->testCmd( $cmd ); | ||
461 | is( $result->return_code, 0, $cmd); | ||
462 | like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output ); | ||
463 | |||
464 | # These tests may block | ||
465 | print "ALRM\n"; | ||
466 | |||
467 | # stickyport - on full urlS port is set back to 80 otherwise | ||
468 | $cmd = "$command -f stickyport -u /redir_external -t 5 -s redirected"; | ||
469 | eval { | ||
470 | local $SIG{ALRM} = sub { die "alarm\n" }; | ||
471 | alarm(2); | ||
472 | $result = NPTest->testCmd( $cmd ); | ||
473 | alarm(0); }; | ||
474 | isnt( $@, "alarm\n", $cmd ); | ||
475 | is( $result->return_code, 0, $cmd ); | ||
476 | |||
477 | # Let's hope there won't be any web server on :80 returning "redirected"! | ||
478 | $cmd = "$command -f sticky -u /redir_external -t 5 -s redirected"; | ||
479 | eval { | ||
480 | local $SIG{ALRM} = sub { die "alarm\n" }; | ||
481 | alarm(2); | ||
482 | $result = NPTest->testCmd( $cmd ); | ||
483 | alarm(0); }; | ||
484 | isnt( $@, "alarm\n", $cmd ); | ||
485 | isnt( $result->return_code, 0, $cmd ); | ||
486 | |||
487 | # Test an external address - timeout | ||
488 | SKIP: { | ||
489 | skip "This doesn't seem to work all the time", 1 unless ($ENV{HTTP_EXTERNAL}); | ||
490 | $cmd = "$command -f follow -u /redir_external -t 5"; | ||
491 | eval { | ||
492 | $result = NPTest->testCmd( $cmd, 2 ); | ||
493 | }; | ||
494 | like( $@, "/timeout in command: $cmd/", $cmd ); | ||
495 | } | ||
496 | |||
497 | $cmd = "$command -u /timeout -t 5"; | ||
498 | eval { | ||
499 | $result = NPTest->testCmd( $cmd, 2 ); | ||
500 | }; | ||
501 | like( $@, "/timeout in command: $cmd/", $cmd ); | ||
502 | |||
503 | $cmd = "$command -f follow -u /redir_timeout -t 2"; | ||
504 | eval { | ||
505 | $result = NPTest->testCmd( $cmd, 5 ); | ||
506 | }; | ||
507 | is( $@, "", $cmd ); | ||
508 | |||
509 | } | ||
diff --git a/plugins/tests/check_http.t b/plugins/tests/check_http.t index d6d31de1..188f5e75 100755 --- a/plugins/tests/check_http.t +++ b/plugins/tests/check_http.t | |||
@@ -4,13 +4,15 @@ | |||
4 | # | 4 | # |
5 | # To create the https server certificate: | 5 | # To create the https server certificate: |
6 | # openssl req -new -x509 -keyout server-key.pem -out server-cert.pem -days 3650 -nodes | 6 | # openssl req -new -x509 -keyout server-key.pem -out server-cert.pem -days 3650 -nodes |
7 | # Country Name (2 letter code) [AU]:UK | 7 | # to create a new expired certificate: |
8 | # State or Province Name (full name) [Some-State]:Derbyshire | 8 | # faketime '2008-01-01 12:00:00' openssl req -new -x509 -keyout expired-key.pem -out expired-cert.pem -days 1 -nodes |
9 | # Locality Name (eg, city) []:Belper | 9 | # Country Name (2 letter code) [AU]:DE |
10 | # State or Province Name (full name) [Some-State]:Bavaria | ||
11 | # Locality Name (eg, city) []:Munich | ||
10 | # Organization Name (eg, company) [Internet Widgits Pty Ltd]:Monitoring Plugins | 12 | # Organization Name (eg, company) [Internet Widgits Pty Ltd]:Monitoring Plugins |
11 | # Organizational Unit Name (eg, section) []: | 13 | # Organizational Unit Name (eg, section) []: |
12 | # Common Name (eg, YOUR name) []:Ton Voon | 14 | # Common Name (e.g. server FQDN or YOUR name) []:Monitoring Plugins |
13 | # Email Address []:tonvoon@mac.com | 15 | # Email Address []:devel@monitoring-plugins.org |
14 | 16 | ||
15 | use strict; | 17 | use strict; |
16 | use Test::More; | 18 | use Test::More; |
@@ -30,13 +32,16 @@ eval { | |||
30 | require HTTP::Response; | 32 | require HTTP::Response; |
31 | }; | 33 | }; |
32 | 34 | ||
35 | my $plugin = 'check_http'; | ||
36 | $plugin = 'check_curl' if $0 =~ m/check_curl/mx; | ||
37 | |||
33 | if ($@) { | 38 | if ($@) { |
34 | plan skip_all => "Missing required module for test: $@"; | 39 | plan skip_all => "Missing required module for test: $@"; |
35 | } else { | 40 | } else { |
36 | if (-x "./check_http") { | 41 | if (-x "./$plugin") { |
37 | plan tests => $common_tests * 2 + $ssl_only_tests + $virtual_port_tests; | 42 | plan tests => $common_tests * 2 + $ssl_only_tests + $virtual_port_tests; |
38 | } else { | 43 | } else { |
39 | plan skip_all => "No check_http compiled"; | 44 | plan skip_all => "No $plugin compiled"; |
40 | } | 45 | } |
41 | } | 46 | } |
42 | 47 | ||
@@ -86,6 +91,8 @@ if ($pid) { | |||
86 | exit; | 91 | exit; |
87 | } | 92 | } |
88 | } else { | 93 | } else { |
94 | # closing the connection after -C cert checks make the daemon exit with a sigpipe otherwise | ||
95 | local $SIG{'PIPE'} = 'IGNORE'; | ||
89 | my $d = HTTP::Daemon::SSL->new( | 96 | my $d = HTTP::Daemon::SSL->new( |
90 | LocalPort => $port_https, | 97 | LocalPort => $port_https, |
91 | LocalAddr => "127.0.0.1", | 98 | LocalAddr => "127.0.0.1", |
@@ -97,8 +104,6 @@ if ($pid) { | |||
97 | exit; | 104 | exit; |
98 | } | 105 | } |
99 | } | 106 | } |
100 | # give our webservers some time to startup | ||
101 | sleep(1); | ||
102 | } else { | 107 | } else { |
103 | # Child | 108 | # Child |
104 | #print "child\n"; | 109 | #print "child\n"; |
@@ -111,6 +116,9 @@ if ($pid) { | |||
111 | exit; | 116 | exit; |
112 | } | 117 | } |
113 | 118 | ||
119 | # give our webservers some time to startup | ||
120 | sleep(3); | ||
121 | |||
114 | # Run the same server on http and https | 122 | # Run the same server on http and https |
115 | sub run_server { | 123 | sub run_server { |
116 | my $d = shift; | 124 | my $d = shift; |
@@ -185,7 +193,7 @@ if ($ARGV[0] && $ARGV[0] eq "-d") { | |||
185 | } | 193 | } |
186 | 194 | ||
187 | my $result; | 195 | my $result; |
188 | my $command = "./check_http -H 127.0.0.1"; | 196 | my $command = "./$plugin -H 127.0.0.1"; |
189 | 197 | ||
190 | run_common_tests( { command => "$command -p $port_http" } ); | 198 | run_common_tests( { command => "$command -p $port_http" } ); |
191 | SKIP: { | 199 | SKIP: { |
@@ -194,21 +202,21 @@ SKIP: { | |||
194 | 202 | ||
195 | $result = NPTest->testCmd( "$command -p $port_https -S -C 14" ); | 203 | $result = NPTest->testCmd( "$command -p $port_https -S -C 14" ); |
196 | is( $result->return_code, 0, "$command -p $port_https -S -C 14" ); | 204 | is( $result->return_code, 0, "$command -p $port_https -S -C 14" ); |
197 | is( $result->output, 'OK - Certificate \'Ton Voon\' will expire on Sun Mar 3 21:41:28 2019 +0000.', "output ok" ); | 205 | is( $result->output, "OK - Certificate 'Monitoring Plugins' will expire on Fri Feb 16 15:31:44 2029 +0000.", "output ok" ); |
198 | 206 | ||
199 | $result = NPTest->testCmd( "$command -p $port_https -S -C 14000" ); | 207 | $result = NPTest->testCmd( "$command -p $port_https -S -C 14000" ); |
200 | is( $result->return_code, 1, "$command -p $port_https -S -C 14000" ); | 208 | is( $result->return_code, 1, "$command -p $port_https -S -C 14000" ); |
201 | like( $result->output, '/WARNING - Certificate \'Ton Voon\' expires in \d+ day\(s\) \(Sun Mar 3 21:41:28 2019 \+0000\)./', "output ok" ); | 209 | like( $result->output, '/WARNING - Certificate \'Monitoring Plugins\' expires in \d+ day\(s\) \(Fri Feb 16 15:31:44 2029 \+0000\)./', "output ok" ); |
202 | 210 | ||
203 | # Expired cert tests | 211 | # Expired cert tests |
204 | $result = NPTest->testCmd( "$command -p $port_https -S -C 13960,14000" ); | 212 | $result = NPTest->testCmd( "$command -p $port_https -S -C 13960,14000" ); |
205 | is( $result->return_code, 2, "$command -p $port_https -S -C 13960,14000" ); | 213 | is( $result->return_code, 2, "$command -p $port_https -S -C 13960,14000" ); |
206 | like( $result->output, '/CRITICAL - Certificate \'Ton Voon\' expires in \d+ day\(s\) \(Sun Mar 3 21:41:28 2019 \+0000\)./', "output ok" ); | 214 | like( $result->output, '/CRITICAL - Certificate \'Monitoring Plugins\' expires in \d+ day\(s\) \(Fri Feb 16 15:31:44 2029 \+0000\)./', "output ok" ); |
207 | 215 | ||
208 | $result = NPTest->testCmd( "$command -p $port_https_expired -S -C 7" ); | 216 | $result = NPTest->testCmd( "$command -p $port_https_expired -S -C 7" ); |
209 | is( $result->return_code, 2, "$command -p $port_https_expired -S -C 7" ); | 217 | is( $result->return_code, 2, "$command -p $port_https_expired -S -C 7" ); |
210 | is( $result->output, | 218 | is( $result->output, |
211 | 'CRITICAL - Certificate \'Ton Voon\' expired on Thu Mar 5 00:13:16 2009 +0000.', | 219 | 'CRITICAL - Certificate \'Monitoring Plugins\' expired on Wed Jan 2 11:00:26 2008 +0000.', |
212 | "output ok" ); | 220 | "output ok" ); |
213 | 221 | ||
214 | } | 222 | } |
@@ -409,22 +417,24 @@ sub run_common_tests { | |||
409 | 417 | ||
410 | # stickyport - on full urlS port is set back to 80 otherwise | 418 | # stickyport - on full urlS port is set back to 80 otherwise |
411 | $cmd = "$command -f stickyport -u /redir_external -t 5 -s redirected"; | 419 | $cmd = "$command -f stickyport -u /redir_external -t 5 -s redirected"; |
420 | alarm(2); | ||
412 | eval { | 421 | eval { |
413 | local $SIG{ALRM} = sub { die "alarm\n" }; | 422 | local $SIG{ALRM} = sub { die "alarm\n" }; |
414 | alarm(2); | ||
415 | $result = NPTest->testCmd( $cmd ); | 423 | $result = NPTest->testCmd( $cmd ); |
416 | alarm(0); }; | 424 | }; |
417 | isnt( $@, "alarm\n", $cmd ); | 425 | isnt( $@, "alarm\n", $cmd ); |
426 | alarm(0); | ||
418 | is( $result->return_code, 0, $cmd ); | 427 | is( $result->return_code, 0, $cmd ); |
419 | 428 | ||
420 | # Let's hope there won't be any web server on :80 returning "redirected"! | 429 | # Let's hope there won't be any web server on :80 returning "redirected"! |
421 | $cmd = "$command -f sticky -u /redir_external -t 5 -s redirected"; | 430 | $cmd = "$command -f sticky -u /redir_external -t 5 -s redirected"; |
431 | alarm(2); | ||
422 | eval { | 432 | eval { |
423 | local $SIG{ALRM} = sub { die "alarm\n" }; | 433 | local $SIG{ALRM} = sub { die "alarm\n" }; |
424 | alarm(2); | ||
425 | $result = NPTest->testCmd( $cmd ); | 434 | $result = NPTest->testCmd( $cmd ); |
426 | alarm(0); }; | 435 | }; |
427 | isnt( $@, "alarm\n", $cmd ); | 436 | isnt( $@, "alarm\n", $cmd ); |
437 | alarm(0); | ||
428 | isnt( $result->return_code, 0, $cmd ); | 438 | isnt( $result->return_code, 0, $cmd ); |
429 | 439 | ||
430 | # Test an external address - timeout | 440 | # Test an external address - timeout |
diff --git a/plugins/tests/check_procs.t b/plugins/tests/check_procs.t index 54d43d9b..3af218f5 100755 --- a/plugins/tests/check_procs.t +++ b/plugins/tests/check_procs.t | |||
@@ -8,13 +8,14 @@ use Test::More; | |||
8 | use NPTest; | 8 | use NPTest; |
9 | 9 | ||
10 | if (-x "./check_procs") { | 10 | if (-x "./check_procs") { |
11 | plan tests => 50; | 11 | plan tests => 52; |
12 | } else { | 12 | } else { |
13 | plan skip_all => "No check_procs compiled"; | 13 | plan skip_all => "No check_procs compiled"; |
14 | } | 14 | } |
15 | 15 | ||
16 | my $result; | 16 | my $result; |
17 | my $command = "./check_procs --input-file=tests/var/ps-axwo.darwin"; | 17 | my $command = "./check_procs --input-file=tests/var/ps-axwo.darwin"; |
18 | my $cmd_etime = "./check_procs --input-file=tests/var/ps-axwo.debian"; | ||
18 | 19 | ||
19 | $result = NPTest->testCmd( "$command" ); | 20 | $result = NPTest->testCmd( "$command" ); |
20 | is( $result->return_code, 0, "Run with no options" ); | 21 | is( $result->return_code, 0, "Run with no options" ); |
@@ -69,9 +70,21 @@ SKIP: { | |||
69 | like( $result->output, '/^PROCS OK: 0 processes with UID = -2 \(nobody\), args \'UsB\'/', "Output correct" ); | 70 | like( $result->output, '/^PROCS OK: 0 processes with UID = -2 \(nobody\), args \'UsB\'/', "Output correct" ); |
70 | }; | 71 | }; |
71 | 72 | ||
72 | $result = NPTest->testCmd( "$command --ereg-argument-array='mdworker.*501'" ); | 73 | SKIP: { |
73 | is( $result->return_code, 0, "Checking regexp search of arguments" ); | 74 | skip 'check_procs is compiled with etime format support', 2 if `$command -vvv` =~ m/etime/mx; |
74 | is( $result->output, "PROCS OK: 1 process with regex args 'mdworker.*501' | procs=1;;;0;", "Output correct" ); | 75 | |
76 | $result = NPTest->testCmd( "$command --ereg-argument-array='mdworker.*501'" ); | ||
77 | is( $result->return_code, 0, "Checking regexp search of arguments" ); | ||
78 | is( $result->output, "PROCS OK: 1 process with regex args 'mdworker.*501' | procs=1;;;0;", "Output correct" ); | ||
79 | } | ||
80 | |||
81 | SKIP: { | ||
82 | skip 'check_procs is compiled without etime format support', 2 if `$cmd_etime -vvv` !~ m/etime/mx; | ||
83 | |||
84 | $result = NPTest->testCmd( "$cmd_etime -m ELAPSED -C apache2 -w 1000 -c 2000" ); | ||
85 | is( $result->return_code, 2, "Checking elapsed time threshold" ); | ||
86 | is( $result->output, "ELAPSED CRITICAL: 10 crit, 0 warn out of 10 processes with command name 'apache2' | procs=10;;;0; procs_warn=0;;;0; procs_crit=10;;;0;", "Output correct" ); | ||
87 | } | ||
75 | 88 | ||
76 | $result = NPTest->testCmd( "$command --vsz 1000000" ); | 89 | $result = NPTest->testCmd( "$command --vsz 1000000" ); |
77 | is( $result->return_code, 0, "Checking filter by VSZ" ); | 90 | is( $result->return_code, 0, "Checking filter by VSZ" ); |
@@ -83,7 +96,7 @@ is( $result->output, 'PROCS OK: 3 processes with RSS >= 100000 | procs=3;;;0;', | |||
83 | 96 | ||
84 | $result = NPTest->testCmd( "$command -s S" ); | 97 | $result = NPTest->testCmd( "$command -s S" ); |
85 | is( $result->return_code, 0, "Checking filter for sleeping processes" ); | 98 | is( $result->return_code, 0, "Checking filter for sleeping processes" ); |
86 | like( $result->output, '/^PROCS OK: 44 processes with STATE = S/', "Output correct" ); | 99 | like( $result->output, '/^PROCS OK: 88 processes with STATE = S/', "Output correct" ); |
87 | 100 | ||
88 | $result = NPTest->testCmd( "$command -s Z" ); | 101 | $result = NPTest->testCmd( "$command -s Z" ); |
89 | is( $result->return_code, 0, "Checking filter for zombies" ); | 102 | is( $result->return_code, 0, "Checking filter for zombies" ); |
@@ -129,4 +142,3 @@ is( $result->output, 'RSS CRITICAL: 5 crit, 0 warn out of 95 processes [WindowSe | |||
129 | $result = NPTest->testCmd( "$command --ereg-argument-array='(nosuchname|nosuch2name)'" ); | 142 | $result = NPTest->testCmd( "$command --ereg-argument-array='(nosuchname|nosuch2name)'" ); |
130 | is( $result->return_code, 0, "Checking no pipe symbol in output" ); | 143 | is( $result->return_code, 0, "Checking no pipe symbol in output" ); |
131 | is( $result->output, "PROCS OK: 0 processes with regex args '(nosuchname,nosuch2name)' | procs=0;;;0;", "Output correct" ); | 144 | is( $result->output, "PROCS OK: 0 processes with regex args '(nosuchname,nosuch2name)' | procs=0;;;0;", "Output correct" ); |
132 | |||
diff --git a/plugins/tests/check_snmp.t b/plugins/tests/check_snmp.t index 73a68b20..0a77fa8a 100755 --- a/plugins/tests/check_snmp.t +++ b/plugins/tests/check_snmp.t | |||
@@ -7,8 +7,9 @@ use strict; | |||
7 | use Test::More; | 7 | use Test::More; |
8 | use NPTest; | 8 | use NPTest; |
9 | use FindBin qw($Bin); | 9 | use FindBin qw($Bin); |
10 | use POSIX qw/strftime/; | ||
10 | 11 | ||
11 | my $tests = 67; | 12 | my $tests = 73; |
12 | # Check that all dependent modules are available | 13 | # Check that all dependent modules are available |
13 | eval { | 14 | eval { |
14 | require NetSNMP::OID; | 15 | require NetSNMP::OID; |
@@ -37,6 +38,7 @@ if ($@) { | |||
37 | 38 | ||
38 | my $port_snmp = 16100 + int(rand(100)); | 39 | my $port_snmp = 16100 + int(rand(100)); |
39 | 40 | ||
41 | my $faketime = -x '/usr/bin/faketime' ? 1 : 0; | ||
40 | 42 | ||
41 | # Start up server | 43 | # Start up server |
42 | my @pids; | 44 | my @pids; |
@@ -118,77 +120,81 @@ like($res->output, '/'.quotemeta('SNMP OK - And now have fun with with this: \"C | |||
118 | "And now have fun with with this: \"C:\\\\\" | 120 | "And now have fun with with this: \"C:\\\\\" |
119 | because we\'re not done yet!"').'/m', "Attempt to confuse parser No.3"); | 121 | because we\'re not done yet!"').'/m', "Attempt to confuse parser No.3"); |
120 | 122 | ||
121 | system("rm -f ".$ENV{'MP_STATE_PATH'}."/check_snmp/*"); | 123 | system("rm -f ".$ENV{'MP_STATE_PATH'}."/*/check_snmp/*"); |
122 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -w 600" ); | ||
123 | is($res->return_code, 0, "Returns OK"); | ||
124 | is($res->output, "No previous data to calculate rate - assume okay"); | ||
125 | 124 | ||
126 | # Need to sleep, otherwise duration=0 | 125 | # run rate checks with faketime. rate checks depend on the exact amount of time spend between the |
127 | sleep 1; | 126 | # plugin runs which may fail on busy machines. |
127 | # using faketime removes this race condition and also saves all the sleeps in between. | ||
128 | SKIP: { | ||
129 | skip "No faketime binary found", 28 if !$faketime; | ||
128 | 130 | ||
129 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -w 600" ); | 131 | my $ts = time(); |
130 | is($res->return_code, 1, "WARNING - due to going above rate calculation" ); | 132 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -w 600" ); |
131 | is($res->output, "SNMP RATE WARNING - *666* | iso.3.6.1.4.1.8072.3.2.67.10=666;600 "); | 133 | is($res->return_code, 0, "Returns OK"); |
134 | is($res->output, "No previous data to calculate rate - assume okay"); | ||
132 | 135 | ||
133 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -w 600" ); | 136 | # test rate 1 second later |
134 | is($res->return_code, 3, "UNKNOWN - basically the divide by zero error" ); | 137 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -w 600" ); |
135 | is($res->output, "Time duration between plugin calls is invalid"); | 138 | is($res->return_code, 1, "WARNING - due to going above rate calculation" ); |
139 | is($res->output, "SNMP RATE WARNING - *666* | iso.3.6.1.4.1.8072.3.2.67.10=666;600 "); | ||
136 | 140 | ||
141 | # test rate with same time | ||
142 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -w 600" ); | ||
143 | is($res->return_code, 3, "UNKNOWN - basically the divide by zero error" ); | ||
144 | is($res->output, "Time duration between plugin calls is invalid"); | ||
137 | 145 | ||
138 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets" ); | ||
139 | is($res->return_code, 0, "OK for first call" ); | ||
140 | is($res->output, "No previous data to calculate rate - assume okay" ); | ||
141 | 146 | ||
142 | # Need to sleep, otherwise duration=0 | 147 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets" ); |
143 | sleep 1; | 148 | is($res->return_code, 0, "OK for first call" ); |
149 | is($res->output, "No previous data to calculate rate - assume okay" ); | ||
144 | 150 | ||
145 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets" ); | 151 | # test rate 1 second later |
146 | is($res->return_code, 0, "OK as no thresholds" ); | 152 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets" ); |
147 | is($res->output, "SNMP RATE OK - inoctets 666 | inoctets=666 ", "Check label"); | 153 | is($res->return_code, 0, "OK as no thresholds" ); |
154 | is($res->output, "SNMP RATE OK - inoctets 666 | inoctets=666 ", "Check label"); | ||
148 | 155 | ||
149 | sleep 2; | 156 | # test rate 3 seconds later |
157 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+3))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets" ); | ||
158 | is($res->return_code, 0, "OK as no thresholds" ); | ||
159 | is($res->output, "SNMP RATE OK - inoctets 333 | inoctets=333 ", "Check rate decreases due to longer interval"); | ||
150 | 160 | ||
151 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets" ); | ||
152 | is($res->return_code, 0, "OK as no thresholds" ); | ||
153 | is($res->output, "SNMP RATE OK - inoctets 333 | inoctets=333 ", "Check rate decreases due to longer interval"); | ||
154 | 161 | ||
162 | # label performance data check | ||
163 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l test" ); | ||
164 | is($res->return_code, 0, "OK as no thresholds" ); | ||
165 | is($res->output, "SNMP OK - test 67996 | test=67996c ", "Check label"); | ||
155 | 166 | ||
156 | # label performance data check | 167 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l \"test'test\"" ); |
157 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l test" ); | 168 | is($res->return_code, 0, "OK as no thresholds" ); |
158 | is($res->return_code, 0, "OK as no thresholds" ); | 169 | is($res->output, "SNMP OK - test'test 68662 | \"test'test\"=68662c ", "Check label"); |
159 | is($res->output, "SNMP OK - test 67996 | test=67996c ", "Check label"); | ||
160 | 170 | ||
161 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l \"test'test\"" ); | 171 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l 'test\"test'" ); |
162 | is($res->return_code, 0, "OK as no thresholds" ); | 172 | is($res->return_code, 0, "OK as no thresholds" ); |
163 | is($res->output, "SNMP OK - test'test 68662 | \"test'test\"=68662c ", "Check label"); | 173 | is($res->output, "SNMP OK - test\"test 69328 | 'test\"test'=69328c ", "Check label"); |
164 | 174 | ||
165 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l 'test\"test'" ); | 175 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l test -O" ); |
166 | is($res->return_code, 0, "OK as no thresholds" ); | 176 | is($res->return_code, 0, "OK as no thresholds" ); |
167 | is($res->output, "SNMP OK - test\"test 69328 | 'test\"test'=69328c ", "Check label"); | 177 | is($res->output, "SNMP OK - test 69994 | iso.3.6.1.4.1.8072.3.2.67.10=69994c ", "Check label"); |
168 | 178 | ||
169 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l test -O" ); | 179 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10" ); |
170 | is($res->return_code, 0, "OK as no thresholds" ); | 180 | is($res->return_code, 0, "OK as no thresholds" ); |
171 | is($res->output, "SNMP OK - test 69994 | iso.3.6.1.4.1.8072.3.2.67.10=69994c ", "Check label"); | 181 | is($res->output, "SNMP OK - 70660 | iso.3.6.1.4.1.8072.3.2.67.10=70660c ", "Check label"); |
172 | 182 | ||
173 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10" ); | 183 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l 'test test'" ); |
174 | is($res->return_code, 0, "OK as no thresholds" ); | 184 | is($res->return_code, 0, "OK as no thresholds" ); |
175 | is($res->output, "SNMP OK - 70660 | iso.3.6.1.4.1.8072.3.2.67.10=70660c ", "Check label"); | 185 | is($res->output, "SNMP OK - test test 71326 | 'test test'=71326c ", "Check label"); |
176 | 186 | ||
177 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 -l 'test test'" ); | ||
178 | is($res->return_code, 0, "OK as no thresholds" ); | ||
179 | is($res->output, "SNMP OK - test test 71326 | 'test test'=71326c ", "Check label"); | ||
180 | 187 | ||
188 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets_per_minute --rate-multiplier=60" ); | ||
189 | is($res->return_code, 0, "OK for first call" ); | ||
190 | is($res->output, "No previous data to calculate rate - assume okay" ); | ||
181 | 191 | ||
182 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets_per_minute --rate-multiplier=60" ); | 192 | # test 1 second later |
183 | is($res->return_code, 0, "OK for first call" ); | 193 | $res = NPTest->testCmd("LC_TIME=C TZ=UTC faketime -f '".strftime("%Y-%m-%d %H:%M:%S", localtime($ts+1))."' ./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets_per_minute --rate-multiplier=60" ); |
184 | is($res->output, "No previous data to calculate rate - assume okay" ); | 194 | is($res->return_code, 0, "OK as no thresholds" ); |
185 | 195 | is($res->output, "SNMP RATE OK - inoctets_per_minute 39960 | inoctets_per_minute=39960 ", "Checking multiplier"); | |
186 | # Need to sleep, otherwise duration=0 | 196 | }; |
187 | sleep 1; | ||
188 | 197 | ||
189 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10 --rate -l inoctets_per_minute --rate-multiplier=60" ); | ||
190 | is($res->return_code, 0, "OK as no thresholds" ); | ||
191 | is($res->output, "SNMP RATE OK - inoctets_per_minute 39960 | inoctets_per_minute=39960 ", "Checking multiplier"); | ||
192 | 198 | ||
193 | 199 | ||
194 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.11 -s '\"stringtests\"'" ); | 200 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.11 -s '\"stringtests\"'" ); |
@@ -245,9 +251,20 @@ is($res->output, 'SNMP CRITICAL - *-4* | iso.3.6.1.4.1.8072.3.2.67.17=-4;-2:;-3: | |||
245 | 251 | ||
246 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.18 -c '~:-6.5'" ); | 252 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.18 -c '~:-6.5'" ); |
247 | is($res->return_code, 0, "Negative float OK" ); | 253 | is($res->return_code, 0, "Negative float OK" ); |
248 | is($res->output, 'SNMP OK - -6.6 | iso.3.6.1.4.1.8072.3.2.67.18=-6.6;;~:-6.5 ', "Negative float OK output" ); | 254 | is($res->output, 'SNMP OK - -6.6 | iso.3.6.1.4.1.8072.3.2.67.18=-6.6;;@-6.5:~ ', "Negative float OK output" ); |
249 | 255 | ||
250 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.18 -w '~:-6.65' -c '~:-6.55'" ); | 256 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.18 -w '~:-6.65' -c '~:-6.55'" ); |
251 | is($res->return_code, 1, "Negative float WARNING" ); | 257 | is($res->return_code, 1, "Negative float WARNING" ); |
252 | is($res->output, 'SNMP WARNING - *-6.6* | iso.3.6.1.4.1.8072.3.2.67.18=-6.6;~:-6.65;~:-6.55 ', "Negative float WARNING output" ); | 258 | is($res->output, 'SNMP WARNING - *-6.6* | iso.3.6.1.4.1.8072.3.2.67.18=-6.6;@-6.65:~;@-6.55:~ ', "Negative float WARNING output" ); |
259 | |||
260 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10,.1.3.6.1.4.1.8072.3.2.67.17 -w '1:100000,-10:20' -c '2:200000,-20:30'" ); | ||
261 | is($res->return_code, 0, "Multiple OIDs with thresholds" ); | ||
262 | like($res->output, '/SNMP OK - \d+ -4 | iso.3.6.1.4.1.8072.3.2.67.10=\d+c;1:100000;2:200000 iso.3.6.1.4.1.8072.3.2.67.17=-4;-10:20;-20:30/', "Multiple OIDs with thresholds output" ); | ||
263 | |||
264 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10,.1.3.6.1.4.1.8072.3.2.67.17 -w '1:100000,-1:2' -c '2:200000,-20:30'" ); | ||
265 | is($res->return_code, 1, "Multiple OIDs with thresholds" ); | ||
266 | like($res->output, '/SNMP WARNING - \d+ \*-4\* | iso.3.6.1.4.1.8072.3.2.67.10=\d+c;1:100000;2:200000 iso.3.6.1.4.1.8072.3.2.67.17=-4;-10:20;-20:30/', "Multiple OIDs with thresholds output" ); | ||
253 | 267 | ||
268 | $res = NPTest->testCmd( "./check_snmp -H 127.0.0.1 -C public -p $port_snmp -o .1.3.6.1.4.1.8072.3.2.67.10,.1.3.6.1.4.1.8072.3.2.67.17 -w 1,2 -c 1" ); | ||
269 | is($res->return_code, 2, "Multiple OIDs with some thresholds" ); | ||
270 | like($res->output, '/SNMP CRITICAL - \*\d+\* \*-4\* | iso.3.6.1.4.1.8072.3.2.67.10=\d+c;1;2 iso.3.6.1.4.1.8072.3.2.67.17=-4;;/', "Multiple OIDs with thresholds output" ); | ||
diff --git a/plugins/tests/var/ps-axwo.debian b/plugins/tests/var/ps-axwo.debian new file mode 100644 index 00000000..5889e9a4 --- /dev/null +++ b/plugins/tests/var/ps-axwo.debian | |||
@@ -0,0 +1,219 @@ | |||
1 | STAT UID PID PPID VSZ RSS %CPU ELAPSED COMMAND COMMAND | ||
2 | Ss 0 1 0 167244 7144 0.1 26-03:07:26 systemd /lib/systemd/systemd --system --deserialize 17 | ||
3 | S 0 2 0 0 0 0.0 26-03:07:26 kthreadd [kthreadd] | ||
4 | I< 0 3 2 0 0 0.0 26-03:07:26 rcu_gp [rcu_gp] | ||
5 | I< 0 4 2 0 0 0.0 26-03:07:26 rcu_par_gp [rcu_par_gp] | ||
6 | I< 0 6 2 0 0 0.0 26-03:07:26 kworker/0:0H-ev [kworker/0:0H-events_highpri] | ||
7 | I< 0 9 2 0 0 0.0 26-03:07:26 mm_percpu_wq [mm_percpu_wq] | ||
8 | S 0 10 2 0 0 0.0 26-03:07:26 rcu_tasks_rude_ [rcu_tasks_rude_] | ||
9 | S 0 11 2 0 0 0.0 26-03:07:26 rcu_tasks_trace [rcu_tasks_trace] | ||
10 | S 0 12 2 0 0 0.0 26-03:07:26 ksoftirqd/0 [ksoftirqd/0] | ||
11 | I 0 13 2 0 0 0.0 26-03:07:26 rcu_sched [rcu_sched] | ||
12 | S 0 14 2 0 0 0.0 26-03:07:26 migration/0 [migration/0] | ||
13 | S 0 15 2 0 0 0.0 26-03:07:26 cpuhp/0 [cpuhp/0] | ||
14 | S 0 16 2 0 0 0.0 26-03:07:26 cpuhp/1 [cpuhp/1] | ||
15 | S 0 17 2 0 0 0.0 26-03:07:26 migration/1 [migration/1] | ||
16 | S 0 18 2 0 0 0.0 26-03:07:26 ksoftirqd/1 [ksoftirqd/1] | ||
17 | I< 0 20 2 0 0 0.0 26-03:07:26 kworker/1:0H-ev [kworker/1:0H-events_highpri] | ||
18 | S 0 21 2 0 0 0.0 26-03:07:26 cpuhp/2 [cpuhp/2] | ||
19 | S 0 22 2 0 0 0.0 26-03:07:26 migration/2 [migration/2] | ||
20 | S 0 23 2 0 0 0.0 26-03:07:26 ksoftirqd/2 [ksoftirqd/2] | ||
21 | I< 0 25 2 0 0 0.0 26-03:07:26 kworker/2:0H-ev [kworker/2:0H-events_highpri] | ||
22 | S 0 26 2 0 0 0.0 26-03:07:26 cpuhp/3 [cpuhp/3] | ||
23 | S 0 27 2 0 0 0.0 26-03:07:26 migration/3 [migration/3] | ||
24 | S 0 28 2 0 0 0.0 26-03:07:26 ksoftirqd/3 [ksoftirqd/3] | ||
25 | I< 0 30 2 0 0 0.0 26-03:07:26 kworker/3:0H-ev [kworker/3:0H-events_highpri] | ||
26 | S 0 35 2 0 0 0.0 26-03:07:26 kdevtmpfs [kdevtmpfs] | ||
27 | I< 0 36 2 0 0 0.0 26-03:07:26 netns [netns] | ||
28 | S 0 37 2 0 0 0.0 26-03:07:26 kauditd [kauditd] | ||
29 | S 0 38 2 0 0 0.0 26-03:07:26 khungtaskd [khungtaskd] | ||
30 | S 0 39 2 0 0 0.0 26-03:07:26 oom_reaper [oom_reaper] | ||
31 | I< 0 40 2 0 0 0.0 26-03:07:26 writeback [writeback] | ||
32 | S 0 41 2 0 0 0.0 26-03:07:26 kcompactd0 [kcompactd0] | ||
33 | SN 0 42 2 0 0 0.0 26-03:07:26 ksmd [ksmd] | ||
34 | SN 0 43 2 0 0 0.0 26-03:07:26 khugepaged [khugepaged] | ||
35 | I< 0 62 2 0 0 0.0 26-03:07:26 kintegrityd [kintegrityd] | ||
36 | I< 0 63 2 0 0 0.0 26-03:07:26 kblockd [kblockd] | ||
37 | I< 0 64 2 0 0 0.0 26-03:07:26 blkcg_punt_bio [blkcg_punt_bio] | ||
38 | I< 0 65 2 0 0 0.0 26-03:07:26 edac-poller [edac-poller] | ||
39 | I< 0 66 2 0 0 0.0 26-03:07:26 devfreq_wq [devfreq_wq] | ||
40 | I< 0 67 2 0 0 0.0 26-03:07:26 kworker/2:1H-ev [kworker/2:1H-events_highpri] | ||
41 | S 0 70 2 0 0 0.3 26-03:07:25 kswapd0 [kswapd0] | ||
42 | I< 0 71 2 0 0 0.0 26-03:07:25 kthrotld [kthrotld] | ||
43 | I< 0 72 2 0 0 0.0 26-03:07:25 acpi_thermal_pm [acpi_thermal_pm] | ||
44 | I< 0 74 2 0 0 0.0 26-03:07:25 ipv6_addrconf [ipv6_addrconf] | ||
45 | I< 0 80 2 0 0 0.0 26-03:07:25 kworker/3:1H-ev [kworker/3:1H-events_highpri] | ||
46 | I< 0 84 2 0 0 0.0 26-03:07:25 kstrp [kstrp] | ||
47 | I< 0 87 2 0 0 0.0 26-03:07:25 zswap-shrink [zswap-shrink] | ||
48 | I< 0 110 2 0 0 0.0 26-03:07:25 kworker/0:1H-ev [kworker/0:1H-events_highpri] | ||
49 | I< 0 141 2 0 0 0.0 26-03:07:25 ata_sff [ata_sff] | ||
50 | S 0 143 2 0 0 0.0 26-03:07:25 scsi_eh_0 [scsi_eh_0] | ||
51 | I< 0 144 2 0 0 0.0 26-03:07:25 scsi_tmf_0 [scsi_tmf_0] | ||
52 | S 0 145 2 0 0 0.0 26-03:07:25 scsi_eh_1 [scsi_eh_1] | ||
53 | I< 0 146 2 0 0 0.0 26-03:07:25 scsi_tmf_1 [scsi_tmf_1] | ||
54 | S 0 147 2 0 0 0.0 26-03:07:25 scsi_eh_2 [scsi_eh_2] | ||
55 | I< 0 148 2 0 0 0.0 26-03:07:25 scsi_tmf_2 [scsi_tmf_2] | ||
56 | S 0 149 2 0 0 0.0 26-03:07:25 scsi_eh_3 [scsi_eh_3] | ||
57 | I< 0 150 2 0 0 0.0 26-03:07:25 scsi_tmf_3 [scsi_tmf_3] | ||
58 | S 0 151 2 0 0 0.0 26-03:07:25 scsi_eh_4 [scsi_eh_4] | ||
59 | I< 0 152 2 0 0 0.0 26-03:07:25 scsi_tmf_4 [scsi_tmf_4] | ||
60 | S 0 153 2 0 0 0.0 26-03:07:25 scsi_eh_5 [scsi_eh_5] | ||
61 | I< 0 154 2 0 0 0.0 26-03:07:25 scsi_tmf_5 [scsi_tmf_5] | ||
62 | S 0 158 2 0 0 0.0 26-03:07:25 card0-crtc0 [card0-crtc0] | ||
63 | S 0 159 2 0 0 0.0 26-03:07:25 card0-crtc1 [card0-crtc1] | ||
64 | S 0 160 2 0 0 0.0 26-03:07:25 card0-crtc2 [card0-crtc2] | ||
65 | I< 0 162 2 0 0 0.0 26-03:07:25 kworker/1:1H-ev [kworker/1:1H-events_highpri] | ||
66 | S 0 163 2 0 0 0.0 26-03:07:25 scsi_eh_6 [scsi_eh_6] | ||
67 | I< 0 164 2 0 0 0.0 26-03:07:25 scsi_tmf_6 [scsi_tmf_6] | ||
68 | S 0 165 2 0 0 0.0 26-03:07:25 usb-storage [usb-storage] | ||
69 | I< 0 167 2 0 0 0.0 26-03:07:25 uas [uas] | ||
70 | I< 0 176 2 0 0 0.0 26-03:07:25 kdmflush [kdmflush] | ||
71 | I< 0 177 2 0 0 0.0 26-03:07:25 kdmflush [kdmflush] | ||
72 | S 0 202 2 0 0 0.0 26-03:07:24 scsi_eh_7 [scsi_eh_7] | ||
73 | I< 0 203 2 0 0 0.0 26-03:07:24 scsi_tmf_7 [scsi_tmf_7] | ||
74 | S 0 204 2 0 0 0.0 26-03:07:24 usb-storage [usb-storage] | ||
75 | I< 0 232 2 0 0 0.0 26-03:07:23 btrfs-worker [btrfs-worker] | ||
76 | I< 0 233 2 0 0 0.0 26-03:07:23 btrfs-worker-hi [btrfs-worker-hi] | ||
77 | I< 0 234 2 0 0 0.0 26-03:07:23 btrfs-delalloc [btrfs-delalloc] | ||
78 | I< 0 235 2 0 0 0.0 26-03:07:23 btrfs-flush_del [btrfs-flush_del] | ||
79 | I< 0 236 2 0 0 0.0 26-03:07:23 btrfs-cache [btrfs-cache] | ||
80 | I< 0 237 2 0 0 0.0 26-03:07:23 btrfs-fixup [btrfs-fixup] | ||
81 | I< 0 238 2 0 0 0.0 26-03:07:23 btrfs-endio [btrfs-endio] | ||
82 | I< 0 239 2 0 0 0.0 26-03:07:23 btrfs-endio-met [btrfs-endio-met] | ||
83 | I< 0 240 2 0 0 0.0 26-03:07:23 btrfs-endio-met [btrfs-endio-met] | ||
84 | I< 0 241 2 0 0 0.0 26-03:07:23 btrfs-endio-rai [btrfs-endio-rai] | ||
85 | I< 0 242 2 0 0 0.0 26-03:07:23 btrfs-rmw [btrfs-rmw] | ||
86 | I< 0 243 2 0 0 0.0 26-03:07:23 btrfs-endio-wri [btrfs-endio-wri] | ||
87 | I< 0 244 2 0 0 0.0 26-03:07:23 btrfs-freespace [btrfs-freespace] | ||
88 | I< 0 245 2 0 0 0.0 26-03:07:23 btrfs-delayed-m [btrfs-delayed-m] | ||
89 | I< 0 246 2 0 0 0.0 26-03:07:23 btrfs-readahead [btrfs-readahead] | ||
90 | I< 0 247 2 0 0 0.0 26-03:07:23 btrfs-qgroup-re [btrfs-qgroup-re] | ||
91 | S 0 248 2 0 0 0.0 26-03:07:23 btrfs-cleaner [btrfs-cleaner] | ||
92 | S 0 249 2 0 0 0.2 26-03:07:23 btrfs-transacti [btrfs-transacti] | ||
93 | I< 0 317 2 0 0 0.0 26-03:07:22 rpciod [rpciod] | ||
94 | I< 0 322 2 0 0 0.0 26-03:07:22 xprtiod [xprtiod] | ||
95 | S 0 381 2 0 0 0.0 26-03:07:22 irq/133-mei_me [irq/133-mei_me] | ||
96 | S 0 422 2 0 0 0.0 26-03:07:22 watchdogd [watchdogd] | ||
97 | I< 0 523 2 0 0 0.0 26-03:07:22 led_workqueue [led_workqueue] | ||
98 | I< 0 583 2 0 0 0.0 26-03:07:22 cryptd [cryptd] | ||
99 | I< 0 590 2 0 0 0.0 26-03:07:22 ext4-rsv-conver [ext4-rsv-conver] | ||
100 | Ss 104 693 1 12324 4292 0.5 26-03:07:21 dbus-daemon /usr/bin/dbus-daemon --system --address=systemd: --nofork --nopidfile --systemd-activation --syslog-only | ||
101 | Ss 0 731 1 575120 1368 0.0 26-03:07:21 systemd-logind /lib/systemd/systemd-logind | ||
102 | Ssl 0 1111 1 121248 732 0.0 26-03:07:18 unattended-upgr /usr/bin/python3 /usr/share/unattended-upgrades/unattended-upgrade-shutdown --wait-for-signal | ||
103 | S 0 1141 2 0 0 0.0 26-03:07:18 lockd [lockd] | ||
104 | I< 0 1459 2 0 0 0.0 26-03:07:16 nfsiod [nfsiod] | ||
105 | S 0 1621 2 0 0 0.0 26-03:07:15 NFSv4 callback [NFSv4 callback] | ||
106 | Ssl 0 1771 1 1548340 676 0.0 26-03:07:13 libvirtd /usr/sbin/libvirtd | ||
107 | I< 0 24315 2 0 0 0.0 26-02:49:02 cifsiod [cifsiod] | ||
108 | I< 0 24316 2 0 0 0.0 26-02:49:02 smb3decryptd [smb3decryptd] | ||
109 | I< 0 24317 2 0 0 0.0 26-02:49:02 cifsfileinfoput [cifsfileinfoput] | ||
110 | I< 0 24318 2 0 0 0.0 26-02:49:02 cifsoplockd [cifsoplockd] | ||
111 | I< 0 24319 2 0 0 0.0 26-02:49:02 cifs-dfscache [cifs-dfscache] | ||
112 | S 0 24322 2 0 0 0.0 26-02:49:02 cifsd [cifsd] | ||
113 | I< 0 24413 2 0 0 0.0 26-02:48:57 btrfs-worker [btrfs-worker] | ||
114 | I< 0 24414 2 0 0 0.0 26-02:48:57 btrfs-worker-hi [btrfs-worker-hi] | ||
115 | I< 0 24415 2 0 0 0.0 26-02:48:57 btrfs-delalloc [btrfs-delalloc] | ||
116 | I< 0 24416 2 0 0 0.0 26-02:48:57 btrfs-flush_del [btrfs-flush_del] | ||
117 | I< 0 24418 2 0 0 0.0 26-02:48:57 btrfs-cache [btrfs-cache] | ||
118 | I< 0 24419 2 0 0 0.0 26-02:48:57 btrfs-fixup [btrfs-fixup] | ||
119 | I< 0 24420 2 0 0 0.0 26-02:48:57 btrfs-endio [btrfs-endio] | ||
120 | I< 0 24421 2 0 0 0.0 26-02:48:57 btrfs-endio-met [btrfs-endio-met] | ||
121 | I< 0 24422 2 0 0 0.0 26-02:48:57 btrfs-endio-met [btrfs-endio-met] | ||
122 | I< 0 24423 2 0 0 0.0 26-02:48:57 btrfs-endio-rai [btrfs-endio-rai] | ||
123 | I< 0 24424 2 0 0 0.0 26-02:48:57 btrfs-rmw [btrfs-rmw] | ||
124 | I< 0 24425 2 0 0 0.0 26-02:48:57 btrfs-endio-wri [btrfs-endio-wri] | ||
125 | I< 0 24426 2 0 0 0.0 26-02:48:57 btrfs-freespace [btrfs-freespace] | ||
126 | I< 0 24427 2 0 0 0.0 26-02:48:57 btrfs-delayed-m [btrfs-delayed-m] | ||
127 | I< 0 24428 2 0 0 0.0 26-02:48:57 btrfs-readahead [btrfs-readahead] | ||
128 | I< 0 24429 2 0 0 0.0 26-02:48:57 btrfs-qgroup-re [btrfs-qgroup-re] | ||
129 | S 0 24450 2 0 0 0.0 26-02:48:53 btrfs-cleaner [btrfs-cleaner] | ||
130 | S 0 24451 2 0 0 0.0 26-02:48:53 btrfs-transacti [btrfs-transacti] | ||
131 | I< 0 747708 2 0 0 0.0 16-21:06:20 xfsalloc [xfsalloc] | ||
132 | I< 0 747709 2 0 0 0.0 16-21:06:20 xfs_mru_cache [xfs_mru_cache] | ||
133 | S 0 747713 2 0 0 0.0 16-21:06:20 jfsIO [jfsIO] | ||
134 | S 0 747714 2 0 0 0.0 16-21:06:20 jfsCommit [jfsCommit] | ||
135 | S 0 747715 2 0 0 0.0 16-21:06:20 jfsCommit [jfsCommit] | ||
136 | S 0 747716 2 0 0 0.0 16-21:06:20 jfsCommit [jfsCommit] | ||
137 | S 0 747717 2 0 0 0.0 16-21:06:20 jfsCommit [jfsCommit] | ||
138 | S 0 747718 2 0 0 0.0 16-21:06:20 jfsSync [jfsSync] | ||
139 | Ss 0 1071687 1 105976 28304 0.0 3-03:12:31 systemd-journal /lib/systemd/systemd-journald | ||
140 | Ss 0 1934146 1 25672 4704 0.0 11:19:31 cupsd /usr/sbin/cupsd -l | ||
141 | Ssl 0 1934148 1 182868 8540 0.0 11:19:31 cups-browsed /usr/sbin/cups-browsed | ||
142 | S 13 1934155 3392655 5752 88 0.0 11:19:31 pinger (pinger) | ||
143 | S< 33 1934166 3393034 57996 5460 0.0 11:19:31 apache2 /usr/sbin/apache2 -k start | ||
144 | S< 33 1934167 3393034 216944 13892 0.0 11:19:30 apache2 /usr/sbin/apache2 -k start | ||
145 | S< 33 1934168 3393034 216944 13756 0.0 11:19:30 apache2 /usr/sbin/apache2 -k start | ||
146 | S< 33 1934169 3393034 216936 13732 0.0 11:19:30 apache2 /usr/sbin/apache2 -k start | ||
147 | S< 33 1934170 3393034 216944 13888 0.0 11:19:30 apache2 /usr/sbin/apache2 -k start | ||
148 | S< 33 1934172 3393034 216944 15388 0.0 11:19:30 apache2 /usr/sbin/apache2 -k start | ||
149 | S< 33 1934701 3393034 216936 13736 0.0 11:19:29 apache2 /usr/sbin/apache2 -k start | ||
150 | S< 33 1935056 3393034 216920 13724 0.0 11:19:28 apache2 /usr/sbin/apache2 -k start | ||
151 | S 7 1936834 1934146 16652 832 0.0 11:18:12 dbus /usr/lib/cups/notifier/dbus dbus:// | ||
152 | S< 33 1955909 3393034 216928 13792 0.0 11:00:25 apache2 /usr/sbin/apache2 -k start | ||
153 | I< 0 2531464 2 0 0 0.0 06:35:47 kworker/u9:0-i9 [kworker/u9:0-i915_flip] | ||
154 | I 0 2570506 2 0 0 0.0 06:27:41 kworker/1:0-cgr [kworker/1:0-cgroup_destroy] | ||
155 | I 0 2596195 2 0 0 0.0 06:21:52 kworker/1:1-eve [kworker/1:1-events] | ||
156 | I 0 2785341 2 0 0 0.0 03:34:16 kworker/u8:8-bt [kworker/u8:8-btrfs-endio-write] | ||
157 | I 0 2785520 2 0 0 0.0 03:33:50 kworker/3:0-eve [kworker/3:0-events] | ||
158 | I 0 2798669 2 0 0 0.0 03:21:09 kworker/u8:5-bt [kworker/u8:5-btrfs-endio-write] | ||
159 | Ss 0 2803015 1 5616 3108 0.0 03:17:54 cron /usr/sbin/cron -f | ||
160 | I 0 2845483 2 0 0 0.0 02:38:11 kworker/0:3-eve [kworker/0:3-events] | ||
161 | I 0 2939490 2 0 0 0.1 01:10:32 kworker/0:0-eve [kworker/0:0-events] | ||
162 | I 0 2939754 2 0 0 0.0 01:10:26 kworker/u8:1-i9 [kworker/u8:1-i915] | ||
163 | I 0 2942040 2 0 0 0.0 01:08:02 kworker/u8:7-bt [kworker/u8:7-btrfs-endio-meta] | ||
164 | S 117 2954268 3392551 40044 5772 0.0 56:37 pickup pickup -l -t unix -u -c | ||
165 | I 0 2965195 2 0 0 0.0 46:00 kworker/u8:0-bt [kworker/u8:0-btrfs-worker] | ||
166 | I 0 2977972 2 0 0 0.0 33:54 kworker/u8:2-bt [kworker/u8:2-btrfs-endio-write] | ||
167 | I 0 2985488 2 0 0 0.0 27:02 kworker/u8:3-bl [kworker/u8:3-blkcg_punt_bio] | ||
168 | I 0 2987519 2 0 0 1.0 25:15 kworker/2:1-eve [kworker/2:1-events] | ||
169 | I 0 2987601 2 0 0 0.0 25:03 kworker/u8:9-i9 [kworker/u8:9-i915] | ||
170 | I< 0 2995218 2 0 0 0.0 18:41 kworker/u9:2-xp [kworker/u9:2-xprtiod] | ||
171 | I 0 2997170 2 0 0 0.0 16:41 kworker/3:1-rcu [kworker/3:1-rcu_gp] | ||
172 | I 0 3001264 2 0 0 0.0 13:01 kworker/u8:4-bt [kworker/u8:4-btrfs-endio-write] | ||
173 | I 0 3004697 2 0 0 0.7 09:41 kworker/2:0-eve [kworker/2:0-events] | ||
174 | I 0 3010619 2 0 0 1.0 04:29 kworker/2:2-eve [kworker/2:2-events] | ||
175 | I 0 3014612 2 0 0 0.0 00:41 kworker/3:2-eve [kworker/3:2-events] | ||
176 | S 0 3015082 2803015 6716 3028 0.0 00:30 cron /usr/sbin/CRON -f | ||
177 | I 0 3015382 2 0 0 0.0 00:00 kworker/u8:6-bt [kworker/u8:6-btrfs-endio-meta] | ||
178 | Ss 1 3392068 1 5592 504 0.0 15-02:34:39 atd /usr/sbin/atd -f | ||
179 | Ssl 0 3392072 1 235796 1740 0.0 15-02:34:39 accounts-daemon /usr/libexec/accounts-daemon | ||
180 | Ssl 106 3392076 1 315708 6128 0.0 15-02:34:39 colord /usr/libexec/colord | ||
181 | Ss 0 3392083 1 8120 720 0.0 15-02:34:39 haveged /usr/sbin/haveged --Foreground --verbose=1 | ||
182 | Ss 0 3392090 1 5168 132 0.0 15-02:34:39 blkmapd /usr/sbin/blkmapd | ||
183 | SNsl 111 3392094 1 155648 440 0.0 15-02:34:39 rtkit-daemon /usr/libexec/rtkit-daemon | ||
184 | Ssl 0 3392097 1 290168 1352 0.0 15-02:34:39 packagekitd /usr/libexec/packagekitd | ||
185 | Ss 128 3392100 1 7960 448 0.0 15-02:34:39 rpcbind /sbin/rpcbind -f -w | ||
186 | Ss 0 3392114 1 13432 616 0.0 15-02:34:39 systemd-machine /lib/systemd/systemd-machined | ||
187 | Ss 0 3392118 1 13316 848 0.0 15-02:34:39 sshd sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups | ||
188 | Ssl 0 3392124 1 244072 2456 0.0 15-02:34:39 upowerd /usr/libexec/upowerd | ||
189 | Ssl 0 3392138 1 1634748 10684 0.0 15-02:34:39 containerd /usr/bin/containerd | ||
190 | Ssl 0 3392139 1 222768 1784 0.0 15-02:34:39 rsyslogd /usr/sbin/rsyslogd -n -iNONE | ||
191 | Ss 13 3392140 1 3344 152 0.0 15-02:34:39 polipo /usr/bin/polipo -c /etc/polipo/config pidFile=/var/run/polipo/polipo.pid daemonise=true | ||
192 | Ssl 119 3392156 1 76472 1688 0.0 15-02:34:39 ntpd /usr/sbin/ntpd -p /var/run/ntpd.pid -g -u 119:126 | ||
193 | Ss 120 3392168 1 4656 276 0.0 15-02:34:39 rpc.statd /sbin/rpc.statd --no-notify | ||
194 | Ss 0 3392171 1 5072 432 0.0 15-02:34:39 rpc.mountd /usr/sbin/rpc.mountd --manage-gids | ||
195 | Ss 0 3392176 1 5008 288 0.0 15-02:34:39 rpc.idmapd /usr/sbin/rpc.idmapd | ||
196 | Ss 105 3392184 1 15544 6816 3.5 15-02:34:39 avahi-daemon avahi-daemon: running [tsui.local] | ||
197 | Ss 0 3392186 1 25288 3860 0.0 15-02:34:39 systemd-udevd /lib/systemd/systemd-udevd | ||
198 | S 105 3392190 3392184 8788 52 0.0 15-02:34:39 avahi-daemon avahi-daemon: chroot helper | ||
199 | Ssl 0 3392197 1 396120 4188 0.0 15-02:34:39 udisksd /usr/libexec/udisks2/udisksd | ||
200 | Ssl 0 3392214 1 237504 6632 0.0 15-02:34:39 polkitd /usr/libexec/polkitd --no-debug | ||
201 | Ss 0 3392284 1 9684 560 0.0 15-02:34:38 xinetd /usr/sbin/xinetd -pidfile /run/xinetd.pid -stayalive -inetd_compat -inetd_ipv6 | ||
202 | Ssl 0 3392285 1 314840 1352 0.0 15-02:34:38 ModemManager /usr/sbin/ModemManager | ||
203 | Ss 0 3392317 1 2352 140 0.0 15-02:34:38 acpid /usr/sbin/acpid | ||
204 | S 0 3392400 2 0 0 0.0 15-02:34:38 nfsd [nfsd] | ||
205 | S 0 3392401 2 0 0 0.0 15-02:34:38 nfsd [nfsd] | ||
206 | S 0 3392402 2 0 0 0.0 15-02:34:38 nfsd [nfsd] | ||
207 | S 0 3392403 2 0 0 0.0 15-02:34:38 nfsd [nfsd] | ||
208 | S 0 3392404 2 0 0 0.0 15-02:34:38 nfsd [nfsd] | ||
209 | S 0 3392405 2 0 0 0.0 15-02:34:38 nfsd [nfsd] | ||
210 | S 0 3392407 2 0 0 0.0 15-02:34:38 nfsd [nfsd] | ||
211 | S 0 3392410 2 0 0 0.0 15-02:34:38 nfsd [nfsd] | ||
212 | Ss 0 3392551 1 40092 1304 0.0 15-02:34:37 master /usr/lib/postfix/sbin/master -w | ||
213 | S 117 3392553 3392551 40156 568 0.0 15-02:34:37 qmgr qmgr -l -t unix -u | ||
214 | Ss 0 3392650 1 63652 4 0.0 15-02:34:36 squid /usr/sbin/squid --foreground -sYC | ||
215 | Ssl 116 3392652 1 1675196 93848 0.0 15-02:34:36 mariadbd /usr/sbin/mariadbd | ||
216 | S 13 3392655 3392650 81776 21232 0.0 15-02:34:36 squid (squid-1) --kid squid-1 --foreground -sYC | ||
217 | S 13 3392657 3392655 5572 68 0.0 15-02:34:36 log_file_daemon (logfile-daemon) /var/log/squid/access.log | ||
218 | S<s 0 3393034 1 216648 7560 0.0 15-02:34:34 apache2 /usr/sbin/apache2 -k start | ||
219 | Ss 33 3393037 1 3432 180 0.0 15-02:34:34 htcacheclean /usr/bin/htcacheclean -d 120 -p /var/cache/apache2/mod_cache_disk -l 300M -n | ||
diff --git a/plugins/tests/var/ps_axwo.debian b/plugins/tests/var/ps_axwo.debian deleted file mode 100644 index 37a2d35e..00000000 --- a/plugins/tests/var/ps_axwo.debian +++ /dev/null | |||
@@ -1,84 +0,0 @@ | |||
1 | STAT UID PID PPID VSZ RSS %CPU COMMAND COMMAND | ||
2 | S 0 1 0 1504 428 0.0 init init [2] | ||
3 | SN 0 2 1 0 0 0.0 ksoftirqd/0 [ksoftirqd/0] | ||
4 | S< 0 3 1 0 0 0.0 events/0 [events/0] | ||
5 | S< 0 4 3 0 0 0.0 khelper [khelper] | ||
6 | S< 0 5 3 0 0 0.0 kacpid [kacpid] | ||
7 | S< 0 38 3 0 0 0.0 kblockd/0 [kblockd/0] | ||
8 | S 0 48 3 0 0 0.0 pdflush [pdflush] | ||
9 | S< 0 51 3 0 0 0.0 aio/0 [aio/0] | ||
10 | S 0 50 1 0 0 0.0 kswapd0 [kswapd0] | ||
11 | S 0 193 1 0 0 0.0 kseriod [kseriod] | ||
12 | S 0 214 1 0 0 0.0 scsi_eh_0 [scsi_eh_0] | ||
13 | S 0 221 1 0 0 0.0 khubd [khubd] | ||
14 | S 0 299 1 0 0 0.3 kjournald [kjournald] | ||
15 | S 0 1148 1 0 0 0.0 pciehpd_event [pciehpd_event] | ||
16 | S 0 1168 1 0 0 0.0 shpchpd_event [shpchpd_event] | ||
17 | Ss 1 1795 1 1612 276 0.0 portmap /sbin/portmap | ||
18 | Ss 0 2200 1 1652 568 0.0 vmware-guestd /usr/sbin/vmware-guestd --background /var/run/vmware-guestd.pid | ||
19 | Ss 0 2209 1 2240 532 0.0 inetd /usr/sbin/inetd | ||
20 | Ss 0 2319 1 3468 792 0.0 sshd /usr/sbin/sshd | ||
21 | Ss 0 2323 1 2468 676 0.0 rpc.statd /sbin/rpc.statd | ||
22 | Ss 1 2332 1 1684 488 0.0 atd /usr/sbin/atd | ||
23 | Ss 0 2335 1 1764 636 0.0 cron /usr/sbin/cron | ||
24 | Ss+ 0 2350 1 1500 348 0.0 getty /sbin/getty 38400 tty1 | ||
25 | Ss+ 0 2351 1 1500 348 0.0 getty /sbin/getty 38400 tty2 | ||
26 | Ss+ 0 2352 1 1500 348 0.0 getty /sbin/getty 38400 tty3 | ||
27 | Ss+ 0 2353 1 1500 348 0.0 getty /sbin/getty 38400 tty4 | ||
28 | Ss+ 0 2354 1 1500 348 0.0 getty /sbin/getty 38400 tty5 | ||
29 | Ss+ 0 2355 1 1500 348 0.0 getty /sbin/getty 38400 tty6 | ||
30 | S 0 6907 1 2308 892 0.0 mysqld_safe /bin/sh /usr/bin/mysqld_safe | ||
31 | S 103 6944 6907 123220 27724 0.0 mysqld /usr/sbin/mysqld --basedir=/usr --datadir=/var/lib/mysql --user=mysql --pid-file=/var/run/mysqld/mysqld.pid --skip-locking --port=3306 --socket=/var/run/mysqld/mysqld.sock | ||
32 | S 0 6945 6907 1488 420 0.0 logger logger -p daemon.err -t mysqld_safe -i -t mysqld | ||
33 | S 1001 17778 1 6436 1588 0.0 snmpd /usr/sbin/snmpd -u nagios -Lsd -Lf /dev/null -p/var/run/snmpd.pid | ||
34 | Ss 0 17789 1 9496 5556 0.0 snmptrapd /usr/sbin/snmptrapd -t -m ALL -M /usr/share/snmp/mibs:/usr/local/monitoring/snmp/load -p /var/run/snmptrapd.pid | ||
35 | Ss 0 847 2319 14452 1752 0.0 sshd sshd: tonvoon [priv] | ||
36 | S 1000 857 847 14616 1832 0.0 sshd sshd: tonvoon@pts/3 | ||
37 | Ss 1000 860 857 2984 1620 0.0 bash -bash | ||
38 | S 0 868 860 2588 1428 0.0 bash -su | ||
39 | S+ 1001 877 868 2652 1568 0.0 bash -su | ||
40 | S 0 6086 3 0 0 0.0 pdflush [pdflush] | ||
41 | Ss 0 17832 2319 14452 1752 0.0 sshd sshd: tonvoon [priv] | ||
42 | S 1000 18155 17832 14620 1840 0.0 sshd sshd: tonvoon@pts/0 | ||
43 | Ss 1000 18156 18155 2984 1620 0.0 bash -bash | ||
44 | S 0 18518 18156 2588 1428 0.0 bash -su | ||
45 | S 1001 18955 18518 2672 1600 0.0 bash -su | ||
46 | Ss 0 21683 2319 14452 1756 0.0 sshd sshd: tonvoon [priv] | ||
47 | S 1000 21742 21683 14620 1896 0.0 sshd sshd: tonvoon@pts/1 | ||
48 | Ss 1000 21743 21742 2984 1620 0.0 bash -bash | ||
49 | S 0 21748 21743 2592 1432 0.0 bash -su | ||
50 | S 1001 21757 21748 2620 1540 0.0 bash -su | ||
51 | Ss 0 2334 2319 14452 1756 0.0 sshd sshd: tonvoon [priv] | ||
52 | S 1000 2343 2334 14620 1840 0.0 sshd sshd: tonvoon@pts/2 | ||
53 | Ss 1000 2344 2343 2984 1620 0.0 bash -bash | ||
54 | S 0 2349 2344 2592 1432 0.0 bash -su | ||
55 | S+ 1001 2364 2349 2620 1520 0.0 bash -su | ||
56 | T 1001 2454 2364 2096 1032 0.0 vi vi configure.in.rej | ||
57 | S+ 1001 8500 21757 69604 52576 0.0 opsview_web_ser /usr/bin/perl -w ./script/opsview_web_server.pl -f -d | ||
58 | Ss 0 7609 2319 14452 1756 0.0 sshd sshd: tonvoon [priv] | ||
59 | S 1000 7617 7609 14460 1828 0.0 sshd sshd: tonvoon@pts/4 | ||
60 | Ss 1000 7618 7617 2984 1620 0.0 bash -bash | ||
61 | S 0 7623 7618 2592 1432 0.0 bash -su | ||
62 | S+ 1001 7632 7623 2620 1528 0.0 bash -su | ||
63 | Ss 1001 12678 1 20784 17728 0.0 opsviewd opsviewd | ||
64 | Ss 0 832 1 14512 6360 0.0 apache2 /usr/sbin/apache2 -k start -DSSL | ||
65 | S 33 842 832 14648 6596 0.0 apache2 /usr/sbin/apache2 -k start -DSSL | ||
66 | S 33 843 832 14512 6504 0.0 apache2 /usr/sbin/apache2 -k start -DSSL | ||
67 | S 33 844 832 14512 6476 0.0 apache2 /usr/sbin/apache2 -k start -DSSL | ||
68 | S 33 845 832 14512 6476 0.0 apache2 /usr/sbin/apache2 -k start -DSSL | ||
69 | S 33 846 832 14512 6476 0.0 apache2 /usr/sbin/apache2 -k start -DSSL | ||
70 | Ss 7 4081 1 2464 884 0.0 lpd /usr/sbin/lpd -s | ||
71 | S 33 26484 832 14512 6476 0.0 apache2 /usr/sbin/apache2 -k start -DSSL | ||
72 | Ss 1001 22324 1 20252 1612 0.1 nagios ../../bin/nagios -d /usr/local/nagios/etc/nagios.cfg | ||
73 | Ss 0 23336 2319 14452 1756 0.0 sshd sshd: tonvoon [priv] | ||
74 | S 1000 23339 23336 14620 1840 0.0 sshd sshd: tonvoon@pts/5 | ||
75 | Ss 1000 23340 23339 2996 1636 0.0 bash -bash | ||
76 | S 0 23367 23340 3020 1628 0.0 bash bash | ||
77 | S 1001 23370 23367 3064 1748 0.0 bash bash | ||
78 | Ss 1001 23783 1 3220 764 0.0 ndo2db /usr/local/nagios/bin/ndo2db -c /usr/local/nagios/etc/ndo2db.cfg | ||
79 | Ss 1001 23784 1 6428 4948 0.0 import_ndologsd import_ndologsd | ||
80 | S+ 1001 9803 18955 4132 1936 0.0 ssh ssh altinity@cube02.lei.altinity | ||
81 | S 1001 22505 22324 20256 1616 0.0 nagios ../../bin/nagios -d /usr/local/nagios/etc/nagios.cfg | ||
82 | S 1001 22506 22505 1676 608 0.0 check_ping /usr/local/libexec/check_ping -H 192.168.10.23 -w 3000.0,80% -c 5000.0,100% -p 1 | ||
83 | S 1001 22507 22506 1660 492 0.0 ping /bin/ping -n -U -w 10 -c 1 192.168.10.23 | ||
84 | R+ 1001 22508 23370 2308 680 0.0 ps ps axwo stat uid pid ppid vsz rss pcpu comm args | ||
diff --git a/plugins/utils.c b/plugins/utils.c index 231af92b..17dd5814 100644 --- a/plugins/utils.c +++ b/plugins/utils.c | |||
@@ -27,6 +27,8 @@ | |||
27 | #include "utils_base.h" | 27 | #include "utils_base.h" |
28 | #include <stdarg.h> | 28 | #include <stdarg.h> |
29 | #include <limits.h> | 29 | #include <limits.h> |
30 | #include <string.h> | ||
31 | #include <errno.h> | ||
30 | 32 | ||
31 | #include <arpa/inet.h> | 33 | #include <arpa/inet.h> |
32 | 34 | ||
@@ -36,9 +38,6 @@ extern const char *progname; | |||
36 | #define STRLEN 64 | 38 | #define STRLEN 64 |
37 | #define TXTBLK 128 | 39 | #define TXTBLK 128 |
38 | 40 | ||
39 | unsigned int timeout_state = STATE_CRITICAL; | ||
40 | unsigned int timeout_interval = DEFAULT_SOCKET_TIMEOUT; | ||
41 | |||
42 | time_t start_time, end_time; | 41 | time_t start_time, end_time; |
43 | 42 | ||
44 | /* ************************************************************************** | 43 | /* ************************************************************************** |
@@ -148,33 +147,6 @@ print_revision (const char *command_name, const char *revision) | |||
148 | command_name, revision, PACKAGE, VERSION); | 147 | command_name, revision, PACKAGE, VERSION); |
149 | } | 148 | } |
150 | 149 | ||
151 | const char * | ||
152 | state_text (int result) | ||
153 | { | ||
154 | switch (result) { | ||
155 | case STATE_OK: | ||
156 | return "OK"; | ||
157 | case STATE_WARNING: | ||
158 | return "WARNING"; | ||
159 | case STATE_CRITICAL: | ||
160 | return "CRITICAL"; | ||
161 | case STATE_DEPENDENT: | ||
162 | return "DEPENDENT"; | ||
163 | default: | ||
164 | return "UNKNOWN"; | ||
165 | } | ||
166 | } | ||
167 | |||
168 | void | ||
169 | timeout_alarm_handler (int signo) | ||
170 | { | ||
171 | if (signo == SIGALRM) { | ||
172 | printf (_("%s - Plugin timed out after %d seconds\n"), | ||
173 | state_text(timeout_state), timeout_interval); | ||
174 | exit (timeout_state); | ||
175 | } | ||
176 | } | ||
177 | |||
178 | int | 150 | int |
179 | is_numeric (char *number) | 151 | is_numeric (char *number) |
180 | { | 152 | { |
@@ -269,6 +241,46 @@ is_intnonneg (char *number) | |||
269 | return FALSE; | 241 | return FALSE; |
270 | } | 242 | } |
271 | 243 | ||
244 | /* | ||
245 | * Checks whether the number in the string _number_ can be put inside a int64_t | ||
246 | * On success the number will be written to the _target_ address, if _target_ is not set | ||
247 | * to NULL. | ||
248 | */ | ||
249 | int is_int64(char *number, int64_t *target) { | ||
250 | errno = 0; | ||
251 | uint64_t tmp = strtoll(number, NULL, 10); | ||
252 | if (errno != 0) { | ||
253 | return 0; | ||
254 | } | ||
255 | if (tmp < INT64_MIN || tmp > INT64_MAX) { | ||
256 | return 0; | ||
257 | } | ||
258 | if (target != NULL) { | ||
259 | *target = tmp; | ||
260 | } | ||
261 | return 1; | ||
262 | } | ||
263 | |||
264 | /* | ||
265 | * Checks whether the number in the string _number_ can be put inside a uint64_t | ||
266 | * On success the number will be written to the _target_ address, if _target_ is not set | ||
267 | * to NULL. | ||
268 | */ | ||
269 | int is_uint64(char *number, uint64_t *target) { | ||
270 | errno = 0; | ||
271 | uint64_t tmp = strtoll(number, NULL, 10); | ||
272 | if (errno != 0) { | ||
273 | return 0; | ||
274 | } | ||
275 | if (tmp < 0 || tmp > UINT64_MAX) { | ||
276 | return 0; | ||
277 | } | ||
278 | if (target != NULL) { | ||
279 | *target = tmp; | ||
280 | } | ||
281 | return 1; | ||
282 | } | ||
283 | |||
272 | int | 284 | int |
273 | is_intpercent (char *number) | 285 | is_intpercent (char *number) |
274 | { | 286 | { |
@@ -577,10 +589,94 @@ char *perfdata (const char *label, | |||
577 | xasprintf (&data, "%s;", data); | 589 | xasprintf (&data, "%s;", data); |
578 | 590 | ||
579 | if (minp) | 591 | if (minp) |
580 | xasprintf (&data, "%s%ld", data, minv); | 592 | xasprintf (&data, "%s%ld;", data, minv); |
593 | else | ||
594 | xasprintf (&data, "%s;", data); | ||
581 | 595 | ||
582 | if (maxp) | 596 | if (maxp) |
583 | xasprintf (&data, "%s;%ld", data, maxv); | 597 | xasprintf (&data, "%s%ld", data, maxv); |
598 | |||
599 | return data; | ||
600 | } | ||
601 | |||
602 | |||
603 | char *perfdata_uint64 (const char *label, | ||
604 | uint64_t val, | ||
605 | const char *uom, | ||
606 | int warnp, /* Warning present */ | ||
607 | uint64_t warn, | ||
608 | int critp, /* Critical present */ | ||
609 | uint64_t crit, | ||
610 | int minp, /* Minimum present */ | ||
611 | uint64_t minv, | ||
612 | int maxp, /* Maximum present */ | ||
613 | uint64_t maxv) | ||
614 | { | ||
615 | char *data = NULL; | ||
616 | |||
617 | if (strpbrk (label, "'= ")) | ||
618 | xasprintf (&data, "'%s'=%ld%s;", label, val, uom); | ||
619 | else | ||
620 | xasprintf (&data, "%s=%ld%s;", label, val, uom); | ||
621 | |||
622 | if (warnp) | ||
623 | xasprintf (&data, "%s%lu;", data, warn); | ||
624 | else | ||
625 | xasprintf (&data, "%s;", data); | ||
626 | |||
627 | if (critp) | ||
628 | xasprintf (&data, "%s%lu;", data, crit); | ||
629 | else | ||
630 | xasprintf (&data, "%s;", data); | ||
631 | |||
632 | if (minp) | ||
633 | xasprintf (&data, "%s%lu;", data, minv); | ||
634 | else | ||
635 | xasprintf (&data, "%s;", data); | ||
636 | |||
637 | if (maxp) | ||
638 | xasprintf (&data, "%s%lu", data, maxv); | ||
639 | |||
640 | return data; | ||
641 | } | ||
642 | |||
643 | |||
644 | char *perfdata_int64 (const char *label, | ||
645 | int64_t val, | ||
646 | const char *uom, | ||
647 | int warnp, /* Warning present */ | ||
648 | int64_t warn, | ||
649 | int critp, /* Critical present */ | ||
650 | int64_t crit, | ||
651 | int minp, /* Minimum present */ | ||
652 | int64_t minv, | ||
653 | int maxp, /* Maximum present */ | ||
654 | int64_t maxv) | ||
655 | { | ||
656 | char *data = NULL; | ||
657 | |||
658 | if (strpbrk (label, "'= ")) | ||
659 | xasprintf (&data, "'%s'=%ld%s;", label, val, uom); | ||
660 | else | ||
661 | xasprintf (&data, "%s=%ld%s;", label, val, uom); | ||
662 | |||
663 | if (warnp) | ||
664 | xasprintf (&data, "%s%ld;", data, warn); | ||
665 | else | ||
666 | xasprintf (&data, "%s;", data); | ||
667 | |||
668 | if (critp) | ||
669 | xasprintf (&data, "%s%ld;", data, crit); | ||
670 | else | ||
671 | xasprintf (&data, "%s;", data); | ||
672 | |||
673 | if (minp) | ||
674 | xasprintf (&data, "%s%ld;", data, minv); | ||
675 | else | ||
676 | xasprintf (&data, "%s;", data); | ||
677 | |||
678 | if (maxp) | ||
679 | xasprintf (&data, "%s%ld", data, maxv); | ||
584 | 680 | ||
585 | return data; | 681 | return data; |
586 | } | 682 | } |
@@ -709,3 +805,18 @@ char *sperfdata_int (const char *label, | |||
709 | return data; | 805 | return data; |
710 | } | 806 | } |
711 | 807 | ||
808 | int | ||
809 | open_max (void) | ||
810 | { | ||
811 | errno = 0; | ||
812 | if (maxfd > 0) | ||
813 | return(maxfd); | ||
814 | |||
815 | if ((maxfd = sysconf (_SC_OPEN_MAX)) < 0) { | ||
816 | if (errno == 0) | ||
817 | maxfd = DEFAULT_MAXFD; /* it's indeterminate */ | ||
818 | else | ||
819 | die (STATE_UNKNOWN, _("sysconf error for _SC_OPEN_MAX\n")); | ||
820 | } | ||
821 | return(maxfd); | ||
822 | } | ||
diff --git a/plugins/utils.h b/plugins/utils.h index a436e1ca..5b54da3c 100644 --- a/plugins/utils.h +++ b/plugins/utils.h | |||
@@ -16,6 +16,7 @@ suite of plugins. */ | |||
16 | /* now some functions etc are being defined in ../lib/utils_base.c */ | 16 | /* now some functions etc are being defined in ../lib/utils_base.c */ |
17 | #include "utils_base.h" | 17 | #include "utils_base.h" |
18 | 18 | ||
19 | |||
19 | #ifdef NP_EXTRA_OPTS | 20 | #ifdef NP_EXTRA_OPTS |
20 | /* Include extra-opts functions if compiled in */ | 21 | /* Include extra-opts functions if compiled in */ |
21 | #include "extra_opts.h" | 22 | #include "extra_opts.h" |
@@ -29,13 +30,6 @@ suite of plugins. */ | |||
29 | void support (void); | 30 | void support (void); |
30 | void print_revision (const char *, const char *); | 31 | void print_revision (const char *, const char *); |
31 | 32 | ||
32 | /* Handle timeouts */ | ||
33 | |||
34 | extern unsigned int timeout_state; | ||
35 | extern unsigned int timeout_interval; | ||
36 | |||
37 | RETSIGTYPE timeout_alarm_handler (int); | ||
38 | |||
39 | extern time_t start_time, end_time; | 33 | extern time_t start_time, end_time; |
40 | 34 | ||
41 | /* Test input types */ | 35 | /* Test input types */ |
@@ -45,6 +39,8 @@ int is_intpos (char *); | |||
45 | int is_intneg (char *); | 39 | int is_intneg (char *); |
46 | int is_intnonneg (char *); | 40 | int is_intnonneg (char *); |
47 | int is_intpercent (char *); | 41 | int is_intpercent (char *); |
42 | int is_uint64(char *number, uint64_t *target); | ||
43 | int is_int64(char *number, int64_t *target); | ||
48 | 44 | ||
49 | int is_numeric (char *); | 45 | int is_numeric (char *); |
50 | int is_positive (char *); | 46 | int is_positive (char *); |
@@ -89,14 +85,18 @@ void usage4(const char *) __attribute__((noreturn)); | |||
89 | void usage5(void) __attribute__((noreturn)); | 85 | void usage5(void) __attribute__((noreturn)); |
90 | void usage_va(const char *fmt, ...) __attribute__((noreturn)); | 86 | void usage_va(const char *fmt, ...) __attribute__((noreturn)); |
91 | 87 | ||
92 | const char *state_text (int); | ||
93 | |||
94 | #define max(a,b) (((a)>(b))?(a):(b)) | 88 | #define max(a,b) (((a)>(b))?(a):(b)) |
95 | #define min(a,b) (((a)<(b))?(a):(b)) | 89 | #define min(a,b) (((a)<(b))?(a):(b)) |
96 | 90 | ||
97 | char *perfdata (const char *, long int, const char *, int, long int, | 91 | char *perfdata (const char *, long int, const char *, int, long int, |
98 | int, long int, int, long int, int, long int); | 92 | int, long int, int, long int, int, long int); |
99 | 93 | ||
94 | char *perfdata_uint64 (const char *, uint64_t , const char *, int, uint64_t, | ||
95 | int, uint64_t, int, uint64_t, int, uint64_t); | ||
96 | |||
97 | char *perfdata_int64 (const char *, int64_t, const char *, int, int64_t, | ||
98 | int, int64_t, int, int64_t, int, int64_t); | ||
99 | |||
100 | char *fperfdata (const char *, double, const char *, int, double, | 100 | char *fperfdata (const char *, double, const char *, int, double, |
101 | int, double, int, double, int, double); | 101 | int, double, int, double, int, double); |
102 | 102 | ||
@@ -106,6 +106,8 @@ char *sperfdata (const char *, double, const char *, char *, char *, | |||
106 | char *sperfdata_int (const char *, int, const char *, char *, char *, | 106 | char *sperfdata_int (const char *, int, const char *, char *, char *, |
107 | int, int, int, int); | 107 | int, int, int, int); |
108 | 108 | ||
109 | int open_max (void); | ||
110 | |||
109 | /* The idea here is that, although not every plugin will use all of these, | 111 | /* The idea here is that, although not every plugin will use all of these, |
110 | most will or should. Therefore, for consistency, these very common | 112 | most will or should. Therefore, for consistency, these very common |
111 | options should have only these meanings throughout the overall suite */ | 113 | options should have only these meanings throughout the overall suite */ |