summaryrefslogtreecommitdiffstats
path: root/plugins
diff options
context:
space:
mode:
Diffstat (limited to 'plugins')
-rw-r--r--plugins/Makefile.am9
-rw-r--r--plugins/check_apt.c17
-rw-r--r--plugins/check_cluster.c10
-rw-r--r--plugins/check_curl.c2358
-rw-r--r--plugins/check_dbi.c1
-rw-r--r--plugins/check_disk.c52
-rw-r--r--plugins/check_dns.c63
-rw-r--r--plugins/check_hpjd.c12
-rw-r--r--plugins/check_http.c48
-rw-r--r--plugins/check_load.c61
-rw-r--r--plugins/check_mysql.c3
-rw-r--r--plugins/check_mysql_query.c12
-rw-r--r--plugins/check_pgsql.c3
-rw-r--r--plugins/check_procs.c5
-rw-r--r--plugins/check_smtp.c1
-rw-r--r--plugins/check_snmp.c8
-rw-r--r--plugins/check_swap.c16
-rw-r--r--plugins/check_tcp.c23
-rw-r--r--plugins/common.h19
-rw-r--r--plugins/picohttpparser/Makefile.am3
-rw-r--r--plugins/picohttpparser/picohttpparser.c645
-rw-r--r--plugins/picohttpparser/picohttpparser.h87
-rw-r--r--plugins/popen.c85
-rw-r--r--plugins/popen.h1
-rw-r--r--plugins/runcmd.c23
-rw-r--r--plugins/sslutils.c33
-rw-r--r--plugins/t/NPTest.cache.travis44
-rw-r--r--plugins/t/check_by_ssh.t14
-rw-r--r--plugins/t/check_curl.t199
-rw-r--r--plugins/t/check_fping.t12
-rw-r--r--plugins/t/check_ftp.t11
-rw-r--r--plugins/t/check_http.t128
-rw-r--r--plugins/t/check_imap.t15
-rw-r--r--plugins/t/check_jabber.t20
-rw-r--r--plugins/t/check_ldap.t17
-rw-r--r--plugins/t/check_mysql.t29
-rw-r--r--plugins/t/check_mysql_query.t11
-rw-r--r--plugins/t/check_snmp.t16
-rw-r--r--plugins/t/check_ssh.t14
-rw-r--r--plugins/t/check_tcp.t20
-rw-r--r--plugins/t/check_time.t11
-rw-r--r--plugins/tests/certs/expired-cert.pem41
-rw-r--r--plugins/tests/certs/expired-key.pem43
-rw-r--r--plugins/tests/certs/server-cert.pem41
-rw-r--r--plugins/tests/certs/server-key.pem43
-rwxr-xr-xplugins/tests/check_curl.t508
-rwxr-xr-xplugins/tests/check_http.t29
-rwxr-xr-xplugins/tests/check_snmp.t110
-rw-r--r--plugins/utils.c45
-rw-r--r--plugins/utils.h11
50 files changed, 4454 insertions, 576 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 \
38EXTRA_PROGRAMS = check_mysql check_radius check_pgsql check_snmp check_hpjd \ 38EXTRA_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
43SUBDIRS = picohttpparser
42 44
43EXTRA_DIST = t tests 45EXTRA_DIST = t tests
44 46
@@ -69,6 +71,9 @@ test-debug:
69 71
70check_apt_LDADD = $(BASEOBJS) 72check_apt_LDADD = $(BASEOBJS)
71check_cluster_LDADD = $(BASEOBJS) 73check_cluster_LDADD = $(BASEOBJS)
74check_curl_CFLAGS = $(AM_CFLAGS) $(LIBCURLCFLAGS) $(URIPARSERCFLAGS) $(LIBCURLINCLUDE) $(URIPARSERINCLUDE) -Ipicohttpparser
75check_curl_CPPFLAGS = $(AM_CPPFLAGS) $(LIBCURLCFLAGS) $(URIPARSERCFLAGS) $(LIBCURLINCLUDE) $(URIPARSERINCLUDE) -Ipicohttpparser
76check_curl_LDADD = $(NETLIBS) $(LIBCURLLIBS) $(SSLOBJS) $(URIPARSERLIBS) picohttpparser/libpicohttpparser.a
72check_dbi_LDADD = $(NETLIBS) $(DBILIBS) 77check_dbi_LDADD = $(NETLIBS) $(DBILIBS)
73check_dig_LDADD = $(NETLIBS) 78check_dig_LDADD = $(NETLIBS)
74check_disk_LDADD = $(BASEOBJS) 79check_disk_LDADD = $(BASEOBJS)
@@ -89,7 +94,7 @@ check_mysql_query_CFLAGS = $(AM_CFLAGS) $(MYSQLCFLAGS)
89check_mysql_query_CPPFLAGS = $(AM_CPPFLAGS) $(MYSQLINCLUDE) 94check_mysql_query_CPPFLAGS = $(AM_CPPFLAGS) $(MYSQLINCLUDE)
90check_mysql_query_LDADD = $(NETLIBS) $(MYSQLLIBS) 95check_mysql_query_LDADD = $(NETLIBS) $(MYSQLLIBS)
91check_nagios_LDADD = $(BASEOBJS) 96check_nagios_LDADD = $(BASEOBJS)
92check_nt_LDADD = $(NETLIBS) 97check_nt_LDADD = $(NETLIBS)
93check_ntp_LDADD = $(NETLIBS) $(MATHLIBS) 98check_ntp_LDADD = $(NETLIBS) $(MATHLIBS)
94check_ntp_peer_LDADD = $(NETLIBS) $(MATHLIBS) 99check_ntp_peer_LDADD = $(NETLIBS) $(MATHLIBS)
95check_nwstat_LDADD = $(NETLIBS) 100check_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 */
86static char *do_exclude = NULL; /* regexp to only exclude certain packages */ 86static char *do_exclude = NULL; /* regexp to only exclude certain packages */
87static char *do_critical = NULL; /* regexp specifying critical packages */ 87static char *do_critical = NULL; /* regexp specifying critical packages */
88static char *input_filename = NULL; /* input filename for testing */ 88static char *input_filename = NULL; /* input filename for testing */
89/* number of packages available for upgrade to return WARNING status */
90static int packages_warning = 1;
89 91
90/* other global variables */ 92/* other global variables */
91static int stderr_warning = 0; /* if a cmd issued output on stderr */ 93static 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
548print_usage(void) 557print_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_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
144int process_arguments(int argc, char **argv){ 144int 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..ee9c8b1d
--- /dev/null
+++ b/plugins/check_curl.c
@@ -0,0 +1,2358 @@
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*****************************************************************************/
35const char *progname = "check_curl";
36
37const char *copyright = "2006-2019";
38const 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#define MAKE_LIBCURL_VERSION(major, minor, patch) ((major)*0x10000 + (minor)*0x100 + (patch))
59
60#define DEFAULT_BUFFER_SIZE 2048
61#define DEFAULT_SERVER_URL "/"
62#define HTTP_EXPECT "HTTP/"
63#define DEFAULT_MAX_REDIRS 15
64#define INET_ADDR_MAX_SIZE INET6_ADDRSTRLEN
65enum {
66 MAX_IPV4_HOSTLENGTH = 255,
67 HTTP_PORT = 80,
68 HTTPS_PORT = 443,
69 MAX_PORT = 65535
70};
71
72enum {
73 STICKY_NONE = 0,
74 STICKY_HOST = 1,
75 STICKY_PORT = 2
76};
77
78enum {
79 FOLLOW_HTTP_CURL = 0,
80 FOLLOW_LIBCURL = 1
81};
82
83/* for buffers for header and body */
84typedef struct {
85 char *buf;
86 size_t buflen;
87 size_t bufsize;
88} curlhelp_write_curlbuf;
89
90/* for buffering the data sent in PUT */
91typedef struct {
92 char *buf;
93 size_t buflen;
94 off_t pos;
95} curlhelp_read_curlbuf;
96
97/* for parsing the HTTP status line */
98typedef struct {
99 int http_major; /* major version of the protocol, always 1 (HTTP/0.9
100 * never reached the big internet most likely) */
101 int http_minor; /* minor version of the protocol, usually 0 or 1 */
102 int http_code; /* HTTP return code as in RFC 2145 */
103 int http_subcode; /* Microsoft IIS extension, HTTP subcodes, see
104 * http://support.microsoft.com/kb/318380/en-us */
105 const char *msg; /* the human readable message */
106 char *first_line; /* a copy of the first line */
107} curlhelp_statusline;
108
109/* to know the underlying SSL library used by libcurl */
110typedef enum curlhelp_ssl_library {
111 CURLHELP_SSL_LIBRARY_UNKNOWN,
112 CURLHELP_SSL_LIBRARY_OPENSSL,
113 CURLHELP_SSL_LIBRARY_LIBRESSL,
114 CURLHELP_SSL_LIBRARY_GNUTLS,
115 CURLHELP_SSL_LIBRARY_NSS
116} curlhelp_ssl_library;
117
118enum {
119 REGS = 2,
120 MAX_RE_SIZE = 256
121};
122#include "regex.h"
123regex_t preg;
124regmatch_t pmatch[REGS];
125char regexp[MAX_RE_SIZE];
126int cflags = REG_NOSUB | REG_EXTENDED | REG_NEWLINE;
127int errcode;
128int invert_regex = 0;
129
130char *server_address = NULL;
131char *host_name = NULL;
132char *server_url = 0;
133char server_ip[DEFAULT_BUFFER_SIZE];
134struct curl_slist *server_ips = NULL;
135int specify_port = FALSE;
136unsigned short server_port = HTTP_PORT;
137unsigned short virtual_port = 0;
138int host_name_length;
139char output_header_search[30] = "";
140char output_string_search[30] = "";
141char *warning_thresholds = NULL;
142char *critical_thresholds = NULL;
143int days_till_exp_warn, days_till_exp_crit;
144thresholds *thlds;
145char user_agent[DEFAULT_BUFFER_SIZE];
146int verbose = 0;
147int show_extended_perfdata = FALSE;
148int min_page_len = 0;
149int max_page_len = 0;
150int redir_depth = 0;
151int max_depth = DEFAULT_MAX_REDIRS;
152char *http_method = NULL;
153char *http_post_data = NULL;
154char *http_content_type = NULL;
155CURL *curl;
156struct curl_slist *header_list = NULL;
157curlhelp_write_curlbuf body_buf;
158curlhelp_write_curlbuf header_buf;
159curlhelp_statusline status_line;
160curlhelp_read_curlbuf put_buf;
161char http_header[DEFAULT_BUFFER_SIZE];
162long code;
163long socket_timeout = DEFAULT_SOCKET_TIMEOUT;
164double total_time;
165double time_connect;
166double time_appconnect;
167double time_headers;
168double time_firstbyte;
169char errbuf[CURL_ERROR_SIZE+1];
170CURLcode res;
171char url[DEFAULT_BUFFER_SIZE];
172char msg[DEFAULT_BUFFER_SIZE];
173char perfstring[DEFAULT_BUFFER_SIZE];
174char header_expect[MAX_INPUT_BUFFER] = "";
175char string_expect[MAX_INPUT_BUFFER] = "";
176char server_expect[MAX_INPUT_BUFFER] = HTTP_EXPECT;
177int server_expect_yn = 0;
178char user_auth[MAX_INPUT_BUFFER] = "";
179char proxy_auth[MAX_INPUT_BUFFER] = "";
180char **http_opt_headers;
181int http_opt_headers_count = 0;
182int display_html = FALSE;
183int onredirect = STATE_OK;
184int followmethod = FOLLOW_HTTP_CURL;
185int followsticky = STICKY_NONE;
186int use_ssl = FALSE;
187int use_sni = TRUE;
188int check_cert = FALSE;
189typedef union {
190 struct curl_slist* to_info;
191 struct curl_certinfo* to_certinfo;
192} cert_ptr_union;
193cert_ptr_union cert_ptr;
194int ssl_version = CURL_SSLVERSION_DEFAULT;
195char *client_cert = NULL;
196char *client_privkey = NULL;
197char *ca_cert = NULL;
198int is_openssl_callback = FALSE;
199#if defined(HAVE_SSL) && defined(USE_OPENSSL)
200X509 *cert = NULL;
201#endif /* defined(HAVE_SSL) && defined(USE_OPENSSL) */
202int no_body = FALSE;
203int maximum_age = -1;
204int address_family = AF_UNSPEC;
205curlhelp_ssl_library ssl_library = CURLHELP_SSL_LIBRARY_UNKNOWN;
206int curl_http_version = CURL_HTTP_VERSION_NONE;
207
208int process_arguments (int, char**);
209void handle_curl_option_return_code (CURLcode res, const char* option);
210int check_http (void);
211void redir (curlhelp_write_curlbuf*);
212char *perfd_time (double microsec);
213char *perfd_time_connect (double microsec);
214char *perfd_time_ssl (double microsec);
215char *perfd_time_firstbyte (double microsec);
216char *perfd_time_headers (double microsec);
217char *perfd_time_transfer (double microsec);
218char *perfd_size (int page_len);
219void print_help (void);
220void print_usage (void);
221void print_curl_version (void);
222int curlhelp_initwritebuffer (curlhelp_write_curlbuf*);
223int curlhelp_buffer_write_callback (void*, size_t , size_t , void*);
224void curlhelp_freewritebuffer (curlhelp_write_curlbuf*);
225int curlhelp_initreadbuffer (curlhelp_read_curlbuf *, const char *, size_t);
226int curlhelp_buffer_read_callback (void *, size_t , size_t , void *);
227void curlhelp_freereadbuffer (curlhelp_read_curlbuf *);
228curlhelp_ssl_library curlhelp_get_ssl_library (CURL*);
229const char* curlhelp_get_ssl_library_string (curlhelp_ssl_library);
230int net_noopenssl_check_certificate (cert_ptr_union*, int, int);
231
232int curlhelp_parse_statusline (const char*, curlhelp_statusline *);
233void curlhelp_free_statusline (curlhelp_statusline *);
234char *get_header_value (const struct phr_header* headers, const size_t nof_headers, const char* header);
235int check_document_dates (const curlhelp_write_curlbuf *, char (*msg)[DEFAULT_BUFFER_SIZE]);
236int get_content_length (const curlhelp_write_curlbuf* header_buf, const curlhelp_write_curlbuf* body_buf);
237
238#if defined(HAVE_SSL) && defined(USE_OPENSSL)
239int np_net_ssl_check_certificate(X509 *certificate, int days_till_exp_warn, int days_till_exp_crit);
240#endif /* defined(HAVE_SSL) && defined(USE_OPENSSL) */
241
242void remove_newlines (char *);
243void test_file (char *);
244
245int
246main (int argc, char **argv)
247{
248 int result = STATE_UNKNOWN;
249
250 setlocale (LC_ALL, "");
251 bindtextdomain (PACKAGE, LOCALEDIR);
252 textdomain (PACKAGE);
253
254 /* Parse extra opts if any */
255 argv = np_extra_opts (&argc, argv, progname);
256
257 /* set defaults */
258 snprintf( user_agent, DEFAULT_BUFFER_SIZE, "%s/v%s (monitoring-plugins %s, %s)",
259 progname, NP_VERSION, VERSION, curl_version());
260
261 /* parse arguments */
262 if (process_arguments (argc, argv) == ERROR)
263 usage4 (_("Could not parse arguments"));
264
265 if (display_html == TRUE)
266 printf ("<A HREF=\"%s://%s:%d%s\" target=\"_blank\">",
267 use_ssl ? "https" : "http",
268 host_name ? host_name : server_address,
269 virtual_port ? virtual_port : server_port,
270 server_url);
271
272 result = check_http ();
273 return result;
274}
275
276#ifdef HAVE_SSL
277#ifdef USE_OPENSSL
278
279int verify_callback(int preverify_ok, X509_STORE_CTX *x509_ctx)
280{
281 /* TODO: we get all certificates of the chain, so which ones
282 * should we test?
283 * TODO: is the last certificate always the server certificate?
284 */
285 cert = X509_STORE_CTX_get_current_cert(x509_ctx);
286 return 1;
287}
288
289CURLcode sslctxfun(CURL *curl, SSL_CTX *sslctx, void *parm)
290{
291 SSL_CTX_set_verify(sslctx, SSL_VERIFY_PEER, verify_callback);
292
293 return CURLE_OK;
294}
295
296#endif /* USE_OPENSSL */
297#endif /* HAVE_SSL */
298
299/* returns a string "HTTP/1.x" or "HTTP/2" */
300static char *string_statuscode (int major, int minor)
301{
302 static char buf[10];
303
304 switch (major) {
305 case 1:
306 snprintf (buf, sizeof (buf), "HTTP/%d.%d", major, minor);
307 break;
308 case 2:
309 case 3:
310 snprintf (buf, sizeof (buf), "HTTP/%d", major);
311 break;
312 default:
313 /* assuming here HTTP/N with N>=4 */
314 snprintf (buf, sizeof (buf), "HTTP/%d", major);
315 break;
316 }
317
318 return buf;
319}
320
321/* Checks if the server 'reply' is one of the expected 'statuscodes' */
322static int
323expected_statuscode (const char *reply, const char *statuscodes)
324{
325 char *expected, *code;
326 int result = 0;
327
328 if ((expected = strdup (statuscodes)) == NULL)
329 die (STATE_UNKNOWN, _("HTTP UNKNOWN - Memory allocation error\n"));
330
331 for (code = strtok (expected, ","); code != NULL; code = strtok (NULL, ","))
332 if (strstr (reply, code) != NULL) {
333 result = 1;
334 break;
335 }
336
337 free (expected);
338 return result;
339}
340
341void
342handle_curl_option_return_code (CURLcode res, const char* option)
343{
344 if (res != CURLE_OK) {
345 snprintf (msg, DEFAULT_BUFFER_SIZE, _("Error while setting cURL option '%s': cURL returned %d - %s"),
346 option, res, curl_easy_strerror(res));
347 die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg);
348 }
349}
350
351int
352check_http (void)
353{
354 int result = STATE_OK;
355 int page_len = 0;
356 int i;
357 char *force_host_header = NULL;
358
359 /* initialize curl */
360 if (curl_global_init (CURL_GLOBAL_DEFAULT) != CURLE_OK)
361 die (STATE_UNKNOWN, "HTTP UNKNOWN - curl_global_init failed\n");
362
363 if ((curl = curl_easy_init()) == NULL)
364 die (STATE_UNKNOWN, "HTTP UNKNOWN - curl_easy_init failed\n");
365
366 if (verbose >= 1)
367 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_VERBOSE, TRUE), "CURLOPT_VERBOSE");
368
369 /* print everything on stdout like check_http would do */
370 handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_STDERR, stdout), "CURLOPT_STDERR");
371
372 /* initialize buffer for body of the answer */
373 if (curlhelp_initwritebuffer(&body_buf) < 0)
374 die (STATE_UNKNOWN, "HTTP CRITICAL - out of memory allocating buffer for body\n");
375 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)curlhelp_buffer_write_callback), "CURLOPT_WRITEFUNCTION");
376 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_WRITEDATA, (void *)&body_buf), "CURLOPT_WRITEDATA");
377
378 /* initialize buffer for header of the answer */
379 if (curlhelp_initwritebuffer( &header_buf ) < 0)
380 die (STATE_UNKNOWN, "HTTP CRITICAL - out of memory allocating buffer for header\n" );
381 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)curlhelp_buffer_write_callback), "CURLOPT_HEADERFUNCTION");
382 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_WRITEHEADER, (void *)&header_buf), "CURLOPT_WRITEHEADER");
383
384 /* set the error buffer */
385 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_ERRORBUFFER, errbuf), "CURLOPT_ERRORBUFFER");
386
387 /* set timeouts */
388 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CONNECTTIMEOUT, socket_timeout), "CURLOPT_CONNECTTIMEOUT");
389 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_TIMEOUT, socket_timeout), "CURLOPT_TIMEOUT");
390
391 // 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
392 if(use_ssl && host_name != NULL) {
393 struct curl_slist *host = NULL;
394 char dnscache[DEFAULT_BUFFER_SIZE];
395 snprintf (dnscache, DEFAULT_BUFFER_SIZE, "%s:%d:%s", host_name, server_port, server_address);
396 host = curl_slist_append(NULL, dnscache);
397 curl_easy_setopt(curl, CURLOPT_RESOLVE, host);
398 if (verbose>=1)
399 printf ("* curl CURLOPT_RESOLVE: %s\n", dnscache);
400 }
401
402 /* compose URL: use the address we want to connect to, set Host: header later */
403 snprintf (url, DEFAULT_BUFFER_SIZE, "%s://%s:%d%s",
404 use_ssl ? "https" : "http",
405 use_ssl & host_name != NULL ? host_name : server_address,
406 server_port,
407 server_url
408 );
409
410 if (verbose>=1)
411 printf ("* curl CURLOPT_URL: %s\n", url);
412 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_URL, url), "CURLOPT_URL");
413
414 /* extract proxy information for legacy proxy https requests */
415 if (!strcmp(http_method, "CONNECT") || strstr(server_url, "http") == server_url) {
416 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_PROXY, server_address), "CURLOPT_PROXY");
417 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_PROXYPORT, (long)server_port), "CURLOPT_PROXYPORT");
418 if (verbose>=2)
419 printf ("* curl CURLOPT_PROXY: %s:%d\n", server_address, server_port);
420 http_method = "GET";
421 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_URL, server_url), "CURLOPT_URL");
422 }
423
424 /* disable body for HEAD request */
425 if (http_method && !strcmp (http_method, "HEAD" )) {
426 no_body = TRUE;
427 }
428
429 /* set HTTP protocol version */
430 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_HTTP_VERSION, curl_http_version), "CURLOPT_HTTP_VERSION");
431
432 /* set HTTP method */
433 if (http_method) {
434 if (!strcmp(http_method, "POST"))
435 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_POST, 1), "CURLOPT_POST");
436 else if (!strcmp(http_method, "PUT"))
437 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_UPLOAD, 1), "CURLOPT_UPLOAD");
438 else
439 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CUSTOMREQUEST, http_method), "CURLOPT_CUSTOMREQUEST");
440 }
441
442 /* check if Host header is explicitly set in options */
443 if (http_opt_headers_count) {
444 for (i = 0; i < http_opt_headers_count ; i++) {
445 if (strncmp(http_opt_headers[i], "Host:", 5) == 0) {
446 force_host_header = http_opt_headers[i];
447 }
448 }
449 }
450
451 /* set hostname (virtual hosts), not needed if CURLOPT_CONNECT_TO is used, but left in anyway */
452 if(host_name != NULL && force_host_header == NULL) {
453 if((virtual_port != HTTP_PORT && !use_ssl) || (virtual_port != HTTPS_PORT && use_ssl)) {
454 snprintf(http_header, DEFAULT_BUFFER_SIZE, "Host: %s:%d", host_name, virtual_port);
455 } else {
456 snprintf(http_header, DEFAULT_BUFFER_SIZE, "Host: %s", host_name);
457 }
458 header_list = curl_slist_append (header_list, http_header);
459 }
460
461 /* always close connection, be nice to servers */
462 snprintf (http_header, DEFAULT_BUFFER_SIZE, "Connection: close");
463 header_list = curl_slist_append (header_list, http_header);
464
465 /* attach additional headers supplied by the user */
466 /* optionally send any other header tag */
467 if (http_opt_headers_count) {
468 for (i = 0; i < http_opt_headers_count ; i++) {
469 header_list = curl_slist_append (header_list, http_opt_headers[i]);
470 }
471 /* This cannot be free'd here because a redirection will then try to access this and segfault */
472 /* Covered in a testcase in tests/check_http.t */
473 /* free(http_opt_headers); */
474 }
475
476 /* set HTTP headers */
477 handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_HTTPHEADER, header_list ), "CURLOPT_HTTPHEADER");
478
479#ifdef LIBCURL_FEATURE_SSL
480
481 /* set SSL version, warn about unsecure or unsupported versions */
482 if (use_ssl) {
483 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSLVERSION, ssl_version), "CURLOPT_SSLVERSION");
484 }
485
486 /* client certificate and key to present to server (SSL) */
487 if (client_cert)
488 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSLCERT, client_cert), "CURLOPT_SSLCERT");
489 if (client_privkey)
490 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSLKEY, client_privkey), "CURLOPT_SSLKEY");
491 if (ca_cert) {
492 /* per default if we have a CA verify both the peer and the
493 * hostname in the certificate, can be switched off later */
494 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CAINFO, ca_cert), "CURLOPT_CAINFO");
495 handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_SSL_VERIFYPEER, 1), "CURLOPT_SSL_VERIFYPEER");
496 handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_SSL_VERIFYHOST, 2), "CURLOPT_SSL_VERIFYHOST");
497 } else {
498 /* backward-compatible behaviour, be tolerant in checks
499 * TODO: depending on more options have aspects we want
500 * to be less tolerant about ssl verfications
501 */
502 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 0), "CURLOPT_SSL_VERIFYPEER");
503 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, 0), "CURLOPT_SSL_VERIFYHOST");
504 }
505
506 /* detect SSL library used by libcurl */
507 ssl_library = curlhelp_get_ssl_library (curl);
508
509 /* try hard to get a stack of certificates to verify against */
510 if (check_cert) {
511#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 1)
512 /* inform curl to report back certificates */
513 switch (ssl_library) {
514 case CURLHELP_SSL_LIBRARY_OPENSSL:
515 case CURLHELP_SSL_LIBRARY_LIBRESSL:
516 /* set callback to extract certificate with OpenSSL context function (works with
517 * OpenSSL-style libraries only!) */
518#ifdef USE_OPENSSL
519 /* libcurl and monitoring plugins built with OpenSSL, good */
520 handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfun), "CURLOPT_SSL_CTX_FUNCTION");
521 is_openssl_callback = TRUE;
522#else /* USE_OPENSSL */
523#endif /* USE_OPENSSL */
524 /* libcurl is built with OpenSSL, monitoring plugins, so falling
525 * back to manually extracting certificate information */
526 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CERTINFO, 1L), "CURLOPT_CERTINFO");
527 break;
528
529 case CURLHELP_SSL_LIBRARY_NSS:
530#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0)
531 /* NSS: support for CERTINFO is implemented since 7.34.0 */
532 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CERTINFO, 1L), "CURLOPT_CERTINFO");
533#else /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */
534 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));
535#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */
536 break;
537
538 case CURLHELP_SSL_LIBRARY_GNUTLS:
539#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 42, 0)
540 /* GnuTLS: support for CERTINFO is implemented since 7.42.0 */
541 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_CERTINFO, 1L), "CURLOPT_CERTINFO");
542#else /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 42, 0) */
543 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));
544#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 42, 0) */
545 break;
546
547 case CURLHELP_SSL_LIBRARY_UNKNOWN:
548 default:
549 die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates (unknown SSL library '%s', must implement first)\n", curlhelp_get_ssl_library_string (ssl_library));
550 break;
551 }
552#else /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 1) */
553 /* old libcurl, our only hope is OpenSSL, otherwise we are out of luck */
554 if (ssl_library == CURLHELP_SSL_LIBRARY_OPENSSL || ssl_library == CURLHELP_SSL_LIBRARY_LIBRESSL)
555 handle_curl_option_return_code (curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfun), "CURLOPT_SSL_CTX_FUNCTION");
556 else
557 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");
558#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 1) */
559 }
560
561#endif /* LIBCURL_FEATURE_SSL */
562
563 /* set default or user-given user agent identification */
564 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_USERAGENT, user_agent), "CURLOPT_USERAGENT");
565
566 /* proxy-authentication */
567 if (strcmp(proxy_auth, ""))
568 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_PROXYUSERPWD, proxy_auth), "CURLOPT_PROXYUSERPWD");
569
570 /* authentication */
571 if (strcmp(user_auth, ""))
572 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_USERPWD, user_auth), "CURLOPT_USERPWD");
573
574 /* TODO: parameter auth method, bitfield of following methods:
575 * CURLAUTH_BASIC (default)
576 * CURLAUTH_DIGEST
577 * CURLAUTH_DIGEST_IE
578 * CURLAUTH_NEGOTIATE
579 * CURLAUTH_NTLM
580 * CURLAUTH_NTLM_WB
581 *
582 * convenience tokens for typical sets of methods:
583 * CURLAUTH_ANYSAFE: most secure, without BASIC
584 * or CURLAUTH_ANY: most secure, even BASIC if necessary
585 *
586 * handle_curl_option_return_code (curl_easy_setopt( curl, CURLOPT_HTTPAUTH, (long)CURLAUTH_DIGEST ), "CURLOPT_HTTPAUTH");
587 */
588
589 /* handle redirections */
590 if (onredirect == STATE_DEPENDENT) {
591 if( followmethod == FOLLOW_LIBCURL ) {
592 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_FOLLOWLOCATION, 1), "CURLOPT_FOLLOWLOCATION");
593
594 /* default -1 is infinite, not good, could lead to zombie plugins!
595 Setting it to one bigger than maximal limit to handle errors nicely below
596 */
597 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_MAXREDIRS, max_depth+1), "CURLOPT_MAXREDIRS");
598
599 /* for now allow only http and https (we are a http(s) check plugin in the end) */
600#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 4)
601 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS), "CURLOPT_REDIRECT_PROTOCOLS");
602#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 19, 4) */
603
604 /* TODO: handle the following aspects of redirection, make them
605 * command line options too later:
606 CURLOPT_POSTREDIR: method switch
607 CURLINFO_REDIRECT_URL: custom redirect option
608 CURLOPT_REDIRECT_PROTOCOLS: allow people to step outside safe protocols
609 CURLINFO_REDIRECT_COUNT: get the number of redirects, print it, maybe a range option here is nice like for expected page size?
610 */
611 } else {
612 /* old style redirection is handled below */
613 }
614 }
615
616 /* no-body */
617 if (no_body)
618 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_NOBODY, 1), "CURLOPT_NOBODY");
619
620 /* IPv4 or IPv6 forced DNS resolution */
621 if (address_family == AF_UNSPEC)
622 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_WHATEVER), "CURLOPT_IPRESOLVE(CURL_IPRESOLVE_WHATEVER)");
623 else if (address_family == AF_INET)
624 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4), "CURLOPT_IPRESOLVE(CURL_IPRESOLVE_V4)");
625#if defined (USE_IPV6) && defined (LIBCURL_FEATURE_IPV6)
626 else if (address_family == AF_INET6)
627 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6), "CURLOPT_IPRESOLVE(CURL_IPRESOLVE_V6)");
628#endif
629
630 /* either send http POST data (any data, not only POST)*/
631 if (!strcmp(http_method, "POST") ||!strcmp(http_method, "PUT")) {
632 /* set content of payload for POST and PUT */
633 if (http_content_type) {
634 snprintf (http_header, DEFAULT_BUFFER_SIZE, "Content-Type: %s", http_content_type);
635 header_list = curl_slist_append (header_list, http_header);
636 }
637 /* NULL indicates "HTTP Continue" in libcurl, provide an empty string
638 * in case of no POST/PUT data */
639 if (!http_post_data)
640 http_post_data = "";
641 if (!strcmp(http_method, "POST")) {
642 /* POST method, set payload with CURLOPT_POSTFIELDS */
643 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_POSTFIELDS, http_post_data), "CURLOPT_POSTFIELDS");
644 } else if (!strcmp(http_method, "PUT")) {
645 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_READFUNCTION, (curl_read_callback)curlhelp_buffer_read_callback), "CURLOPT_READFUNCTION");
646 curlhelp_initreadbuffer (&put_buf, http_post_data, strlen (http_post_data));
647 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_READDATA, (void *)&put_buf), "CURLOPT_READDATA");
648 handle_curl_option_return_code (curl_easy_setopt (curl, CURLOPT_INFILESIZE, (curl_off_t)strlen (http_post_data)), "CURLOPT_INFILESIZE");
649 }
650 }
651
652 /* do the request */
653 res = curl_easy_perform(curl);
654
655 if (verbose>=2 && http_post_data)
656 printf ("**** REQUEST CONTENT ****\n%s\n", http_post_data);
657
658 /* free header and server IP resolve lists, we don't need it anymore */
659 curl_slist_free_all (header_list); header_list = NULL;
660 curl_slist_free_all (server_ips); server_ips = NULL;
661
662 /* Curl errors, result in critical Nagios state */
663 if (res != CURLE_OK) {
664 snprintf (msg, DEFAULT_BUFFER_SIZE, _("Invalid HTTP response received from host on port %d: cURL returned %d - %s"),
665 server_port, res, errbuf[0] ? errbuf : curl_easy_strerror(res));
666 die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg);
667 }
668
669 /* certificate checks */
670#ifdef LIBCURL_FEATURE_SSL
671 if (use_ssl == TRUE) {
672 if (check_cert == TRUE) {
673 if (is_openssl_callback) {
674#ifdef USE_OPENSSL
675 /* check certificate with OpenSSL functions, curl has been built against OpenSSL
676 * and we actually have OpenSSL in the monitoring tools
677 */
678 result = np_net_ssl_check_certificate(cert, days_till_exp_warn, days_till_exp_crit);
679 return result;
680#else /* USE_OPENSSL */
681 die (STATE_CRITICAL, "HTTP CRITICAL - Cannot retrieve certificates - OpenSSL callback used and not linked against OpenSSL\n");
682#endif /* USE_OPENSSL */
683 } else {
684 int i;
685 struct curl_slist *slist;
686
687 cert_ptr.to_info = NULL;
688 res = curl_easy_getinfo (curl, CURLINFO_CERTINFO, &cert_ptr.to_info);
689 if (!res && cert_ptr.to_info) {
690#ifdef USE_OPENSSL
691 /* We have no OpenSSL in libcurl, but we can use OpenSSL for X509 cert parsing
692 * We only check the first certificate and assume it's the one of the server
693 */
694 const char* raw_cert = NULL;
695 for (i = 0; i < cert_ptr.to_certinfo->num_of_certs; i++) {
696 for (slist = cert_ptr.to_certinfo->certinfo[i]; slist; slist = slist->next) {
697 if (verbose >= 2)
698 printf ("%d ** %s\n", i, slist->data);
699 if (strncmp (slist->data, "Cert:", 5) == 0) {
700 raw_cert = &slist->data[5];
701 goto GOT_FIRST_CERT;
702 }
703 }
704 }
705GOT_FIRST_CERT:
706 if (!raw_cert) {
707 snprintf (msg, DEFAULT_BUFFER_SIZE, _("Cannot retrieve certificates from CERTINFO information - certificate data was empty"));
708 die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg);
709 }
710 BIO* cert_BIO = BIO_new (BIO_s_mem());
711 BIO_write (cert_BIO, raw_cert, strlen(raw_cert));
712 cert = PEM_read_bio_X509 (cert_BIO, NULL, NULL, NULL);
713 if (!cert) {
714 snprintf (msg, DEFAULT_BUFFER_SIZE, _("Cannot read certificate from CERTINFO information - BIO error"));
715 die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg);
716 }
717 BIO_free (cert_BIO);
718 result = np_net_ssl_check_certificate(cert, days_till_exp_warn, days_till_exp_crit);
719 return result;
720#else /* USE_OPENSSL */
721 /* We assume we don't have OpenSSL and np_net_ssl_check_certificate at our disposal,
722 * so we use the libcurl CURLINFO data
723 */
724 result = net_noopenssl_check_certificate(&cert_ptr, days_till_exp_warn, days_till_exp_crit);
725 return result;
726#endif /* USE_OPENSSL */
727 } else {
728 snprintf (msg, DEFAULT_BUFFER_SIZE, _("Cannot retrieve certificates - cURL returned %d - %s"),
729 res, curl_easy_strerror(res));
730 die (STATE_CRITICAL, "HTTP CRITICAL - %s\n", msg);
731 }
732 }
733 }
734 }
735#endif /* LIBCURL_FEATURE_SSL */
736
737 /* we got the data and we executed the request in a given time, so we can append
738 * performance data to the answer always
739 */
740 handle_curl_option_return_code (curl_easy_getinfo (curl, CURLINFO_TOTAL_TIME, &total_time), "CURLINFO_TOTAL_TIME");
741 page_len = get_content_length(&header_buf, &body_buf);
742 if(show_extended_perfdata) {
743 handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME, &time_connect), "CURLINFO_CONNECT_TIME");
744 handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_APPCONNECT_TIME, &time_appconnect), "CURLINFO_APPCONNECT_TIME");
745 handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_PRETRANSFER_TIME, &time_headers), "CURLINFO_PRETRANSFER_TIME");
746 handle_curl_option_return_code (curl_easy_getinfo(curl, CURLINFO_STARTTRANSFER_TIME, &time_firstbyte), "CURLINFO_STARTTRANSFER_TIME");
747 snprintf(perfstring, DEFAULT_BUFFER_SIZE, "%s %s %s %s %s %s %s",
748 perfd_time(total_time),
749 perfd_size(page_len),
750 perfd_time_connect(time_connect),
751 use_ssl == TRUE ? perfd_time_ssl (time_appconnect-time_connect) : "",
752 perfd_time_headers(time_headers - time_appconnect),
753 perfd_time_firstbyte(time_firstbyte - time_headers),
754 perfd_time_transfer(total_time-time_firstbyte)
755 );
756 } else {
757 snprintf(perfstring, DEFAULT_BUFFER_SIZE, "%s %s",
758 perfd_time(total_time),
759 perfd_size(page_len)
760 );
761 }
762
763 /* return a CRITICAL status if we couldn't read any data */
764 if (strlen(header_buf.buf) == 0 && strlen(body_buf.buf) == 0)
765 die (STATE_CRITICAL, _("HTTP CRITICAL - No header received from host\n"));
766
767 /* get status line of answer, check sanity of HTTP code */
768 if (curlhelp_parse_statusline (header_buf.buf, &status_line) < 0) {
769 snprintf (msg, DEFAULT_BUFFER_SIZE, "Unparsable status line in %.3g seconds response time|%s\n",
770 total_time, perfstring);
771 /* we cannot know the major/minor version here for sure as we cannot parse the first line */
772 die (STATE_CRITICAL, "HTTP CRITICAL HTTP/x.x %ld unknown - %s", code, msg);
773 }
774
775 /* get result code from cURL */
776 handle_curl_option_return_code (curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &code), "CURLINFO_RESPONSE_CODE");
777 if (verbose>=2)
778 printf ("* curl CURLINFO_RESPONSE_CODE is %ld\n", code);
779
780 /* print status line, header, body if verbose */
781 if (verbose >= 2) {
782 printf ("**** HEADER ****\n%s\n**** CONTENT ****\n%s\n", header_buf.buf,
783 (no_body ? " [[ skipped ]]" : body_buf.buf));
784 }
785
786 /* make sure the status line matches the response we are looking for */
787 if (!expected_statuscode(status_line.first_line, server_expect)) {
788 if (server_port == HTTP_PORT)
789 snprintf(msg, DEFAULT_BUFFER_SIZE, _("Invalid HTTP response received from host: %s\n"), status_line.first_line);
790 else
791 snprintf(msg, DEFAULT_BUFFER_SIZE, _("Invalid HTTP response received from host on port %d: %s\n"), server_port, status_line.first_line);
792 die (STATE_CRITICAL, "HTTP CRITICAL - %s", msg);
793 }
794
795 if( server_expect_yn ) {
796 snprintf(msg, DEFAULT_BUFFER_SIZE, _("Status line output matched \"%s\" - "), server_expect);
797 if (verbose)
798 printf ("%s\n",msg);
799 result = STATE_OK;
800 }
801 else {
802 /* illegal return codes result in a critical state */
803 if (code >= 600 || code < 100) {
804 die (STATE_CRITICAL, _("HTTP CRITICAL: Invalid Status (%d, %.40s)\n"), status_line.http_code, status_line.msg);
805 /* server errors result in a critical state */
806 } else if (code >= 500) {
807 result = STATE_CRITICAL;
808 /* client errors result in a warning state */
809 } else if (code >= 400) {
810 result = STATE_WARNING;
811 /* check redirected page if specified */
812 } else if (code >= 300) {
813 if (onredirect == STATE_DEPENDENT) {
814 if( followmethod == FOLLOW_LIBCURL ) {
815 code = status_line.http_code;
816 } else {
817 /* old check_http style redirection, if we come
818 * back here, we are in the same status as with
819 * the libcurl method
820 */
821 redir (&header_buf);
822 }
823 } else {
824 /* this is a specific code in the command line to
825 * be returned when a redirection is encoutered
826 */
827 }
828 result = max_state_alt (onredirect, result);
829 /* all other codes are considered ok */
830 } else {
831 result = STATE_OK;
832 }
833 }
834
835 /* libcurl redirection internally, handle error states here */
836 if( followmethod == FOLLOW_LIBCURL ) {
837 handle_curl_option_return_code (curl_easy_getinfo (curl, CURLINFO_REDIRECT_COUNT, &redir_depth), "CURLINFO_REDIRECT_COUNT");
838 if (verbose >= 2)
839 printf(_("* curl LIBINFO_REDIRECT_COUNT is %d\n"), redir_depth);
840 if (redir_depth > max_depth) {
841 snprintf (msg, DEFAULT_BUFFER_SIZE, "maximum redirection depth %d exceeded in libcurl",
842 max_depth);
843 die (STATE_WARNING, "HTTP WARNING - %s", msg);
844 }
845 }
846
847 /* check status codes, set exit status accordingly */
848 if( status_line.http_code != code ) {
849 die (STATE_CRITICAL, _("HTTP CRITICAL %s %d %s - different HTTP codes (cUrl has %ld)\n"),
850 string_statuscode (status_line.http_major, status_line.http_minor),
851 status_line.http_code, status_line.msg, code);
852 }
853
854 if (maximum_age >= 0) {
855 result = max_state_alt(check_document_dates(&header_buf, &msg), result);
856 }
857
858 /* Page and Header content checks go here */
859
860 if (strlen (header_expect)) {
861 if (!strstr (header_buf.buf, header_expect)) {
862 strncpy(&output_header_search[0],header_expect,sizeof(output_header_search));
863 if(output_header_search[sizeof(output_header_search)-1]!='\0') {
864 bcopy("...",&output_header_search[sizeof(output_header_search)-4],4);
865 }
866 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);
867 result = STATE_CRITICAL;
868 }
869 }
870
871 if (strlen (string_expect)) {
872 if (!strstr (body_buf.buf, string_expect)) {
873 strncpy(&output_string_search[0],string_expect,sizeof(output_string_search));
874 if(output_string_search[sizeof(output_string_search)-1]!='\0') {
875 bcopy("...",&output_string_search[sizeof(output_string_search)-4],4);
876 }
877 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);
878 result = STATE_CRITICAL;
879 }
880 }
881
882 if (strlen (regexp)) {
883 errcode = regexec (&preg, body_buf.buf, REGS, pmatch, 0);
884 if ((errcode == 0 && invert_regex == 0) || (errcode == REG_NOMATCH && invert_regex == 1)) {
885 /* OK - No-op to avoid changing the logic around it */
886 result = max_state_alt(STATE_OK, result);
887 }
888 else if ((errcode == REG_NOMATCH && invert_regex == 0) || (errcode == 0 && invert_regex == 1)) {
889 if (invert_regex == 0)
890 snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spattern not found, "), msg);
891 else
892 snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spattern found, "), msg);
893 result = STATE_CRITICAL;
894 }
895 else {
896 regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
897 snprintf (msg, DEFAULT_BUFFER_SIZE, _("%sExecute Error: %s, "), msg, errbuf);
898 result = STATE_UNKNOWN;
899 }
900 }
901
902 /* make sure the page is of an appropriate size */
903 if ((max_page_len > 0) && (page_len > max_page_len)) {
904 snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spage size %d too large, "), msg, page_len);
905 result = max_state_alt(STATE_WARNING, result);
906 } else if ((min_page_len > 0) && (page_len < min_page_len)) {
907 snprintf (msg, DEFAULT_BUFFER_SIZE, _("%spage size %d too small, "), msg, page_len);
908 result = max_state_alt(STATE_WARNING, result);
909 }
910
911 /* -w, -c: check warning and critical level */
912 result = max_state_alt(get_status(total_time, thlds), result);
913
914 /* Cut-off trailing characters */
915 if(msg[strlen(msg)-2] == ',')
916 msg[strlen(msg)-2] = '\0';
917 else
918 msg[strlen(msg)-3] = '\0';
919
920 /* TODO: separate _() msg and status code: die (result, "HTTP %s: %s\n", state_text(result), msg); */
921 die (result, "HTTP %s: %s %d %s%s%s - %d bytes in %.3f second response time %s|%s\n",
922 state_text(result), string_statuscode (status_line.http_major, status_line.http_minor),
923 status_line.http_code, status_line.msg,
924 strlen(msg) > 0 ? " - " : "",
925 msg, page_len, total_time,
926 (display_html ? "</A>" : ""),
927 perfstring);
928
929 /* proper cleanup after die? */
930 curlhelp_free_statusline(&status_line);
931 curl_easy_cleanup (curl);
932 curl_global_cleanup ();
933 curlhelp_freewritebuffer (&body_buf);
934 curlhelp_freewritebuffer (&header_buf);
935 if (!strcmp (http_method, "PUT")) {
936 curlhelp_freereadbuffer (&put_buf);
937 }
938
939 return result;
940}
941
942int
943uri_strcmp (const UriTextRangeA range, const char* s)
944{
945 if (!range.first) return -1;
946 if (range.afterLast - range.first < strlen (s)) return -1;
947 return strncmp (s, range.first, min( range.afterLast - range.first, strlen (s)));
948}
949
950char*
951uri_string (const UriTextRangeA range, char* buf, size_t buflen)
952{
953 if (!range.first) return "(null)";
954 strncpy (buf, range.first, max (buflen, range.afterLast - range.first));
955 buf[max (buflen, range.afterLast - range.first)] = '\0';
956 buf[range.afterLast - range.first] = '\0';
957 return buf;
958}
959
960void
961redir (curlhelp_write_curlbuf* header_buf)
962{
963 char *location = NULL;
964 curlhelp_statusline status_line;
965 struct phr_header headers[255];
966 size_t nof_headers = 255;
967 size_t msglen;
968 char buf[DEFAULT_BUFFER_SIZE];
969 char ipstr[INET_ADDR_MAX_SIZE];
970 int new_port;
971 char *new_host;
972 char *new_url;
973
974 int res = phr_parse_response (header_buf->buf, header_buf->buflen,
975 &status_line.http_minor, &status_line.http_code, &status_line.msg, &msglen,
976 headers, &nof_headers, 0);
977
978 location = get_header_value (headers, nof_headers, "location");
979
980 if (verbose >= 2)
981 printf(_("* Seen redirect location %s\n"), location);
982
983 if (++redir_depth > max_depth)
984 die (STATE_WARNING,
985 _("HTTP WARNING - maximum redirection depth %d exceeded - %s%s\n"),
986 max_depth, location, (display_html ? "</A>" : ""));
987
988 UriParserStateA state;
989 UriUriA uri;
990 state.uri = &uri;
991 if (uriParseUriA (&state, location) != URI_SUCCESS) {
992 if (state.errorCode == URI_ERROR_SYNTAX) {
993 die (STATE_UNKNOWN,
994 _("HTTP UNKNOWN - Could not parse redirect location '%s'%s\n"),
995 location, (display_html ? "</A>" : ""));
996 } else if (state.errorCode == URI_ERROR_MALLOC) {
997 die (STATE_UNKNOWN, _("HTTP UNKNOWN - Could not allocate URL\n"));
998 }
999 }
1000
1001 if (verbose >= 2) {
1002 printf (_("** scheme: %s\n"),
1003 uri_string (uri.scheme, buf, DEFAULT_BUFFER_SIZE));
1004 printf (_("** host: %s\n"),
1005 uri_string (uri.hostText, buf, DEFAULT_BUFFER_SIZE));
1006 printf (_("** port: %s\n"),
1007 uri_string (uri.portText, buf, DEFAULT_BUFFER_SIZE));
1008 if (uri.hostData.ip4) {
1009 inet_ntop (AF_INET, uri.hostData.ip4->data, ipstr, sizeof (ipstr));
1010 printf (_("** IPv4: %s\n"), ipstr);
1011 }
1012 if (uri.hostData.ip6) {
1013 inet_ntop (AF_INET, uri.hostData.ip6->data, ipstr, sizeof (ipstr));
1014 printf (_("** IPv6: %s\n"), ipstr);
1015 }
1016 if (uri.pathHead) {
1017 printf (_("** path: "));
1018 const UriPathSegmentA* p = uri.pathHead;
1019 for (; p; p = p->next) {
1020 printf ("/%s", uri_string (p->text, buf, DEFAULT_BUFFER_SIZE));
1021 }
1022 puts ("");
1023 }
1024 if (uri.query.first) {
1025 printf (_("** query: %s\n"),
1026 uri_string (uri.query, buf, DEFAULT_BUFFER_SIZE));
1027 }
1028 if (uri.fragment.first) {
1029 printf (_("** fragment: %s\n"),
1030 uri_string (uri.fragment, buf, DEFAULT_BUFFER_SIZE));
1031 }
1032 }
1033
1034 use_ssl = !uri_strcmp (uri.scheme, "https");
1035
1036 /* we do a sloppy test here only, because uriparser would have failed
1037 * above, if the port would be invalid, we just check for MAX_PORT
1038 */
1039 if (uri.portText.first) {
1040 new_port = atoi (uri_string (uri.portText, buf, DEFAULT_BUFFER_SIZE));
1041 } else {
1042 new_port = HTTP_PORT;
1043 if (use_ssl)
1044 new_port = HTTPS_PORT;
1045 }
1046 if (new_port > MAX_PORT)
1047 die (STATE_UNKNOWN,
1048 _("HTTP UNKNOWN - Redirection to port above %d - %s%s\n"),
1049 MAX_PORT, location, display_html ? "</A>" : "");
1050
1051 /* by RFC 7231 relative URLs in Location should be taken relative to
1052 * the original URL, so wy try to form a new absolute URL here
1053 */
1054 if (!uri.scheme.first && !uri.hostText.first) {
1055 new_host = strdup (host_name ? host_name : server_address);
1056 } else {
1057 new_host = strdup (uri_string (uri.hostText, buf, DEFAULT_BUFFER_SIZE));
1058 }
1059
1060 /* compose new path */
1061 /* TODO: handle fragments and query part of URL */
1062 new_url = (char *)calloc( 1, DEFAULT_BUFFER_SIZE);
1063 if (uri.pathHead) {
1064 const UriPathSegmentA* p = uri.pathHead;
1065 for (; p; p = p->next) {
1066 strncat (new_url, "/", DEFAULT_BUFFER_SIZE);
1067 strncat (new_url, uri_string (p->text, buf, DEFAULT_BUFFER_SIZE), DEFAULT_BUFFER_SIZE-1);
1068 }
1069 }
1070
1071 if (server_port==new_port &&
1072 !strncmp(server_address, new_host, MAX_IPV4_HOSTLENGTH) &&
1073 (host_name && !strncmp(host_name, new_host, MAX_IPV4_HOSTLENGTH)) &&
1074 !strcmp(server_url, new_url))
1075 die (STATE_WARNING,
1076 _("HTTP WARNING - redirection creates an infinite loop - %s://%s:%d%s%s\n"),
1077 use_ssl ? "https" : "http", new_host, new_port, new_url, (display_html ? "</A>" : ""));
1078
1079 /* set new values for redirected request */
1080
1081 if (!(followsticky & STICKY_HOST)) {
1082 free (server_address);
1083 server_address = strndup (new_host, MAX_IPV4_HOSTLENGTH);
1084 }
1085 if (!(followsticky & STICKY_PORT)) {
1086 server_port = (unsigned short)new_port;
1087 }
1088
1089 free (host_name);
1090 host_name = strndup (new_host, MAX_IPV4_HOSTLENGTH);
1091
1092 /* reset virtual port */
1093 virtual_port = server_port;
1094
1095 free(new_host);
1096 free (server_url);
1097 server_url = new_url;
1098
1099 uriFreeUriMembersA (&uri);
1100
1101 if (verbose)
1102 printf (_("Redirection to %s://%s:%d%s\n"), use_ssl ? "https" : "http",
1103 host_name ? host_name : server_address, server_port, server_url);
1104
1105 /* TODO: the hash component MUST be taken from the original URL and
1106 * attached to the URL in Location
1107 */
1108
1109 check_http ();
1110}
1111
1112/* check whether a file exists */
1113void
1114test_file (char *path)
1115{
1116 if (access(path, R_OK) == 0)
1117 return;
1118 usage2 (_("file does not exist or is not readable"), path);
1119}
1120
1121int
1122process_arguments (int argc, char **argv)
1123{
1124 char *p;
1125 int c = 1;
1126 char *temp;
1127
1128 enum {
1129 INVERT_REGEX = CHAR_MAX + 1,
1130 SNI_OPTION,
1131 CA_CERT_OPTION,
1132 HTTP_VERSION_OPTION
1133 };
1134
1135 int option = 0;
1136 int got_plus = 0;
1137 static struct option longopts[] = {
1138 STD_LONG_OPTS,
1139 {"link", no_argument, 0, 'L'},
1140 {"nohtml", no_argument, 0, 'n'},
1141 {"ssl", optional_argument, 0, 'S'},
1142 {"sni", no_argument, 0, SNI_OPTION},
1143 {"post", required_argument, 0, 'P'},
1144 {"method", required_argument, 0, 'j'},
1145 {"IP-address", required_argument, 0, 'I'},
1146 {"url", required_argument, 0, 'u'},
1147 {"port", required_argument, 0, 'p'},
1148 {"authorization", required_argument, 0, 'a'},
1149 {"proxy-authorization", required_argument, 0, 'b'},
1150 {"header-string", required_argument, 0, 'd'},
1151 {"string", required_argument, 0, 's'},
1152 {"expect", required_argument, 0, 'e'},
1153 {"regex", required_argument, 0, 'r'},
1154 {"ereg", required_argument, 0, 'r'},
1155 {"eregi", required_argument, 0, 'R'},
1156 {"linespan", no_argument, 0, 'l'},
1157 {"onredirect", required_argument, 0, 'f'},
1158 {"certificate", required_argument, 0, 'C'},
1159 {"client-cert", required_argument, 0, 'J'},
1160 {"private-key", required_argument, 0, 'K'},
1161 {"ca-cert", required_argument, 0, CA_CERT_OPTION},
1162 {"useragent", required_argument, 0, 'A'},
1163 {"header", required_argument, 0, 'k'},
1164 {"no-body", no_argument, 0, 'N'},
1165 {"max-age", required_argument, 0, 'M'},
1166 {"content-type", required_argument, 0, 'T'},
1167 {"pagesize", required_argument, 0, 'm'},
1168 {"invert-regex", no_argument, NULL, INVERT_REGEX},
1169 {"use-ipv4", no_argument, 0, '4'},
1170 {"use-ipv6", no_argument, 0, '6'},
1171 {"extended-perfdata", no_argument, 0, 'E'},
1172 {"http-version", required_argument, 0, HTTP_VERSION_OPTION},
1173 {0, 0, 0, 0}
1174 };
1175
1176 if (argc < 2)
1177 return ERROR;
1178
1179 /* support check_http compatible arguments */
1180 for (c = 1; c < argc; c++) {
1181 if (strcmp ("-to", argv[c]) == 0)
1182 strcpy (argv[c], "-t");
1183 if (strcmp ("-hn", argv[c]) == 0)
1184 strcpy (argv[c], "-H");
1185 if (strcmp ("-wt", argv[c]) == 0)
1186 strcpy (argv[c], "-w");
1187 if (strcmp ("-ct", argv[c]) == 0)
1188 strcpy (argv[c], "-c");
1189 if (strcmp ("-nohtml", argv[c]) == 0)
1190 strcpy (argv[c], "-n");
1191 }
1192
1193 server_url = strdup(DEFAULT_SERVER_URL);
1194
1195 while (1) {
1196 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);
1197 if (c == -1 || c == EOF || c == 1)
1198 break;
1199
1200 switch (c) {
1201 case 'h':
1202 print_help();
1203 exit(STATE_UNKNOWN);
1204 break;
1205 case 'V':
1206 print_revision(progname, NP_VERSION);
1207 print_curl_version();
1208 exit(STATE_UNKNOWN);
1209 break;
1210 case 'v':
1211 verbose++;
1212 break;
1213 case 't': /* timeout period */
1214 if (!is_intnonneg (optarg))
1215 usage2 (_("Timeout interval must be a positive integer"), optarg);
1216 else
1217 socket_timeout = (int)strtol (optarg, NULL, 10);
1218 break;
1219 case 'c': /* critical time threshold */
1220 critical_thresholds = optarg;
1221 break;
1222 case 'w': /* warning time threshold */
1223 warning_thresholds = optarg;
1224 break;
1225 case 'H': /* virtual host */
1226 host_name = strdup (optarg);
1227 if (host_name[0] == '[') {
1228 if ((p = strstr (host_name, "]:")) != NULL) { /* [IPv6]:port */
1229 virtual_port = atoi (p + 2);
1230 /* cut off the port */
1231 host_name_length = strlen (host_name) - strlen (p) - 1;
1232 free (host_name);
1233 host_name = strndup (optarg, host_name_length);
1234 }
1235 } else if ((p = strchr (host_name, ':')) != NULL
1236 && strchr (++p, ':') == NULL) { /* IPv4:port or host:port */
1237 virtual_port = atoi (p);
1238 /* cut off the port */
1239 host_name_length = strlen (host_name) - strlen (p) - 1;
1240 free (host_name);
1241 host_name = strndup (optarg, host_name_length);
1242 }
1243 break;
1244 case 'I': /* internet address */
1245 server_address = strdup (optarg);
1246 break;
1247 case 'u': /* URL path */
1248 server_url = strdup (optarg);
1249 break;
1250 case 'p': /* Server port */
1251 if (!is_intnonneg (optarg))
1252 usage2 (_("Invalid port number, expecting a non-negative number"), optarg);
1253 else {
1254 if( strtol(optarg, NULL, 10) > MAX_PORT)
1255 usage2 (_("Invalid port number, supplied port number is too big"), optarg);
1256 server_port = (unsigned short)strtol(optarg, NULL, 10);
1257 specify_port = TRUE;
1258 }
1259 break;
1260 case 'a': /* authorization info */
1261 strncpy (user_auth, optarg, MAX_INPUT_BUFFER - 1);
1262 user_auth[MAX_INPUT_BUFFER - 1] = 0;
1263 break;
1264 case 'b': /* proxy-authorization info */
1265 strncpy (proxy_auth, optarg, MAX_INPUT_BUFFER - 1);
1266 proxy_auth[MAX_INPUT_BUFFER - 1] = 0;
1267 break;
1268 case 'P': /* HTTP POST data in URL encoded format; ignored if settings already */
1269 if (! http_post_data)
1270 http_post_data = strdup (optarg);
1271 if (! http_method)
1272 http_method = strdup("POST");
1273 break;
1274 case 'j': /* Set HTTP method */
1275 if (http_method)
1276 free(http_method);
1277 http_method = strdup (optarg);
1278 break;
1279 case 'A': /* useragent */
1280 strncpy (user_agent, optarg, DEFAULT_BUFFER_SIZE);
1281 user_agent[DEFAULT_BUFFER_SIZE-1] = '\0';
1282 break;
1283 case 'k': /* Additional headers */
1284 if (http_opt_headers_count == 0)
1285 http_opt_headers = malloc (sizeof (char *) * (++http_opt_headers_count));
1286 else
1287 http_opt_headers = realloc (http_opt_headers, sizeof (char *) * (++http_opt_headers_count));
1288 http_opt_headers[http_opt_headers_count - 1] = optarg;
1289 break;
1290 case 'L': /* show html link */
1291 display_html = TRUE;
1292 break;
1293 case 'n': /* do not show html link */
1294 display_html = FALSE;
1295 break;
1296 case 'C': /* Check SSL cert validity */
1297#ifdef LIBCURL_FEATURE_SSL
1298 if ((temp=strchr(optarg,','))!=NULL) {
1299 *temp='\0';
1300 if (!is_intnonneg (optarg))
1301 usage2 (_("Invalid certificate expiration period"), optarg);
1302 days_till_exp_warn = atoi(optarg);
1303 *temp=',';
1304 temp++;
1305 if (!is_intnonneg (temp))
1306 usage2 (_("Invalid certificate expiration period"), temp);
1307 days_till_exp_crit = atoi (temp);
1308 }
1309 else {
1310 days_till_exp_crit=0;
1311 if (!is_intnonneg (optarg))
1312 usage2 (_("Invalid certificate expiration period"), optarg);
1313 days_till_exp_warn = atoi (optarg);
1314 }
1315 check_cert = TRUE;
1316 goto enable_ssl;
1317#endif
1318 case 'J': /* use client certificate */
1319#ifdef LIBCURL_FEATURE_SSL
1320 test_file(optarg);
1321 client_cert = optarg;
1322 goto enable_ssl;
1323#endif
1324 case 'K': /* use client private key */
1325#ifdef LIBCURL_FEATURE_SSL
1326 test_file(optarg);
1327 client_privkey = optarg;
1328 goto enable_ssl;
1329#endif
1330#ifdef LIBCURL_FEATURE_SSL
1331 case CA_CERT_OPTION: /* use CA chain file */
1332 test_file(optarg);
1333 ca_cert = optarg;
1334 goto enable_ssl;
1335#endif
1336 case 'S': /* use SSL */
1337#ifdef LIBCURL_FEATURE_SSL
1338 enable_ssl:
1339 use_ssl = TRUE;
1340 /* ssl_version initialized to CURL_SSLVERSION_DEFAULT as a default.
1341 * Only set if it's non-zero. This helps when we include multiple
1342 * parameters, like -S and -C combinations */
1343 ssl_version = CURL_SSLVERSION_DEFAULT;
1344 if (c=='S' && optarg != NULL) {
1345 char *plus_ptr = strchr(optarg, '+');
1346 if (plus_ptr) {
1347 got_plus = 1;
1348 *plus_ptr = '\0';
1349 }
1350
1351 if (optarg[0] == '2')
1352 ssl_version = CURL_SSLVERSION_SSLv2;
1353 else if (optarg[0] == '3')
1354 ssl_version = CURL_SSLVERSION_SSLv3;
1355 else if (!strcmp (optarg, "1") || !strcmp (optarg, "1.0"))
1356#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0)
1357 ssl_version = CURL_SSLVERSION_TLSv1_0;
1358#else
1359 ssl_version = CURL_SSLVERSION_DEFAULT;
1360#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */
1361 else if (!strcmp (optarg, "1.1"))
1362#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0)
1363 ssl_version = CURL_SSLVERSION_TLSv1_1;
1364#else
1365 ssl_version = CURL_SSLVERSION_DEFAULT;
1366#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */
1367 else if (!strcmp (optarg, "1.2"))
1368#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0)
1369 ssl_version = CURL_SSLVERSION_TLSv1_2;
1370#else
1371 ssl_version = CURL_SSLVERSION_DEFAULT;
1372#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 34, 0) */
1373 else if (!strcmp (optarg, "1.3"))
1374#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 52, 0)
1375 ssl_version = CURL_SSLVERSION_TLSv1_3;
1376#else
1377 ssl_version = CURL_SSLVERSION_DEFAULT;
1378#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 52, 0) */
1379 else
1380 usage4 (_("Invalid option - Valid SSL/TLS versions: 2, 3, 1, 1.1, 1.2, 1.3 (with optional '+' suffix)"));
1381 }
1382#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 54, 0)
1383 if (got_plus) {
1384 switch (ssl_version) {
1385 case CURL_SSLVERSION_TLSv1_3:
1386 ssl_version |= CURL_SSLVERSION_MAX_TLSv1_3;
1387 break;
1388 case CURL_SSLVERSION_TLSv1_2:
1389 case CURL_SSLVERSION_TLSv1_1:
1390 case CURL_SSLVERSION_TLSv1_0:
1391 ssl_version |= CURL_SSLVERSION_MAX_DEFAULT;
1392 break;
1393 }
1394 } else {
1395 switch (ssl_version) {
1396 case CURL_SSLVERSION_TLSv1_3:
1397 ssl_version |= CURL_SSLVERSION_MAX_TLSv1_3;
1398 break;
1399 case CURL_SSLVERSION_TLSv1_2:
1400 ssl_version |= CURL_SSLVERSION_MAX_TLSv1_2;
1401 break;
1402 case CURL_SSLVERSION_TLSv1_1:
1403 ssl_version |= CURL_SSLVERSION_MAX_TLSv1_1;
1404 break;
1405 case CURL_SSLVERSION_TLSv1_0:
1406 ssl_version |= CURL_SSLVERSION_MAX_TLSv1_0;
1407 break;
1408 }
1409 }
1410#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 54, 0) */
1411 if (verbose >= 2)
1412 printf(_("* Set SSL/TLS version to %d\n"), ssl_version);
1413 if (specify_port == FALSE)
1414 server_port = HTTPS_PORT;
1415 break;
1416#else /* LIBCURL_FEATURE_SSL */
1417 /* -C -J and -K fall through to here without SSL */
1418 usage4 (_("Invalid option - SSL is not available"));
1419 break;
1420 case SNI_OPTION: /* --sni is parsed, but ignored, the default is TRUE with libcurl */
1421 use_sni = TRUE;
1422 break;
1423#endif /* LIBCURL_FEATURE_SSL */
1424 case 'f': /* onredirect */
1425 if (!strcmp (optarg, "ok"))
1426 onredirect = STATE_OK;
1427 else if (!strcmp (optarg, "warning"))
1428 onredirect = STATE_WARNING;
1429 else if (!strcmp (optarg, "critical"))
1430 onredirect = STATE_CRITICAL;
1431 else if (!strcmp (optarg, "unknown"))
1432 onredirect = STATE_UNKNOWN;
1433 else if (!strcmp (optarg, "follow"))
1434 onredirect = STATE_DEPENDENT;
1435 else if (!strcmp (optarg, "stickyport"))
1436 onredirect = STATE_DEPENDENT, followmethod = FOLLOW_HTTP_CURL, followsticky = STICKY_HOST|STICKY_PORT;
1437 else if (!strcmp (optarg, "sticky"))
1438 onredirect = STATE_DEPENDENT, followmethod = FOLLOW_HTTP_CURL, followsticky = STICKY_HOST;
1439 else if (!strcmp (optarg, "follow"))
1440 onredirect = STATE_DEPENDENT, followmethod = FOLLOW_HTTP_CURL, followsticky = STICKY_NONE;
1441 else if (!strcmp (optarg, "curl"))
1442 onredirect = STATE_DEPENDENT, followmethod = FOLLOW_LIBCURL;
1443 else usage2 (_("Invalid onredirect option"), optarg);
1444 if (verbose >= 2)
1445 printf(_("* Following redirects set to %s\n"), state_text(onredirect));
1446 break;
1447 case 'd': /* string or substring */
1448 strncpy (header_expect, optarg, MAX_INPUT_BUFFER - 1);
1449 header_expect[MAX_INPUT_BUFFER - 1] = 0;
1450 break;
1451 case 's': /* string or substring */
1452 strncpy (string_expect, optarg, MAX_INPUT_BUFFER - 1);
1453 string_expect[MAX_INPUT_BUFFER - 1] = 0;
1454 break;
1455 case 'e': /* string or substring */
1456 strncpy (server_expect, optarg, MAX_INPUT_BUFFER - 1);
1457 server_expect[MAX_INPUT_BUFFER - 1] = 0;
1458 server_expect_yn = 1;
1459 break;
1460 case 'T': /* Content-type */
1461 http_content_type = strdup (optarg);
1462 break;
1463 case 'l': /* linespan */
1464 cflags &= ~REG_NEWLINE;
1465 break;
1466 case 'R': /* regex */
1467 cflags |= REG_ICASE;
1468 case 'r': /* regex */
1469 strncpy (regexp, optarg, MAX_RE_SIZE - 1);
1470 regexp[MAX_RE_SIZE - 1] = 0;
1471 errcode = regcomp (&preg, regexp, cflags);
1472 if (errcode != 0) {
1473 (void) regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
1474 printf (_("Could Not Compile Regular Expression: %s"), errbuf);
1475 return ERROR;
1476 }
1477 break;
1478 case INVERT_REGEX:
1479 invert_regex = 1;
1480 break;
1481 case '4':
1482 address_family = AF_INET;
1483 break;
1484 case '6':
1485#if defined (USE_IPV6) && defined (LIBCURL_FEATURE_IPV6)
1486 address_family = AF_INET6;
1487#else
1488 usage4 (_("IPv6 support not available"));
1489#endif
1490 break;
1491 case 'm': /* min_page_length */
1492 {
1493 char *tmp;
1494 if (strchr(optarg, ':') != (char *)NULL) {
1495 /* range, so get two values, min:max */
1496 tmp = strtok(optarg, ":");
1497 if (tmp == NULL) {
1498 printf("Bad format: try \"-m min:max\"\n");
1499 exit (STATE_WARNING);
1500 } else
1501 min_page_len = atoi(tmp);
1502
1503 tmp = strtok(NULL, ":");
1504 if (tmp == NULL) {
1505 printf("Bad format: try \"-m min:max\"\n");
1506 exit (STATE_WARNING);
1507 } else
1508 max_page_len = atoi(tmp);
1509 } else
1510 min_page_len = atoi (optarg);
1511 break;
1512 }
1513 case 'N': /* no-body */
1514 no_body = TRUE;
1515 break;
1516 case 'M': /* max-age */
1517 {
1518 int L = strlen(optarg);
1519 if (L && optarg[L-1] == 'm')
1520 maximum_age = atoi (optarg) * 60;
1521 else if (L && optarg[L-1] == 'h')
1522 maximum_age = atoi (optarg) * 60 * 60;
1523 else if (L && optarg[L-1] == 'd')
1524 maximum_age = atoi (optarg) * 60 * 60 * 24;
1525 else if (L && (optarg[L-1] == 's' ||
1526 isdigit (optarg[L-1])))
1527 maximum_age = atoi (optarg);
1528 else {
1529 fprintf (stderr, "unparsable max-age: %s\n", optarg);
1530 exit (STATE_WARNING);
1531 }
1532 if (verbose >= 2)
1533 printf ("* Maximal age of document set to %d seconds\n", maximum_age);
1534 }
1535 break;
1536 case 'E': /* show extended perfdata */
1537 show_extended_perfdata = TRUE;
1538 break;
1539 case HTTP_VERSION_OPTION:
1540 curl_http_version = CURL_HTTP_VERSION_NONE;
1541 if (strcmp (optarg, "1.0") == 0) {
1542 curl_http_version = CURL_HTTP_VERSION_1_0;
1543 } else if (strcmp (optarg, "1.1") == 0) {
1544 curl_http_version = CURL_HTTP_VERSION_1_1;
1545 } else if ((strcmp (optarg, "2.0") == 0) || (strcmp (optarg, "2") == 0)) {
1546#if LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 33, 0)
1547 curl_http_version = CURL_HTTP_VERSION_2_0;
1548#else
1549 curl_http_version = CURL_HTTP_VERSION_NONE;
1550#endif /* LIBCURL_VERSION_NUM >= MAKE_LIBCURL_VERSION(7, 33, 0) */
1551 } else {
1552 fprintf (stderr, "unkown http-version parameter: %s\n", optarg);
1553 exit (STATE_WARNING);
1554 }
1555 break;
1556 case '?':
1557 /* print short usage statement if args not parsable */
1558 usage5 ();
1559 break;
1560 }
1561 }
1562
1563 c = optind;
1564
1565 if (server_address == NULL && c < argc)
1566 server_address = strdup (argv[c++]);
1567
1568 if (host_name == NULL && c < argc)
1569 host_name = strdup (argv[c++]);
1570
1571 if (server_address == NULL) {
1572 if (host_name == NULL)
1573 usage4 (_("You must specify a server address or host name"));
1574 else
1575 server_address = strdup (host_name);
1576 }
1577
1578 set_thresholds(&thlds, warning_thresholds, critical_thresholds);
1579
1580 if (critical_thresholds && thlds->critical->end>(double)socket_timeout)
1581 socket_timeout = (int)thlds->critical->end + 1;
1582 if (verbose >= 2)
1583 printf ("* Socket timeout set to %ld seconds\n", socket_timeout);
1584
1585 if (http_method == NULL)
1586 http_method = strdup ("GET");
1587
1588 if (client_cert && !client_privkey)
1589 usage4 (_("If you use a client certificate you must also specify a private key file"));
1590
1591 if (virtual_port == 0)
1592 virtual_port = server_port;
1593 else {
1594 if ((use_ssl && server_port == HTTPS_PORT) || (!use_ssl && server_port == HTTP_PORT))
1595 if(specify_port == FALSE)
1596 server_port = virtual_port;
1597 }
1598
1599 return TRUE;
1600}
1601
1602char *perfd_time (double elapsed_time)
1603{
1604 return fperfdata ("time", elapsed_time, "s",
1605 thlds->warning?TRUE:FALSE, thlds->warning?thlds->warning->end:0,
1606 thlds->critical?TRUE:FALSE, thlds->critical?thlds->critical->end:0,
1607 TRUE, 0, TRUE, socket_timeout);
1608}
1609
1610char *perfd_time_connect (double elapsed_time_connect)
1611{
1612 return fperfdata ("time_connect", elapsed_time_connect, "s", FALSE, 0, FALSE, 0, FALSE, 0, TRUE, socket_timeout);
1613}
1614
1615char *perfd_time_ssl (double elapsed_time_ssl)
1616{
1617 return fperfdata ("time_ssl", elapsed_time_ssl, "s", FALSE, 0, FALSE, 0, FALSE, 0, TRUE, socket_timeout);
1618}
1619
1620char *perfd_time_headers (double elapsed_time_headers)
1621{
1622 return fperfdata ("time_headers", elapsed_time_headers, "s", FALSE, 0, FALSE, 0, FALSE, 0, TRUE, socket_timeout);
1623}
1624
1625char *perfd_time_firstbyte (double elapsed_time_firstbyte)
1626{
1627 return fperfdata ("time_firstbyte", elapsed_time_firstbyte, "s", FALSE, 0, FALSE, 0, FALSE, 0, TRUE, socket_timeout);
1628}
1629
1630char *perfd_time_transfer (double elapsed_time_transfer)
1631{
1632 return fperfdata ("time_transfer", elapsed_time_transfer, "s", FALSE, 0, FALSE, 0, FALSE, 0, TRUE, socket_timeout);
1633}
1634
1635char *perfd_size (int page_len)
1636{
1637 return perfdata ("size", page_len, "B",
1638 (min_page_len>0?TRUE:FALSE), min_page_len,
1639 (min_page_len>0?TRUE:FALSE), 0,
1640 TRUE, 0, FALSE, 0);
1641}
1642
1643void
1644print_help (void)
1645{
1646 print_revision (progname, NP_VERSION);
1647
1648 printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
1649 printf (COPYRIGHT, copyright, email);
1650
1651 printf ("%s\n", _("This plugin tests the HTTP service on the specified host. It can test"));
1652 printf ("%s\n", _("normal (http) and secure (https) servers, follow redirects, search for"));
1653 printf ("%s\n", _("strings and regular expressions, check connection times, and report on"));
1654 printf ("%s\n", _("certificate expiration times."));
1655 printf ("\n");
1656 printf ("%s\n", _("It makes use of libcurl to do so. It tries to be as compatible to check_http"));
1657 printf ("%s\n", _("as possible."));
1658
1659 printf ("\n\n");
1660
1661 print_usage ();
1662
1663 printf (_("NOTE: One or both of -H and -I must be specified"));
1664
1665 printf ("\n");
1666
1667 printf (UT_HELP_VRSN);
1668 printf (UT_EXTRA_OPTS);
1669
1670 printf (" %s\n", "-H, --hostname=ADDRESS");
1671 printf (" %s\n", _("Host name argument for servers using host headers (virtual host)"));
1672 printf (" %s\n", _("Append a port to include it in the header (eg: example.com:5000)"));
1673 printf (" %s\n", "-I, --IP-address=ADDRESS");
1674 printf (" %s\n", _("IP address or name (use numeric address if possible to bypass DNS lookup)."));
1675 printf (" %s\n", "-p, --port=INTEGER");
1676 printf (" %s", _("Port number (default: "));
1677 printf ("%d)\n", HTTP_PORT);
1678
1679 printf (UT_IPv46);
1680
1681#ifdef LIBCURL_FEATURE_SSL
1682 printf (" %s\n", "-S, --ssl=VERSION[+]");
1683 printf (" %s\n", _("Connect via SSL. Port defaults to 443. VERSION is optional, and prevents"));
1684 printf (" %s\n", _("auto-negotiation (2 = SSLv2, 3 = SSLv3, 1 = TLSv1, 1.1 = TLSv1.1,"));
1685 printf (" %s\n", _("1.2 = TLSv1.2, 1.3 = TLSv1.3). With a '+' suffix, newer versions are also accepted."));
1686 printf (" %s\n", _("Note: SSLv2 and SSLv3 are deprecated and are usually disabled in libcurl"));
1687 printf (" %s\n", "--sni");
1688 printf (" %s\n", _("Enable SSL/TLS hostname extension support (SNI)"));
1689#if LIBCURL_VERSION_NUM >= 0x071801
1690 printf (" %s\n", _("Note: --sni is the default in libcurl as SSLv2 and SSLV3 are deprecated and"));
1691 printf (" %s\n", _(" SNI only really works since TLSv1.0"));
1692#else
1693 printf (" %s\n", _("Note: SNI is not supported in libcurl before 7.18.1"));
1694#endif
1695 printf (" %s\n", "-C, --certificate=INTEGER[,INTEGER]");
1696 printf (" %s\n", _("Minimum number of days a certificate has to be valid. Port defaults to 443"));
1697 printf (" %s\n", _("(when this option is used the URL is not checked.)"));
1698 printf (" %s\n", "-J, --client-cert=FILE");
1699 printf (" %s\n", _("Name of file that contains the client certificate (PEM format)"));
1700 printf (" %s\n", _("to be used in establishing the SSL session"));
1701 printf (" %s\n", "-K, --private-key=FILE");
1702 printf (" %s\n", _("Name of file containing the private key (PEM format)"));
1703 printf (" %s\n", _("matching the client certificate"));
1704 printf (" %s\n", "--ca-cert=FILE");
1705 printf (" %s\n", _("CA certificate file to verify peer against"));
1706#endif
1707
1708 printf (" %s\n", "-e, --expect=STRING");
1709 printf (" %s\n", _("Comma-delimited list of strings, at least one of them is expected in"));
1710 printf (" %s", _("the first (status) line of the server response (default: "));
1711 printf ("%s)\n", HTTP_EXPECT);
1712 printf (" %s\n", _("If specified skips all other status line logic (ex: 3xx, 4xx, 5xx processing)"));
1713 printf (" %s\n", "-d, --header-string=STRING");
1714 printf (" %s\n", _("String to expect in the response headers"));
1715 printf (" %s\n", "-s, --string=STRING");
1716 printf (" %s\n", _("String to expect in the content"));
1717 printf (" %s\n", "-u, --url=PATH");
1718 printf (" %s\n", _("URL to GET or POST (default: /)"));
1719 printf (" %s\n", "-P, --post=STRING");
1720 printf (" %s\n", _("URL encoded http POST data"));
1721 printf (" %s\n", "-j, --method=STRING (for example: HEAD, OPTIONS, TRACE, PUT, DELETE, CONNECT)");
1722 printf (" %s\n", _("Set HTTP method."));
1723 printf (" %s\n", "-N, --no-body");
1724 printf (" %s\n", _("Don't wait for document body: stop reading after headers."));
1725 printf (" %s\n", _("(Note that this still does an HTTP GET or POST, not a HEAD.)"));
1726 printf (" %s\n", "-M, --max-age=SECONDS");
1727 printf (" %s\n", _("Warn if document is more than SECONDS old. the number can also be of"));
1728 printf (" %s\n", _("the form \"10m\" for minutes, \"10h\" for hours, or \"10d\" for days."));
1729 printf (" %s\n", "-T, --content-type=STRING");
1730 printf (" %s\n", _("specify Content-Type header media type when POSTing\n"));
1731 printf (" %s\n", "-l, --linespan");
1732 printf (" %s\n", _("Allow regex to span newlines (must precede -r or -R)"));
1733 printf (" %s\n", "-r, --regex, --ereg=STRING");
1734 printf (" %s\n", _("Search page for regex STRING"));
1735 printf (" %s\n", "-R, --eregi=STRING");
1736 printf (" %s\n", _("Search page for case-insensitive regex STRING"));
1737 printf (" %s\n", "--invert-regex");
1738 printf (" %s\n", _("Return CRITICAL if found, OK if not\n"));
1739 printf (" %s\n", "-a, --authorization=AUTH_PAIR");
1740 printf (" %s\n", _("Username:password on sites with basic authentication"));
1741 printf (" %s\n", "-b, --proxy-authorization=AUTH_PAIR");
1742 printf (" %s\n", _("Username:password on proxy-servers with basic authentication"));
1743 printf (" %s\n", "-A, --useragent=STRING");
1744 printf (" %s\n", _("String to be sent in http header as \"User Agent\""));
1745 printf (" %s\n", "-k, --header=STRING");
1746 printf (" %s\n", _("Any other tags to be sent in http header. Use multiple times for additional headers"));
1747 printf (" %s\n", "-E, --extended-perfdata");
1748 printf (" %s\n", _("Print additional performance data"));
1749 printf (" %s\n", "-L, --link");
1750 printf (" %s\n", _("Wrap output in HTML link (obsoleted by urlize)"));
1751 printf (" %s\n", "-f, --onredirect=<ok|warning|critical|follow|sticky|stickyport|curl>");
1752 printf (" %s\n", _("How to handle redirected pages. sticky is like follow but stick to the"));
1753 printf (" %s\n", _("specified IP address. stickyport also ensures port stays the same."));
1754 printf (" %s\n", _("follow uses the old redirection algorithm of check_http."));
1755 printf (" %s\n", _("curl uses CURL_FOLLOWLOCATION built into libcurl."));
1756 printf (" %s\n", "-m, --pagesize=INTEGER<:INTEGER>");
1757 printf (" %s\n", _("Minimum page size required (bytes) : Maximum page size required (bytes)"));
1758 printf ("\n");
1759 printf (" %s\n", "--http-version=VERSION");
1760 printf (" %s\n", _("Connect via specific HTTP protocol."));
1761 printf (" %s\n", _("1.0 = HTTP/1.0, 1.1 = HTTP/1.1, 2.0 = HTTP/2 (HTTP/2 will fail without -S)"));
1762 printf ("\n");
1763
1764 printf (UT_WARN_CRIT);
1765
1766 printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT);
1767
1768 printf (UT_VERBOSE);
1769
1770 printf ("\n");
1771 printf ("%s\n", _("Notes:"));
1772 printf (" %s\n", _("This plugin will attempt to open an HTTP connection with the host."));
1773 printf (" %s\n", _("Successful connects return STATE_OK, refusals and timeouts return STATE_CRITICAL"));
1774 printf (" %s\n", _("other errors return STATE_UNKNOWN. Successful connects, but incorrect response"));
1775 printf (" %s\n", _("messages from the host result in STATE_WARNING return values. If you are"));
1776 printf (" %s\n", _("checking a virtual server that uses 'host headers' you must supply the FQDN"));
1777 printf (" %s\n", _("(fully qualified domain name) as the [host_name] argument."));
1778
1779#ifdef LIBCURL_FEATURE_SSL
1780 printf ("\n");
1781 printf (" %s\n", _("This plugin can also check whether an SSL enabled web server is able to"));
1782 printf (" %s\n", _("serve content (optionally within a specified time) or whether the X509 "));
1783 printf (" %s\n", _("certificate is still valid for the specified number of days."));
1784 printf ("\n");
1785 printf (" %s\n", _("Please note that this plugin does not check if the presented server"));
1786 printf (" %s\n", _("certificate matches the hostname of the server, or if the certificate"));
1787 printf (" %s\n", _("has a valid chain of trust to one of the locally installed CAs."));
1788 printf ("\n");
1789 printf ("%s\n", _("Examples:"));
1790 printf (" %s\n\n", "CHECK CONTENT: check_curl -w 5 -c 10 --ssl -H www.verisign.com");
1791 printf (" %s\n", _("When the 'www.verisign.com' server returns its content within 5 seconds,"));
1792 printf (" %s\n", _("a STATE_OK will be returned. When the server returns its content but exceeds"));
1793 printf (" %s\n", _("the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,"));
1794 printf (" %s\n", _("a STATE_CRITICAL will be returned."));
1795 printf ("\n");
1796 printf (" %s\n\n", "CHECK CERTIFICATE: check_curl -H www.verisign.com -C 14");
1797 printf (" %s\n", _("When the certificate of 'www.verisign.com' is valid for more than 14 days,"));
1798 printf (" %s\n", _("a STATE_OK is returned. When the certificate is still valid, but for less than"));
1799 printf (" %s\n", _("14 days, a STATE_WARNING is returned. A STATE_CRITICAL will be returned when"));
1800 printf (" %s\n\n", _("the certificate is expired."));
1801 printf ("\n");
1802 printf (" %s\n\n", "CHECK CERTIFICATE: check_curl -H www.verisign.com -C 30,14");
1803 printf (" %s\n", _("When the certificate of 'www.verisign.com' is valid for more than 30 days,"));
1804 printf (" %s\n", _("a STATE_OK is returned. When the certificate is still valid, but for less than"));
1805 printf (" %s\n", _("30 days, but more than 14 days, a STATE_WARNING is returned."));
1806 printf (" %s\n", _("A STATE_CRITICAL will be returned when certificate expires in less than 14 days"));
1807#endif
1808
1809 printf ("\n %s\n", "CHECK WEBSERVER CONTENT VIA PROXY:");
1810 printf (" %s\n", _("It is recommended to use an environment proxy like:"));
1811 printf (" %s\n", _("http_proxy=http://192.168.100.35:3128 ./check_curl -H www.monitoring-plugins.org"));
1812 printf (" %s\n", _("legacy proxy requests in check_http style still work:"));
1813 printf (" %s\n", _("check_curl -I 192.168.100.35 -p 3128 -u http://www.monitoring-plugins.org/ -H www.monitoring-plugins.org"));
1814
1815#ifdef LIBCURL_FEATURE_SSL
1816 printf ("\n %s\n", "CHECK SSL WEBSERVER CONTENT VIA PROXY USING HTTP 1.1 CONNECT: ");
1817 printf (" %s\n", _("It is recommended to use an environment proxy like:"));
1818 printf (" %s\n", _("https_proxy=http://192.168.100.35:3128 ./check_curl -H www.verisign.com -S"));
1819 printf (" %s\n", _("legacy proxy requests in check_http style still work:"));
1820 printf (" %s\n", _("check_curl -I 192.168.100.35 -p 3128 -u https://www.verisign.com/ -S -j CONNECT -H www.verisign.com "));
1821 printf (" %s\n", _("all these options are needed: -I <proxy> -p <proxy-port> -u <check-url> -S(sl) -j CONNECT -H <webserver>"));
1822 printf (" %s\n", _("a STATE_OK will be returned. When the server returns its content but exceeds"));
1823 printf (" %s\n", _("the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,"));
1824 printf (" %s\n", _("a STATE_CRITICAL will be returned."));
1825
1826#endif
1827
1828 printf (UT_SUPPORT);
1829
1830}
1831
1832
1833
1834void
1835print_usage (void)
1836{
1837 printf ("%s\n", _("Usage:"));
1838 printf (" %s -H <vhost> | -I <IP-address> [-u <uri>] [-p <port>]\n",progname);
1839 printf (" [-J <client certificate file>] [-K <private key>] [--ca-cert <CA certificate file>]\n");
1840 printf (" [-w <warn time>] [-c <critical time>] [-t <timeout>] [-L] [-E] [-a auth]\n");
1841 printf (" [-b proxy_auth] [-f <ok|warning|critcal|follow|sticky|stickyport|curl>]\n");
1842 printf (" [-e <expect>] [-d string] [-s string] [-l] [-r <regex> | -R <case-insensitive regex>]\n");
1843 printf (" [-P string] [-m <min_pg_size>:<max_pg_size>] [-4|-6] [-N] [-M <age>]\n");
1844 printf (" [-A string] [-k string] [-S <version>] [--sni] [-C <warn_age>[,<crit_age>]]\n");
1845 printf (" [-T <content-type>] [-j method]\n");
1846 printf (" [--http-version=<version>]\n");
1847 printf ("\n");
1848 printf ("%s\n", _("WARNING: check_curl is experimental. Please use"));
1849 printf ("%s\n\n", _("check_http if you need a stable version."));
1850}
1851
1852void
1853print_curl_version (void)
1854{
1855 printf( "%s\n", curl_version());
1856}
1857
1858int
1859curlhelp_initwritebuffer (curlhelp_write_curlbuf *buf)
1860{
1861 buf->bufsize = DEFAULT_BUFFER_SIZE;
1862 buf->buflen = 0;
1863 buf->buf = (char *)malloc ((size_t)buf->bufsize);
1864 if (buf->buf == NULL) return -1;
1865 return 0;
1866}
1867
1868int
1869curlhelp_buffer_write_callback (void *buffer, size_t size, size_t nmemb, void *stream)
1870{
1871 curlhelp_write_curlbuf *buf = (curlhelp_write_curlbuf *)stream;
1872
1873 while (buf->bufsize < buf->buflen + size * nmemb + 1) {
1874 buf->bufsize *= buf->bufsize * 2;
1875 buf->buf = (char *)realloc (buf->buf, buf->bufsize);
1876 if (buf->buf == NULL) return -1;
1877 }
1878
1879 memcpy (buf->buf + buf->buflen, buffer, size * nmemb);
1880 buf->buflen += size * nmemb;
1881 buf->buf[buf->buflen] = '\0';
1882
1883 return (int)(size * nmemb);
1884}
1885
1886int
1887curlhelp_buffer_read_callback (void *buffer, size_t size, size_t nmemb, void *stream)
1888{
1889 curlhelp_read_curlbuf *buf = (curlhelp_read_curlbuf *)stream;
1890
1891 size_t n = min (nmemb * size, buf->buflen - buf->pos);
1892
1893 memcpy (buffer, buf->buf + buf->pos, n);
1894 buf->pos += n;
1895
1896 return (int)n;
1897}
1898
1899void
1900curlhelp_freewritebuffer (curlhelp_write_curlbuf *buf)
1901{
1902 free (buf->buf);
1903 buf->buf = NULL;
1904}
1905
1906int
1907curlhelp_initreadbuffer (curlhelp_read_curlbuf *buf, const char *data, size_t datalen)
1908{
1909 buf->buflen = datalen;
1910 buf->buf = (char *)malloc ((size_t)buf->buflen);
1911 if (buf->buf == NULL) return -1;
1912 memcpy (buf->buf, data, datalen);
1913 buf->pos = 0;
1914 return 0;
1915}
1916
1917void
1918curlhelp_freereadbuffer (curlhelp_read_curlbuf *buf)
1919{
1920 free (buf->buf);
1921 buf->buf = NULL;
1922}
1923
1924/* TODO: where to put this, it's actually part of sstrings2 (logically)?
1925 */
1926const char*
1927strrstr2(const char *haystack, const char *needle)
1928{
1929 int counter;
1930 size_t len;
1931 const char *prev_pos;
1932 const char *pos;
1933
1934 if (haystack == NULL || needle == NULL)
1935 return NULL;
1936
1937 if (haystack[0] == '\0' || needle[0] == '\0')
1938 return NULL;
1939
1940 counter = 0;
1941 prev_pos = NULL;
1942 pos = haystack;
1943 len = strlen (needle);
1944 for (;;) {
1945 pos = strstr (pos, needle);
1946 if (pos == NULL) {
1947 if (counter == 0)
1948 return NULL;
1949 else
1950 return prev_pos;
1951 }
1952 counter++;
1953 prev_pos = pos;
1954 pos += len;
1955 if (*pos == '\0') return prev_pos;
1956 }
1957}
1958
1959int
1960curlhelp_parse_statusline (const char *buf, curlhelp_statusline *status_line)
1961{
1962 char *first_line_end;
1963 char *p;
1964 size_t first_line_len;
1965 char *pp;
1966 const char *start;
1967 char *first_line_buf;
1968
1969 /* find last start of a new header */
1970 start = strrstr2 (buf, "\r\nHTTP");
1971 if (start != NULL) {
1972 start += 2;
1973 buf = start;
1974 }
1975
1976 first_line_end = strstr(buf, "\r\n");
1977 if (first_line_end == NULL) return -1;
1978
1979 first_line_len = (size_t)(first_line_end - buf);
1980 status_line->first_line = (char *)malloc (first_line_len + 1);
1981 if (status_line->first_line == NULL) return -1;
1982 memcpy (status_line->first_line, buf, first_line_len);
1983 status_line->first_line[first_line_len] = '\0';
1984 first_line_buf = strdup( status_line->first_line );
1985
1986 /* protocol and version: "HTTP/x.x" SP or "HTTP/2" SP */
1987
1988 p = strtok(first_line_buf, "/");
1989 if( p == NULL ) { free( first_line_buf ); return -1; }
1990 if( strcmp( p, "HTTP" ) != 0 ) { free( first_line_buf ); return -1; }
1991
1992 p = strtok( NULL, " " );
1993 if( p == NULL ) { free( first_line_buf ); return -1; }
1994 if( strchr( p, '.' ) != NULL ) {
1995
1996 /* HTTP 1.x case */
1997 char *ppp;
1998 ppp = strtok( p, "." );
1999 status_line->http_major = (int)strtol( p, &pp, 10 );
2000 if( *pp != '\0' ) { free( first_line_buf ); return -1; }
2001 ppp = strtok( NULL, " " );
2002 status_line->http_minor = (int)strtol( p, &pp, 10 );
2003 if( *pp != '\0' ) { free( first_line_buf ); return -1; }
2004 p += 4; /* 1.x SP */
2005 } else {
2006 /* HTTP 2 case */
2007 status_line->http_major = (int)strtol( p, &pp, 10 );
2008 status_line->http_minor = 0;
2009 p += 2; /* 2 SP */
2010 }
2011
2012 /* status code: "404" or "404.1", then SP */
2013
2014 p = strtok( p, " " );
2015 if( p == NULL ) { free( first_line_buf ); return -1; }
2016 if( strchr( p, '.' ) != NULL ) {
2017 char *ppp;
2018 ppp = strtok( p, "." );
2019 status_line->http_code = (int)strtol( ppp, &pp, 10 );
2020 if( *pp != '\0' ) { free( first_line_buf ); return -1; }
2021 ppp = strtok( NULL, "" );
2022 status_line->http_subcode = (int)strtol( ppp, &pp, 10 );
2023 if( *pp != '\0' ) { free( first_line_buf ); return -1; }
2024 p += 6; /* 400.1 SP */
2025 } else {
2026 status_line->http_code = (int)strtol( p, &pp, 10 );
2027 status_line->http_subcode = -1;
2028 if( *pp != '\0' ) { free( first_line_buf ); return -1; }
2029 p += 4; /* 400 SP */
2030 }
2031
2032 /* Human readable message: "Not Found" CRLF */
2033
2034 p = strtok( p, "" );
2035 if( p == NULL ) { status_line->msg = ""; return 0; }
2036 status_line->msg = status_line->first_line + ( p - first_line_buf );
2037 free( first_line_buf );
2038
2039 return 0;
2040}
2041
2042void
2043curlhelp_free_statusline (curlhelp_statusline *status_line)
2044{
2045 free (status_line->first_line);
2046}
2047
2048void
2049remove_newlines (char *s)
2050{
2051 char *p;
2052
2053 for (p = s; *p != '\0'; p++)
2054 if (*p == '\r' || *p == '\n')
2055 *p = ' ';
2056}
2057
2058char *
2059get_header_value (const struct phr_header* headers, const size_t nof_headers, const char* header)
2060{
2061 int i;
2062 for( i = 0; i < nof_headers; i++ ) {
2063 if(headers[i].name != NULL && strncasecmp( header, headers[i].name, max( headers[i].name_len, 4 ) ) == 0 ) {
2064 return strndup( headers[i].value, headers[i].value_len );
2065 }
2066 }
2067 return NULL;
2068}
2069
2070int
2071check_document_dates (const curlhelp_write_curlbuf *header_buf, char (*msg)[DEFAULT_BUFFER_SIZE])
2072{
2073 char *server_date = NULL;
2074 char *document_date = NULL;
2075 int date_result = STATE_OK;
2076 curlhelp_statusline status_line;
2077 struct phr_header headers[255];
2078 size_t nof_headers = 255;
2079 size_t msglen;
2080
2081 int res = phr_parse_response (header_buf->buf, header_buf->buflen,
2082 &status_line.http_minor, &status_line.http_code, &status_line.msg, &msglen,
2083 headers, &nof_headers, 0);
2084
2085 server_date = get_header_value (headers, nof_headers, "date");
2086 document_date = get_header_value (headers, nof_headers, "last-modified");
2087
2088 if (!server_date || !*server_date) {
2089 snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sServer date unknown, "), *msg);
2090 date_result = max_state_alt(STATE_UNKNOWN, date_result);
2091 } else if (!document_date || !*document_date) {
2092 snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sDocument modification date unknown, "), *msg);
2093 date_result = max_state_alt(STATE_CRITICAL, date_result);
2094 } else {
2095 time_t srv_data = curl_getdate (server_date, NULL);
2096 time_t doc_data = curl_getdate (document_date, NULL);
2097 if (verbose >= 2)
2098 printf ("* server date: '%s' (%d), doc_date: '%s' (%d)\n", server_date, (int)srv_data, document_date, (int)doc_data);
2099 if (srv_data <= 0) {
2100 snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sServer date \"%100s\" unparsable, "), *msg, server_date);
2101 date_result = max_state_alt(STATE_CRITICAL, date_result);
2102 } else if (doc_data <= 0) {
2103 snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sDocument date \"%100s\" unparsable, "), *msg, document_date);
2104 date_result = max_state_alt(STATE_CRITICAL, date_result);
2105 } else if (doc_data > srv_data + 30) {
2106 snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sDocument is %d seconds in the future, "), *msg, (int)doc_data - (int)srv_data);
2107 date_result = max_state_alt(STATE_CRITICAL, date_result);
2108 } else if (doc_data < srv_data - maximum_age) {
2109 int n = (srv_data - doc_data);
2110 if (n > (60 * 60 * 24 * 2)) {
2111 snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sLast modified %.1f days ago, "), *msg, ((float) n) / (60 * 60 * 24));
2112 date_result = max_state_alt(STATE_CRITICAL, date_result);
2113 } else {
2114 snprintf (*msg, DEFAULT_BUFFER_SIZE, _("%sLast modified %d:%02d:%02d ago, "), *msg, n / (60 * 60), (n / 60) % 60, n % 60);
2115 date_result = max_state_alt(STATE_CRITICAL, date_result);
2116 }
2117 }
2118 }
2119
2120 if (server_date) free (server_date);
2121 if (document_date) free (document_date);
2122
2123 return date_result;
2124}
2125
2126
2127int
2128get_content_length (const curlhelp_write_curlbuf* header_buf, const curlhelp_write_curlbuf* body_buf)
2129{
2130 const char *s;
2131 int content_length = 0;
2132 char *copy;
2133 struct phr_header headers[255];
2134 size_t nof_headers = 255;
2135 size_t msglen;
2136 char *content_length_s = NULL;
2137 curlhelp_statusline status_line;
2138
2139 int res = phr_parse_response (header_buf->buf, header_buf->buflen,
2140 &status_line.http_minor, &status_line.http_code, &status_line.msg, &msglen,
2141 headers, &nof_headers, 0);
2142
2143 content_length_s = get_header_value (headers, nof_headers, "content-length");
2144 if (!content_length_s) {
2145 return header_buf->buflen + body_buf->buflen;
2146 }
2147 content_length_s += strspn (content_length_s, " \t");
2148 content_length = atoi (content_length_s);
2149 if (content_length != body_buf->buflen) {
2150 /* TODO: should we warn if the actual and the reported body length don't match? */
2151 }
2152
2153 if (content_length_s) free (content_length_s);
2154
2155 return header_buf->buflen + body_buf->buflen;
2156}
2157
2158/* TODO: is there a better way in libcurl to check for the SSL library? */
2159curlhelp_ssl_library
2160curlhelp_get_ssl_library (CURL* curl)
2161{
2162 curl_version_info_data* version_data;
2163 char *ssl_version;
2164 char *library;
2165 curlhelp_ssl_library ssl_library = CURLHELP_SSL_LIBRARY_UNKNOWN;
2166
2167 version_data = curl_version_info (CURLVERSION_NOW);
2168 if (version_data == NULL) return CURLHELP_SSL_LIBRARY_UNKNOWN;
2169
2170 ssl_version = strdup (version_data->ssl_version);
2171 if (ssl_version == NULL ) return CURLHELP_SSL_LIBRARY_UNKNOWN;
2172
2173 library = strtok (ssl_version, "/");
2174 if (library == NULL) return CURLHELP_SSL_LIBRARY_UNKNOWN;
2175
2176 if (strcmp (library, "OpenSSL") == 0)
2177 ssl_library = CURLHELP_SSL_LIBRARY_OPENSSL;
2178 else if (strcmp (library, "LibreSSL") == 0)
2179 ssl_library = CURLHELP_SSL_LIBRARY_LIBRESSL;
2180 else if (strcmp (library, "GnuTLS") == 0)
2181 ssl_library = CURLHELP_SSL_LIBRARY_GNUTLS;
2182 else if (strcmp (library, "NSS") == 0)
2183 ssl_library = CURLHELP_SSL_LIBRARY_NSS;
2184
2185 if (verbose >= 2)
2186 printf ("* SSL library string is : %s %s (%d)\n", version_data->ssl_version, library, ssl_library);
2187
2188 free (ssl_version);
2189
2190 return ssl_library;
2191}
2192
2193const char*
2194curlhelp_get_ssl_library_string (curlhelp_ssl_library ssl_library)
2195{
2196 switch (ssl_library) {
2197 case CURLHELP_SSL_LIBRARY_OPENSSL:
2198 return "OpenSSL";
2199 case CURLHELP_SSL_LIBRARY_LIBRESSL:
2200 return "LibreSSL";
2201 case CURLHELP_SSL_LIBRARY_GNUTLS:
2202 return "GnuTLS";
2203 case CURLHELP_SSL_LIBRARY_NSS:
2204 return "NSS";
2205 case CURLHELP_SSL_LIBRARY_UNKNOWN:
2206 default:
2207 return "unknown";
2208 }
2209}
2210
2211#ifdef LIBCURL_FEATURE_SSL
2212#ifndef USE_OPENSSL
2213time_t
2214parse_cert_date (const char *s)
2215{
2216 struct tm tm;
2217 time_t date;
2218 char *res;
2219
2220 if (!s) return -1;
2221
2222 /* Jan 17 14:25:12 2020 GMT */
2223 res = strptime (s, "%Y-%m-%d %H:%M:%S GMT", &tm);
2224 /* Sep 11 12:00:00 2020 GMT */
2225 if (res == NULL) strptime (s, "%Y %m %d %H:%M:%S GMT", &tm);
2226 date = mktime (&tm);
2227
2228 return date;
2229}
2230
2231/* TODO: this needs cleanup in the sslutils.c, maybe we the #else case to
2232 * OpenSSL could be this function
2233 */
2234int
2235net_noopenssl_check_certificate (cert_ptr_union* cert_ptr, int days_till_exp_warn, int days_till_exp_crit)
2236{
2237 int i;
2238 struct curl_slist* slist;
2239 int cname_found = 0;
2240 char* start_date_str = NULL;
2241 char* end_date_str = NULL;
2242 time_t start_date;
2243 time_t end_date;
2244 char *tz;
2245 float time_left;
2246 int days_left;
2247 int time_remaining;
2248 char timestamp[50] = "";
2249 int status = STATE_UNKNOWN;
2250
2251 if (verbose >= 2)
2252 printf ("**** REQUEST CERTIFICATES ****\n");
2253
2254 for (i = 0; i < cert_ptr->to_certinfo->num_of_certs; i++) {
2255 for (slist = cert_ptr->to_certinfo->certinfo[i]; slist; slist = slist->next) {
2256 /* find first common name in subject,
2257 * TODO: check alternative subjects for
2258 * TODO: have a decent parser here and not a hack
2259 * multi-host certificate, check wildcards
2260 */
2261 if (strncasecmp (slist->data, "Subject:", 8) == 0) {
2262 int d = 3;
2263 char* p = strstr (slist->data, "CN=");
2264 if (p == NULL) {
2265 d = 5;
2266 p = strstr (slist->data, "CN = ");
2267 }
2268 if (p != NULL) {
2269 if (strncmp (host_name, p+d, strlen (host_name)) == 0) {
2270 cname_found = 1;
2271 }
2272 }
2273 } else if (strncasecmp (slist->data, "Start Date:", 11) == 0) {
2274 start_date_str = &slist->data[11];
2275 } else if (strncasecmp (slist->data, "Expire Date:", 12) == 0) {
2276 end_date_str = &slist->data[12];
2277 } else if (strncasecmp (slist->data, "Cert:", 5) == 0) {
2278 goto HAVE_FIRST_CERT;
2279 }
2280 if (verbose >= 2)
2281 printf ("%d ** %s\n", i, slist->data);
2282 }
2283 }
2284HAVE_FIRST_CERT:
2285
2286 if (verbose >= 2)
2287 printf ("**** REQUEST CERTIFICATES ****\n");
2288
2289 if (!cname_found) {
2290 printf("%s\n",_("CRITICAL - Cannot retrieve certificate subject."));
2291 return STATE_CRITICAL;
2292 }
2293
2294 start_date = parse_cert_date (start_date_str);
2295 if (start_date <= 0) {
2296 snprintf (msg, DEFAULT_BUFFER_SIZE, _("WARNING - Unparsable 'Start Date' in certificate: '%s'"),
2297 start_date_str);
2298 puts (msg);
2299 return STATE_WARNING;
2300 }
2301
2302 end_date = parse_cert_date (end_date_str);
2303 if (end_date <= 0) {
2304 snprintf (msg, DEFAULT_BUFFER_SIZE, _("WARNING - Unparsable 'Expire Date' in certificate: '%s'"),
2305 start_date_str);
2306 puts (msg);
2307 return STATE_WARNING;
2308 }
2309
2310 time_left = difftime (end_date, time(NULL));
2311 days_left = time_left / 86400;
2312 tz = getenv("TZ");
2313 setenv("TZ", "GMT", 1);
2314 tzset();
2315 strftime(timestamp, 50, "%c %z", localtime(&end_date));
2316 if (tz)
2317 setenv("TZ", tz, 1);
2318 else
2319 unsetenv("TZ");
2320 tzset();
2321
2322 if (days_left > 0 && days_left <= days_till_exp_warn) {
2323 printf (_("%s - Certificate '%s' expires in %d day(s) (%s).\n"), (days_left>days_till_exp_crit)?"WARNING":"CRITICAL", host_name, days_left, timestamp);
2324 if (days_left > days_till_exp_crit)
2325 status = STATE_WARNING;
2326 else
2327 status = STATE_CRITICAL;
2328 } else if (days_left == 0 && time_left > 0) {
2329 if (time_left >= 3600)
2330 time_remaining = (int) time_left / 3600;
2331 else
2332 time_remaining = (int) time_left / 60;
2333
2334 printf (_("%s - Certificate '%s' expires in %u %s (%s)\n"),
2335 (days_left>days_till_exp_crit) ? "WARNING" : "CRITICAL", host_name, time_remaining,
2336 time_left >= 3600 ? "hours" : "minutes", timestamp);
2337
2338 if ( days_left > days_till_exp_crit)
2339 status = STATE_WARNING;
2340 else
2341 status = STATE_CRITICAL;
2342 } else if (time_left < 0) {
2343 printf(_("CRITICAL - Certificate '%s' expired on %s.\n"), host_name, timestamp);
2344 status=STATE_CRITICAL;
2345 } else if (days_left == 0) {
2346 printf (_("%s - Certificate '%s' just expired (%s).\n"), (days_left>days_till_exp_crit)?"WARNING":"CRITICAL", host_name, timestamp);
2347 if (days_left > days_till_exp_crit)
2348 status = STATE_WARNING;
2349 else
2350 status = STATE_CRITICAL;
2351 } else {
2352 printf(_("OK - Certificate '%s' will expire on %s.\n"), host_name, timestamp);
2353 status = STATE_OK;
2354 }
2355 return status;
2356}
2357#endif /* USE_OPENSSL */
2358#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..844e625f 100644
--- a/plugins/check_disk.c
+++ b/plugins/check_disk.c
@@ -141,6 +141,7 @@ int erronly = FALSE;
141int display_mntp = FALSE; 141int display_mntp = FALSE;
142int exact_match = FALSE; 142int exact_match = FALSE;
143int freespace_ignore_reserved = FALSE; 143int freespace_ignore_reserved = FALSE;
144int display_inodes_perfdata = FALSE;
144char *warn_freespace_units = NULL; 145char *warn_freespace_units = NULL;
145char *crit_freespace_units = NULL; 146char *crit_freespace_units = NULL;
146char *warn_freespace_percent = NULL; 147char *warn_freespace_percent = NULL;
@@ -167,6 +168,7 @@ 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;
@@ -186,6 +188,7 @@ main (int argc, char **argv)
186 output = strdup (""); 188 output = strdup ("");
187 details = strdup (""); 189 details = strdup ("");
188 perf = strdup (""); 190 perf = strdup ("");
191 perf_ilabel = strdup ("");
189 stat_buf = malloc(sizeof *stat_buf); 192 stat_buf = malloc(sizeof *stat_buf);
190 193
191 setlocale (LC_ALL, ""); 194 setlocale (LC_ALL, "");
@@ -348,6 +351,29 @@ main (int argc, char **argv)
348 TRUE, 0, 351 TRUE, 0,
349 TRUE, path->dtotal_units)); 352 TRUE, path->dtotal_units));
350 353
354 if (display_inodes_perfdata) {
355 /* *_high_tide must be reinitialized at each run */
356 warning_high_tide = UINT_MAX;
357 critical_high_tide = UINT_MAX;
358
359 if (path->freeinodes_percent->warning != NULL) {
360 warning_high_tide = abs( min( (double) warning_high_tide, (double) (1.0 - path->freeinodes_percent->warning->end/100)*path->inodes_total ));
361 }
362 if (path->freeinodes_percent->critical != NULL) {
363 critical_high_tide = abs( min( (double) critical_high_tide, (double) (1.0 - path->freeinodes_percent->critical->end/100)*path->inodes_total ));
364 }
365
366 xasprintf (&perf_ilabel, "%s (inodes)", (!strcmp(me->me_mountdir, "none") || display_mntp) ? me->me_devname : me->me_mountdir);
367 /* Nb: *_high_tide are unset when == UINT_MAX */
368 xasprintf (&perf, "%s %s", perf,
369 perfdata (perf_ilabel,
370 path->inodes_used, "",
371 (warning_high_tide != UINT_MAX ? TRUE : FALSE), warning_high_tide,
372 (critical_high_tide != UINT_MAX ? TRUE : FALSE), critical_high_tide,
373 TRUE, 0,
374 TRUE, path->inodes_total));
375 }
376
351 if (disk_result==STATE_OK && erronly && !verbose) 377 if (disk_result==STATE_OK && erronly && !verbose)
352 continue; 378 continue;
353 379
@@ -455,6 +481,7 @@ process_arguments (int argc, char **argv)
455 {"ignore-eregi-partition", required_argument, 0, 'I'}, 481 {"ignore-eregi-partition", required_argument, 0, 'I'},
456 {"local", no_argument, 0, 'l'}, 482 {"local", no_argument, 0, 'l'},
457 {"stat-remote-fs", no_argument, 0, 'L'}, 483 {"stat-remote-fs", no_argument, 0, 'L'},
484 {"iperfdata", no_argument, 0, 'P'},
458 {"mountpoint", no_argument, 0, 'M'}, 485 {"mountpoint", no_argument, 0, 'M'},
459 {"errors-only", no_argument, 0, 'e'}, 486 {"errors-only", no_argument, 0, 'e'},
460 {"exact-match", no_argument, 0, 'E'}, 487 {"exact-match", no_argument, 0, 'E'},
@@ -477,7 +504,7 @@ process_arguments (int argc, char **argv)
477 strcpy (argv[c], "-t"); 504 strcpy (argv[c], "-t");
478 505
479 while (1) { 506 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); 507 c = getopt_long (argc, argv, "+?VqhvefCt:c:w:K:W:u:p:x:X:N:mklLPg:R:r:i:I:MEA", longopts, &option);
481 508
482 if (c == -1 || c == EOF) 509 if (c == -1 || c == EOF)
483 break; 510 break;
@@ -582,9 +609,13 @@ process_arguments (int argc, char **argv)
582 break; 609 break;
583 case 'L': 610 case 'L':
584 stat_remote_fs = 1; 611 stat_remote_fs = 1;
612 /* fallthrough */
585 case 'l': 613 case 'l':
586 show_local_fs = 1; 614 show_local_fs = 1;
587 break; 615 break;
616 case 'P':
617 display_inodes_perfdata = 1;
618 break;
588 case 'p': /* select path */ 619 case 'p': /* select path */
589 if (! (warn_freespace_units || crit_freespace_units || warn_freespace_percent || 620 if (! (warn_freespace_units || crit_freespace_units || warn_freespace_percent ||
590 crit_freespace_percent || warn_usedspace_units || crit_usedspace_units || 621 crit_freespace_percent || warn_usedspace_units || crit_usedspace_units ||
@@ -904,6 +935,8 @@ print_help (void)
904 printf (" %s\n", _("Display only devices/mountpoints with errors")); 935 printf (" %s\n", _("Display only devices/mountpoints with errors"));
905 printf (" %s\n", "-f, --freespace-ignore-reserved"); 936 printf (" %s\n", "-f, --freespace-ignore-reserved");
906 printf (" %s\n", _("Don't account root-reserved blocks into freespace in perfdata")); 937 printf (" %s\n", _("Don't account root-reserved blocks into freespace in perfdata"));
938 printf (" %s\n", "-P, --iperfdata");
939 printf (" %s\n", _("Display inode usage in perfdata"));
907 printf (" %s\n", "-g, --group=NAME"); 940 printf (" %s\n", "-g, --group=NAME");
908 printf (" %s\n", _("Group paths. Thresholds apply to (free-)space of all partitions together")); 941 printf (" %s\n", _("Group paths. Thresholds apply to (free-)space of all partitions together"));
909 printf (" %s\n", "-k, --kilobytes"); 942 printf (" %s\n", "-k, --kilobytes");
@@ -1012,6 +1045,8 @@ get_stats (struct parameter_list *p, struct fs_usage *fsp) {
1012 p->dtotal_units += p_list->dtotal_units; 1045 p->dtotal_units += p_list->dtotal_units;
1013 p->inodes_total += p_list->inodes_total; 1046 p->inodes_total += p_list->inodes_total;
1014 p->inodes_free += p_list->inodes_free; 1047 p->inodes_free += p_list->inodes_free;
1048 p->inodes_free_to_root += p_list->inodes_free_to_root;
1049 p->inodes_used += p_list->inodes_used;
1015 } 1050 }
1016 first = 0; 1051 first = 0;
1017 } 1052 }
@@ -1050,7 +1085,18 @@ get_path_stats (struct parameter_list *p, struct fs_usage *fsp) {
1050 p->dused_units = p->used*fsp->fsu_blocksize/mult; 1085 p->dused_units = p->used*fsp->fsu_blocksize/mult;
1051 p->dfree_units = p->available*fsp->fsu_blocksize/mult; 1086 p->dfree_units = p->available*fsp->fsu_blocksize/mult;
1052 p->dtotal_units = p->total*fsp->fsu_blocksize/mult; 1087 p->dtotal_units = p->total*fsp->fsu_blocksize/mult;
1053 p->inodes_total = fsp->fsu_files; /* Total file nodes. */ 1088 /* Free file nodes. Not sure the workaround is required, but in case...*/
1054 p->inodes_free = fsp->fsu_ffree; /* Free file nodes. */ 1089 p->inodes_free = fsp->fsu_favail > fsp->fsu_ffree ? 0 : fsp->fsu_favail;
1090 p->inodes_free_to_root = fsp->fsu_ffree; /* Free file nodes for root. */
1091 p->inodes_used = fsp->fsu_files - fsp->fsu_ffree;
1092 if (freespace_ignore_reserved) {
1093 /* option activated : we substract the root-reserved inodes from the total */
1094 /* not all OS report fsp->fsu_favail, only the ones with statvfs syscall */
1095 /* for others, fsp->fsu_ffree == fsp->fsu_favail */
1096 p->inodes_total = fsp->fsu_files - p->inodes_free_to_root + p->inodes_free;
1097 } else {
1098 /* default behaviour : take all the inodes into account */
1099 p->inodes_total = fsp->fsu_files;
1100 }
1055 np_add_name(&seen, p->best_match->me_mountdir); 1101 np_add_name(&seen, p->best_match->me_mountdir);
1056} 1102}
diff --git a/plugins/check_dns.c b/plugins/check_dns.c
index f2061636..0f2e6541 100644
--- a/plugins/check_dns.c
+++ b/plugins/check_dns.c
@@ -56,6 +56,7 @@ char **expected_address = NULL;
56int expected_address_cnt = 0; 56int expected_address_cnt = 0;
57 57
58int expect_authority = FALSE; 58int expect_authority = FALSE;
59int all_match = FALSE;
59thresholds *time_thresholds = NULL; 60thresholds *time_thresholds = NULL;
60 61
61static int 62static int
@@ -168,8 +169,8 @@ main (int argc, char **argv)
168 temp_buffer++; 169 temp_buffer++;
169 170
170 /* Strip leading spaces */ 171 /* Strip leading spaces */
171 for (; *temp_buffer != '\0' && *temp_buffer == ' '; temp_buffer++) 172 while (*temp_buffer == ' ')
172 /* NOOP */; 173 temp_buffer++;
173 174
174 strip(temp_buffer); 175 strip(temp_buffer);
175 if (temp_buffer==NULL || strlen(temp_buffer)==0) { 176 if (temp_buffer==NULL || strlen(temp_buffer)==0) {
@@ -201,7 +202,10 @@ main (int argc, char **argv)
201 if (error_scan (chld_err.line[i]) != STATE_OK) { 202 if (error_scan (chld_err.line[i]) != STATE_OK) {
202 result = max_state (result, error_scan (chld_err.line[i])); 203 result = max_state (result, error_scan (chld_err.line[i]));
203 msg = strchr(input_buffer, ':'); 204 msg = strchr(input_buffer, ':');
204 if(msg) msg++; 205 if(msg)
206 msg++;
207 else
208 msg = input_buffer;
205 } 209 }
206 } 210 }
207 211
@@ -228,16 +232,27 @@ main (int argc, char **argv)
228 if (result == STATE_OK && expected_address_cnt > 0) { 232 if (result == STATE_OK && expected_address_cnt > 0) {
229 result = STATE_CRITICAL; 233 result = STATE_CRITICAL;
230 temp_buffer = ""; 234 temp_buffer = "";
235 unsigned long expect_match = (1 << expected_address_cnt) - 1;
236 unsigned long addr_match = (1 << n_addresses) - 1;
231 237
232 for (i=0; i<expected_address_cnt; i++) { 238 for (i=0; i<expected_address_cnt; i++) {
239 int j;
233 /* check if we get a match on 'raw' ip or cidr */ 240 /* check if we get a match on 'raw' ip or cidr */
234 if ( strcmp(address, expected_address[i]) == 0 241 for (j=0; j<n_addresses; j++) {
235 || ip_match_cidr(address, expected_address[i]) ) 242 if ( strcmp(addresses[j], expected_address[i]) == 0
236 result = STATE_OK; 243 || ip_match_cidr(addresses[j], expected_address[i]) ) {
244 result = STATE_OK;
245 addr_match &= ~(1 << j);
246 expect_match &= ~(1 << i);
247 }
248 }
237 249
238 /* prepare an error string */ 250 /* prepare an error string */
239 xasprintf(&temp_buffer, "%s%s; ", temp_buffer, expected_address[i]); 251 xasprintf(&temp_buffer, "%s%s; ", temp_buffer, expected_address[i]);
240 } 252 }
253 /* check if expected_address must cover all in addresses and none may be missing */
254 if (all_match && (expect_match != 0 || addr_match != 0))
255 result = STATE_CRITICAL;
241 if (result == STATE_CRITICAL) { 256 if (result == STATE_CRITICAL) {
242 /* Strip off last semicolon... */ 257 /* Strip off last semicolon... */
243 temp_buffer[strlen(temp_buffer)-2] = '\0'; 258 temp_buffer[strlen(temp_buffer)-2] = '\0';
@@ -336,6 +351,8 @@ error_scan (char *input_buffer)
336 /* DNS server is not running... */ 351 /* DNS server is not running... */
337 else if (strstr (input_buffer, "No response from server")) 352 else if (strstr (input_buffer, "No response from server"))
338 die (STATE_CRITICAL, _("No response from DNS %s\n"), dns_server); 353 die (STATE_CRITICAL, _("No response from DNS %s\n"), dns_server);
354 else if (strstr (input_buffer, "no servers could be reached"))
355 die (STATE_CRITICAL, _("No response from DNS %s\n"), dns_server);
339 356
340 /* Host name is valid, but server doesn't have records... */ 357 /* Host name is valid, but server doesn't have records... */
341 else if (strstr (input_buffer, "No records")) 358 else if (strstr (input_buffer, "No records"))
@@ -401,6 +418,7 @@ process_arguments (int argc, char **argv)
401 {"reverse-server", required_argument, 0, 'r'}, 418 {"reverse-server", required_argument, 0, 'r'},
402 {"expected-address", required_argument, 0, 'a'}, 419 {"expected-address", required_argument, 0, 'a'},
403 {"expect-authority", no_argument, 0, 'A'}, 420 {"expect-authority", no_argument, 0, 'A'},
421 {"all", no_argument, 0, 'L'},
404 {"warning", required_argument, 0, 'w'}, 422 {"warning", required_argument, 0, 'w'},
405 {"critical", required_argument, 0, 'c'}, 423 {"critical", required_argument, 0, 'c'},
406 {0, 0, 0, 0} 424 {0, 0, 0, 0}
@@ -414,7 +432,7 @@ process_arguments (int argc, char **argv)
414 strcpy (argv[c], "-t"); 432 strcpy (argv[c], "-t");
415 433
416 while (1) { 434 while (1) {
417 c = getopt_long (argc, argv, "hVvAt:H:s:r:a:w:c:", long_opts, &opt_index); 435 c = getopt_long (argc, argv, "hVvALt:H:s:r:a:w:c:", long_opts, &opt_index);
418 436
419 if (c == -1 || c == EOF) 437 if (c == -1 || c == EOF)
420 break; 438 break;
@@ -455,13 +473,30 @@ process_arguments (int argc, char **argv)
455 case 'a': /* expected address */ 473 case 'a': /* expected address */
456 if (strlen (optarg) >= ADDRESS_LENGTH) 474 if (strlen (optarg) >= ADDRESS_LENGTH)
457 die (STATE_UNKNOWN, _("Input buffer overflow\n")); 475 die (STATE_UNKNOWN, _("Input buffer overflow\n"));
458 expected_address = (char **)realloc(expected_address, (expected_address_cnt+1) * sizeof(char**)); 476 if (strchr(optarg, ',') != NULL) {
459 expected_address[expected_address_cnt] = strdup(optarg); 477 char *comma = strchr(optarg, ',');
460 expected_address_cnt++; 478 while (comma != NULL) {
479 expected_address = (char **)realloc(expected_address, (expected_address_cnt+1) * sizeof(char**));
480 expected_address[expected_address_cnt] = strndup(optarg, comma - optarg);
481 expected_address_cnt++;
482 optarg = comma + 1;
483 comma = strchr(optarg, ',');
484 }
485 expected_address = (char **)realloc(expected_address, (expected_address_cnt+1) * sizeof(char**));
486 expected_address[expected_address_cnt] = strdup(optarg);
487 expected_address_cnt++;
488 } else {
489 expected_address = (char **)realloc(expected_address, (expected_address_cnt+1) * sizeof(char**));
490 expected_address[expected_address_cnt] = strdup(optarg);
491 expected_address_cnt++;
492 }
461 break; 493 break;
462 case 'A': /* expect authority */ 494 case 'A': /* expect authority */
463 expect_authority = TRUE; 495 expect_authority = TRUE;
464 break; 496 break;
497 case 'L': /* all must match */
498 all_match = TRUE;
499 break;
465 case 'w': 500 case 'w':
466 warning = optarg; 501 warning = optarg;
467 break; 502 break;
@@ -530,14 +565,16 @@ print_help (void)
530 printf (" -a, --expected-address=IP-ADDRESS|CIDR|HOST\n"); 565 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")); 566 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")); 567 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")); 568 printf (" %s\n", _("value matches)."));
534 printf (" %s\n", _("the whole string of addresses separated with commas (sorted alphabetically)."));
535 printf (" -A, --expect-authority\n"); 569 printf (" -A, --expect-authority\n");
536 printf (" %s\n", _("Optionally expect the DNS server to be authoritative for the lookup")); 570 printf (" %s\n", _("Optionally expect the DNS server to be authoritative for the lookup"));
537 printf (" -w, --warning=seconds\n"); 571 printf (" -w, --warning=seconds\n");
538 printf (" %s\n", _("Return warning if elapsed time exceeds value. Default off")); 572 printf (" %s\n", _("Return warning if elapsed time exceeds value. Default off"));
539 printf (" -c, --critical=seconds\n"); 573 printf (" -c, --critical=seconds\n");
540 printf (" %s\n", _("Return critical if elapsed time exceeds value. Default off")); 574 printf (" %s\n", _("Return critical if elapsed time exceeds value. Default off"));
575 printf (" -L, --all\n");
576 printf (" %s\n", _("Return critical if the list of expected addresses does not match all addresses"));
577 printf (" %s\n", _("returned. Default off"));
541 578
542 printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT); 579 printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT);
543 580
@@ -549,5 +586,5 @@ void
549print_usage (void) 586print_usage (void)
550{ 587{
551 printf ("%s\n", _("Usage:")); 588 printf ("%s\n", _("Usage:"));
552 printf ("%s -H host [-s server] [-a expected-address] [-A] [-t timeout] [-w warn] [-c crit]\n", progname); 589 printf ("%s -H host [-s server] [-a expected-address] [-A] [-t timeout] [-w warn] [-c crit] [-L]\n", progname);
553} 590}
diff --git a/plugins/check_hpjd.c b/plugins/check_hpjd.c
index f159f5a2..65465567 100644
--- a/plugins/check_hpjd.c
+++ b/plugins/check_hpjd.c
@@ -67,6 +67,7 @@ void print_usage (void);
67char *community = NULL; 67char *community = NULL;
68char *address = NULL; 68char *address = NULL;
69char *port = NULL; 69char *port = NULL;
70int check_paper_out = 1;
70 71
71int 72int
72main (int argc, char **argv) 73main (int argc, char **argv)
@@ -240,7 +241,8 @@ main (int argc, char **argv)
240 strcpy (errmsg, _("Paper Jam")); 241 strcpy (errmsg, _("Paper Jam"));
241 } 242 }
242 else if (paper_out) { 243 else if (paper_out) {
243 result = STATE_WARNING; 244 if (check_paper_out)
245 result = STATE_WARNING;
244 strcpy (errmsg, _("Out of Paper")); 246 strcpy (errmsg, _("Out of Paper"));
245 } 247 }
246 else if (line_status == OFFLINE) { 248 else if (line_status == OFFLINE) {
@@ -325,7 +327,7 @@ process_arguments (int argc, char **argv)
325 327
326 328
327 while (1) { 329 while (1) {
328 c = getopt_long (argc, argv, "+hVH:C:p:", longopts, &option); 330 c = getopt_long (argc, argv, "+hVH:C:p:D", longopts, &option);
329 331
330 if (c == -1 || c == EOF || c == 1) 332 if (c == -1 || c == EOF || c == 1)
331 break; 333 break;
@@ -347,6 +349,8 @@ process_arguments (int argc, char **argv)
347 usage2 (_("Port must be a positive short integer"), optarg); 349 usage2 (_("Port must be a positive short integer"), optarg);
348 else 350 else
349 port = atoi(optarg); 351 port = atoi(optarg);
352 case 'D': /* disable paper out check*/
353 check_paper_out = 0;
350 break; 354 break;
351 case 'V': /* version */ 355 case 'V': /* version */
352 print_revision (progname, NP_VERSION); 356 print_revision (progname, NP_VERSION);
@@ -420,6 +424,8 @@ print_help (void)
420 printf (" %s", _("Specify the port to check ")); 424 printf (" %s", _("Specify the port to check "));
421 printf (_("(default=%s)"), DEFAULT_PORT); 425 printf (_("(default=%s)"), DEFAULT_PORT);
422 printf ("\n"); 426 printf ("\n");
427 printf (" %s\n", "-D");
428 printf (" %s", _("Disable paper check "));
423 429
424 printf (UT_SUPPORT); 430 printf (UT_SUPPORT);
425} 431}
@@ -430,5 +436,5 @@ void
430print_usage (void) 436print_usage (void)
431{ 437{
432 printf ("%s\n", _("Usage:")); 438 printf ("%s\n", _("Usage:"));
433 printf ("%s -H host [-C community] [-p port]\n", progname); 439 printf ("%s -H host [-C community] [-p port] [-D]\n", progname);
434} 440}
diff --git a/plugins/check_http.c b/plugins/check_http.c
index d540bf7d..0b712665 100644
--- a/plugins/check_http.c
+++ b/plugins/check_http.c
@@ -72,7 +72,7 @@ int maximum_age = -1;
72 72
73enum { 73enum {
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"
78regex_t preg; 78regex_t preg;
@@ -120,12 +120,14 @@ int use_ssl = FALSE;
120int use_sni = FALSE; 120int use_sni = FALSE;
121int verbose = FALSE; 121int verbose = FALSE;
122int show_extended_perfdata = FALSE; 122int show_extended_perfdata = FALSE;
123int show_body = FALSE;
123int sd; 124int sd;
124int min_page_len = 0; 125int min_page_len = 0;
125int max_page_len = 0; 126int max_page_len = 0;
126int redir_depth = 0; 127int redir_depth = 0;
127int max_depth = 15; 128int max_depth = 15;
128char *http_method; 129char *http_method;
130char *http_method_proxy;
129char *http_post_data; 131char *http_post_data;
130char *http_content_type; 132char *http_content_type;
131char buffer[MAX_INPUT_BUFFER]; 133char 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);
@@ -1585,7 +1620,7 @@ print_help (void)
1585 printf (" %s\n", _("URL to GET or POST (default: /)")); 1620 printf (" %s\n", _("URL to GET or POST (default: /)"));
1586 printf (" %s\n", "-P, --post=STRING"); 1621 printf (" %s\n", "-P, --post=STRING");
1587 printf (" %s\n", _("URL encoded http POST data")); 1622 printf (" %s\n", _("URL encoded http POST data"));
1588 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)");
1589 printf (" %s\n", _("Set HTTP method.")); 1624 printf (" %s\n", _("Set HTTP method."));
1590 printf (" %s\n", "-N, --no-body"); 1625 printf (" %s\n", "-N, --no-body");
1591 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."));
@@ -1615,6 +1650,8 @@ print_help (void)
1615 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"));
1616 printf (" %s\n", "-E, --extended-perfdata"); 1651 printf (" %s\n", "-E, --extended-perfdata");
1617 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"));
1618 printf (" %s\n", "-L, --link"); 1655 printf (" %s\n", "-L, --link");
1619 printf (" %s\n", _("Wrap output in HTML link (obsoleted by urlize)")); 1656 printf (" %s\n", _("Wrap output in HTML link (obsoleted by urlize)"));
1620 printf (" %s\n", "-f, --onredirect=<ok|warning|critical|follow|sticky|stickyport>"); 1657 printf (" %s\n", "-f, --onredirect=<ok|warning|critical|follow|sticky|stickyport>");
@@ -1672,7 +1709,8 @@ print_help (void)
1672 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>"));
1673 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"));
1674 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,"));
1675 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"));
1676 1714
1677#endif 1715#endif
1678 1716
diff --git a/plugins/check_load.c b/plugins/check_load.c
index b1cc498f..bf7b94b4 100644
--- a/plugins/check_load.c
+++ b/plugins/check_load.c
@@ -33,6 +33,7 @@ const char *copyright = "1999-2007";
33const char *email = "devel@monitoring-plugins.org"; 33const 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);
52static int validate_arguments (void); 53static int validate_arguments (void);
53void print_help (void); 54void print_help (void);
54void print_usage (void); 55void print_usage (void);
56static int print_top_consuming_processes();
57
58static int n_procs_to_show = 0;
55 59
56/* strictly for pretty-print usage in loops */ 60/* strictly for pretty-print usage in loops */
57static const int nums[3] = { 1, 5, 15 }; 61static const int nums[3] = { 1, 5, 15 };
@@ -210,6 +214,9 @@ main (int argc, char **argv)
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
332print_usage (void) 346print_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
353int 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
373static 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_procs.c b/plugins/check_procs.c
index 4bcc56bc..f7917c34 100644
--- a/plugins/check_procs.c
+++ b/plugins/check_procs.c
@@ -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..d37c57c8 100644
--- a/plugins/check_smtp.c
+++ b/plugins/check_smtp.c
@@ -293,6 +293,7 @@ main (int argc, char **argv)
293 printf("%s", buffer); 293 printf("%s", buffer);
294 } 294 }
295 295
296 n = 0;
296 while (n < ncommands) { 297 while (n < ncommands) {
297 xasprintf (&cmd_str, "%s%s", commands[n], "\r\n"); 298 xasprintf (&cmd_str, "%s%s", commands[n], "\r\n");
298 my_send(cmd_str, strlen(cmd_str)); 299 my_send(cmd_str, strlen(cmd_str));
diff --git a/plugins/check_snmp.c b/plugins/check_snmp.c
index da9638c4..afc568b2 100644
--- a/plugins/check_snmp.c
+++ b/plugins/check_snmp.c
@@ -576,6 +576,9 @@ main (int argc, char **argv)
576 len = sizeof(perfstr)-strlen(perfstr)-1; 576 len = sizeof(perfstr)-strlen(perfstr)-1;
577 strncat(perfstr, show, len>ptr-show ? ptr-show : len); 577 strncat(perfstr, show, len>ptr-show ? ptr-show : len);
578 578
579 if (type)
580 strncat(perfstr, type, sizeof(perfstr)-strlen(perfstr)-1);
581
579 if (warning_thresholds) { 582 if (warning_thresholds) {
580 strncat(perfstr, ";", sizeof(perfstr)-strlen(perfstr)-1); 583 strncat(perfstr, ";", sizeof(perfstr)-strlen(perfstr)-1);
581 strncat(perfstr, warning_thresholds, sizeof(perfstr)-strlen(perfstr)-1); 584 strncat(perfstr, warning_thresholds, sizeof(perfstr)-strlen(perfstr)-1);
@@ -588,8 +591,6 @@ main (int argc, char **argv)
588 strncat(perfstr, critical_thresholds, sizeof(perfstr)-strlen(perfstr)-1); 591 strncat(perfstr, critical_thresholds, sizeof(perfstr)-strlen(perfstr)-1);
589 } 592 }
590 593
591 if (type)
592 strncat(perfstr, type, sizeof(perfstr)-strlen(perfstr)-1);
593 strncat(perfstr, " ", sizeof(perfstr)-strlen(perfstr)-1); 594 strncat(perfstr, " ", sizeof(perfstr)-strlen(perfstr)-1);
594 } 595 }
595 } 596 }
@@ -1207,8 +1208,9 @@ print_help (void)
1207 printf (" %s\n", _("Separates output on multiple OID requests")); 1208 printf (" %s\n", _("Separates output on multiple OID requests"));
1208 1209
1209 printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT); 1210 printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT);
1211 printf (" %s\n", _("NOTE the final timeout value is calculated using this formula: timeout_interval * retries + 5"));
1210 printf (" %s\n", "-e, --retries=INTEGER"); 1212 printf (" %s\n", "-e, --retries=INTEGER");
1211 printf (" %s\n", _("Number of retries to be used in the requests")); 1213 printf (" %s%i\n", _("Number of retries to be used in the requests, default: "), DEFAULT_RETRIES);
1212 1214
1213 printf (" %s\n", "-O, --perf-oids"); 1215 printf (" %s\n", "-O, --perf-oids");
1214 printf (" %s\n", _("Label performance data with OIDs instead of --label's")); 1216 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..0ff0c770 100644
--- a/plugins/check_swap.c
+++ b/plugins/check_swap.c
@@ -51,7 +51,7 @@ const char *email = "devel@monitoring-plugins.org";
51# define SWAP_CONVERSION 1 51# define SWAP_CONVERSION 1
52#endif 52#endif
53 53
54int check_swap (int usp, float free_swap_mb); 54int check_swap (int usp, float free_swap_mb, float total_swap_mb);
55int process_arguments (int argc, char **argv); 55int process_arguments (int argc, char **argv);
56int validate_arguments (void); 56int validate_arguments (void);
57void print_usage (void); 57void print_usage (void);
@@ -128,7 +128,7 @@ main (int argc, char **argv)
128 percent=100.0; 128 percent=100.0;
129 else 129 else
130 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); 130 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
131 result = max_state (result, check_swap (percent, dskfree_mb)); 131 result = max_state (result, check_swap (percent, dskfree_mb, dsktotal_mb));
132 if (verbose) 132 if (verbose)
133 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); 133 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
134 } 134 }
@@ -227,7 +227,7 @@ main (int argc, char **argv)
227 free_swap_mb += dskfree_mb; 227 free_swap_mb += dskfree_mb;
228 if (allswaps) { 228 if (allswaps) {
229 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); 229 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
230 result = max_state (result, check_swap (percent, dskfree_mb)); 230 result = max_state (result, check_swap (percent, dskfree_mb, dsktotal_mb));
231 if (verbose) 231 if (verbose)
232 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); 232 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
233 } 233 }
@@ -289,7 +289,7 @@ main (int argc, char **argv)
289 289
290 if(allswaps && dsktotal_mb > 0){ 290 if(allswaps && dsktotal_mb > 0){
291 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); 291 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
292 result = max_state (result, check_swap (percent, dskfree_mb)); 292 result = max_state (result, check_swap (percent, dskfree_mb, dsktotal_mb));
293 if (verbose) { 293 if (verbose) {
294 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); 294 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
295 } 295 }
@@ -328,7 +328,7 @@ main (int argc, char **argv)
328 328
329 if(allswaps && dsktotal_mb > 0){ 329 if(allswaps && dsktotal_mb > 0){
330 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); 330 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
331 result = max_state (result, check_swap (percent, dskfree_mb)); 331 result = max_state (result, check_swap (percent, dskfree_mb, dsktotal_mb));
332 if (verbose) { 332 if (verbose) {
333 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); 333 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
334 } 334 }
@@ -355,7 +355,7 @@ main (int argc, char **argv)
355 status = "- Swap is either disabled, not present, or of zero size. "; 355 status = "- Swap is either disabled, not present, or of zero size. ";
356 } 356 }
357 357
358 result = max_state (result, check_swap (percent_used, free_swap_mb)); 358 result = max_state (result, check_swap (percent_used, free_swap_mb, total_swap_mb));
359 printf (_("SWAP %s - %d%% free (%d MB out of %d MB) %s|"), 359 printf (_("SWAP %s - %d%% free (%d MB out of %d MB) %s|"),
360 state_text (result), 360 state_text (result),
361 (100 - percent_used), (int) free_swap_mb, (int) total_swap_mb, status); 361 (100 - percent_used), (int) free_swap_mb, (int) total_swap_mb, status);
@@ -372,10 +372,10 @@ main (int argc, char **argv)
372 372
373 373
374int 374int
375check_swap (int usp, float free_swap_mb) 375check_swap (int usp, float free_swap_mb, float total_swap_mb)
376{ 376{
377 377
378 if (!free_swap_mb) return no_swap_state; 378 if (!total_swap_mb) return no_swap_state;
379 379
380 int result = STATE_UNKNOWN; 380 int result = STATE_UNKNOWN;
381 float 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 */
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];
86static int expect_mismatch_state = STATE_WARNING; 86static int expect_mismatch_state = STATE_WARNING;
87static int match_flags = NP_MATCH_EXACT; 87static int match_flags = NP_MATCH_EXACT;
88 88
89#ifdef HAVE_SSL
90static char *sni = NULL;
91static 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/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
177enum { 182enum {
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
235static 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/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 @@
1noinst_LIBRARIES = libpicohttpparser.a
2
3libpicohttpparser_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
96static 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
105static 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
134static 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 }
180FOUND_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
197static 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 */
245static 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
263static 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
341static 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
383int 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
411static 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
454int 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
480int 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
501enum {
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
510static 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
523ssize_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
629Complete:
630 ret = bufsz - src;
631Exit:
632 if (dst != src)
633 memmove(buf + dst, buf + src, bufsz - src);
634 *_bufsz = dst;
635 return ret;
636}
637
638int 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
37extern "C" {
38#endif
39
40/* contains name and value of a header (name == NULL if is a continuing line
41 * of a multiline header */
42struct 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 */
51int 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 */
55int 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 */
59int 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 */
62struct 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 */
78ssize_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 */
81int 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 */
44extern int timeout_interval;
45extern pid_t *childpid; 45extern pid_t *childpid;
46extern int *child_stderr_array; 46extern int *child_stderr_array;
47extern FILE *child_process; 47extern 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))
81int open_max (void); /* {Prog openmax} */
82static void err_sys (const char *, ...) __attribute__((noreturn,format(printf, 1, 2)));
83char *rtrim (char *, const char *);
84 79
85char *pname = NULL; /* caller can set this from argv[0] */ 80char *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 */
89static int maxfd; /* from our open_max(), {Prog openmax} */
90
91#ifdef REDHAT_SPOPEN_ERROR 82#ifdef REDHAT_SPOPEN_ERROR
92static volatile int childtermd = 0; 83static 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
277static int openmax = OPEN_MAX;
278#else
279static 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
286RETSIGTYPE 269RETSIGTYPE
287popen_sigchld_handler (int signo) 270popen_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
314int
315open_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
334static void
335err_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
357char *
358rtrim (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 *);
7int spclose (FILE *); 7int spclose (FILE *);
8RETSIGTYPE popen_timeout_alarm_handler (int); 8RETSIGTYPE popen_timeout_alarm_handler (int);
9 9
10extern unsigned int timeout_interval;
11pid_t *childpid=NULL; 10pid_t *childpid=NULL;
12int *child_stderr_array=NULL; 11int *child_stderr_array=NULL;
13FILE *child_process=NULL; 12FILE *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. */
68static pid_t *np_pids = NULL; 68static 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
75static 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 **/
84static int np_runcmd_open(const char *, int *, int *) 71static 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 */
100void np_runcmd_init(void) 87void 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
194int np_net_ssl_check_cert(int days_till_exp_warn, int days_till_exp_crit){ 194int 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
205int 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
index e9705f3b..9b9f8059 100644
--- a/plugins/t/NPTest.cache.travis
+++ b/plugins/t/NPTest.cache.travis
@@ -1,62 +1,54 @@
1{ 1{
2 'MYSQL_LOGIN_DETAILS' => '-u root -d test',
3 'NP_ALLOW_SUDO' => 'yes', 2 'NP_ALLOW_SUDO' => 'yes',
4 'NP_DNS_SERVER' => '8.8.8.8', 3 'NP_DNS_SERVER' => '8.8.8.8',
5 'NP_GOOD_NTP_SERVICE' => '', 4 'NP_GOOD_NTP_SERVICE' => '',
5 'NP_HOST_DHCP_RESPONSIVE' => '',
6 'NP_HOST_HPJD_PORT_INVALID' => '161',
7 'NP_HOST_HPJD_PORT_VALID' => '',
8 'NP_HOSTNAME_INVALID_CIDR' => '130.133.8.39/30',
6 'NP_HOSTNAME_INVALID' => 'nosuchhost', 9 '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_VALID_CIDR' => '130.133.8.41/30',
10 'NP_HOSTNAME_INVALID_CIDR' => '130.133.8.39/30', 11 'NP_HOSTNAME_VALID_IP' => '130.133.8.40',
12 'NP_HOSTNAME_VALID' => 'monitoring-plugins.org',
11 'NP_HOSTNAME_VALID_REVERSE' => 'orwell.monitoring-plugins.org.', 13 'NP_HOSTNAME_VALID_REVERSE' => 'orwell.monitoring-plugins.org.',
12 'NP_HOST_DHCP_RESPONSIVE' => '',
13 'NP_HOST_NONRESPONSIVE' => '10.0.0.1', 14 'NP_HOST_NONRESPONSIVE' => '10.0.0.1',
14 'NP_HOST_RESPONSIVE' => 'localhost', 15 'NP_HOST_RESPONSIVE' => 'localhost',
15 'NP_HOST_SMB' => '', 16 'NP_HOST_SMB' => '',
16 'NP_HOST_SNMP' => 'localhost', 17 'NP_HOST_SNMP' => '',
17 'NP_HOST_TCP_FTP' => '', 18 'NP_HOST_TCP_FTP' => '',
18 'NP_HOST_TCP_HPJD' => '', 19 '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', 20 'NP_HOST_TCP_HTTP2' => 'test.monitoring-plugins.org',
21 'NP_HOST_TCP_HTTP' => 'localhost',
23 'NP_HOST_TCP_IMAP' => 'imap.web.de', 22 'NP_HOST_TCP_IMAP' => 'imap.web.de',
23 'NP_HOST_TCP_JABBER' => 'jabber.org',
24 'NP_HOST_TCP_LDAP' => 'localhost', 24 'NP_HOST_TCP_LDAP' => 'localhost',
25 'NP_HOST_TCP_POP' => 'pop.web.de', 25 'NP_HOST_TCP_POP' => 'pop.web.de',
26 'NP_HOST_TCP_PROXY' => 'localhost',
26 'NP_HOST_TCP_SMTP' => 'localhost', 27 'NP_HOST_TCP_SMTP' => 'localhost',
27 'NP_HOST_TCP_SMTP_NOTLS' => '', 28 'NP_HOST_TCP_SMTP_NOTLS' => '',
28 'NP_HOST_TCP_SMTP_TLS' => '', 29 'NP_HOST_TCP_SMTP_TLS' => '',
30 'NP_HOST_TLS_CERT' => 'localhost,
31 'NP_HOST_TLS_HTTP' => 'localhost',
32 'NP_HOST_UDP_TIME' => 'none',
29 'NP_INTERNET_ACCESS' => 'yes', 33 'NP_INTERNET_ACCESS' => 'yes',
30 'NP_LDAP_BASE_DN' => 'cn=admin,dc=nodomain', 34 'NP_LDAP_BASE_DN' => 'cn=admin,dc=nodomain',
31 'NP_MOUNTPOINT2_VALID' => '/media/ramdisk', 35 'NP_MOUNTPOINT2_VALID' => '/media/ramdisk',
32 'NP_MOUNTPOINT_VALID' => '/', 36 'NP_MOUNTPOINT_VALID' => '/',
37 'NP_MYSQL_LOGIN_DETAILS' => '-u root -d test',
33 'NP_MYSQL_SERVER' => 'localhost', 38 'NP_MYSQL_SERVER' => 'localhost',
34 'NP_HOST_UDP_TIME' => 'localhost',
35 'NP_MYSQL_SOCKET' => '/var/run/mysqld/mysqld.sock', 39 'NP_MYSQL_SOCKET' => '/var/run/mysqld/mysqld.sock',
36 'NP_MYSQL_WITH_SLAVE' => '', 40 'NP_MYSQL_WITH_SLAVE' => '',
37 'NP_MYSQL_WITH_SLAVE_LOGIN' => '', 41 'NP_MYSQL_WITH_SLAVE_LOGIN' => '',
38 'NP_NO_NTP_SERVICE' => 'localhost', 42 'NP_NO_NTP_SERVICE' => 'localhost',
43 'NP_PORT_TCP_PROXY' => '3128',
39 'NP_SMB_SHARE' => '', 44 'NP_SMB_SHARE' => '',
40 'NP_SMB_SHARE_DENY' => '', 45 'NP_SMB_SHARE_DENY' => '',
41 'NP_SMB_SHARE_SPC' => '', 46 'NP_SMB_SHARE_SPC' => '',
42 'NP_SMB_VALID_USER' => '', 47 'NP_SMB_VALID_USER' => '',
43 'NP_SMB_VALID_USER_PASS' => '', 48 'NP_SMB_VALID_USER_PASS' => '',
44 'NP_SNMP_COMMUNITY' => 'public', 49 'NP_SNMP_COMMUNITY' => '',
50 'NP_SNMP_USER' => '',
45 'NP_SSH_CONFIGFILE' => '~/.ssh/config', 51 'NP_SSH_CONFIGFILE' => '~/.ssh/config',
46 'NP_SSH_HOST' => 'localhost', 52 'NP_SSH_HOST' => 'localhost',
47 'NP_SSH_IDENTITY' => '~/.ssh/id_dsa', 53 'NP_SSH_IDENTITY' => '~/.ssh/id_rsa'
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} 54}
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;
9use NPTest; 9use NPTest;
10 10
11# Required parameters 11# Required parameters
12my $ssh_service = getTestParameter( "NP_SSH_HOST", 12my $ssh_service = getTestParameter("NP_SSH_HOST", "A host providing SSH service", "localhost");
13 "A host providing SSH service", 13my $ssh_key = getTestParameter("NP_SSH_IDENTITY", "A key allowing access to NP_SSH_HOST", "~/.ssh/id_dsa");
14 "localhost"); 14my $ssh_conf = getTestParameter( "NP_SSH_CONFIGFILE", "A config file with ssh settings", "~/.ssh/config");
15
16my $ssh_key = getTestParameter( "NP_SSH_IDENTITY",
17 "A key allowing access to NP_SSH_HOST",
18 "~/.ssh/id_dsa");
19
20my $ssh_conf = getTestParameter( "NP_SSH_CONFIGFILE",
21 "A config file with ssh settings",
22 "~/.ssh/config");
23 15
24 16
25plan skip_all => "SSH_HOST and SSH_IDENTITY must be defined" unless ($ssh_service && $ssh_key); 17plan 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..cc65f037
--- /dev/null
+++ b/plugins/t/check_curl.t
@@ -0,0 +1,199 @@
1#! /usr/bin/perl -w -I ..
2#
3# HyperText Transfer Protocol (HTTP) Test via check_http
4#
5#
6
7use strict;
8use Test::More;
9use POSIX qw/mktime strftime/;
10use NPTest;
11
12plan tests => 57;
13
14my $successOutput = '/OK.*HTTP.*second/';
15
16my $res;
17my $plugin = 'check_http';
18$plugin = 'check_curl' if $0 =~ m/check_curl/mx;
19
20my $host_tcp_http = getTestParameter("NP_HOST_TCP_HTTP", "A host providing the HTTP Service (a web server)", "localhost");
21my $host_tls_http = getTestParameter("NP_HOST_TLS_HTTP", "A host providing the HTTPS Service (a tls web server)", "localhost");
22my $host_tls_cert = getTestParameter("NP_HOST_TLS_CERT", "the common name of the certificate.", "localhost");
23my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
24my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
25my $internet_access = getTestParameter("NP_INTERNET_ACCESS", "Is this system directly connected to the internet?", "yes");
26my $host_tcp_http2 = getTestParameter("NP_HOST_TCP_HTTP2", "A host providing an index page containing the string 'monitoring'", "test.monitoring-plugins.org");
27my $host_tcp_proxy = getTestParameter("NP_HOST_TCP_PROXY", "A host providing a HTTP proxy with CONNECT support", "localhost");
28my $port_tcp_proxy = getTestParameter("NP_PORT_TCP_PROXY", "Port of the proxy with HTTP and CONNECT support", "3128");
29
30my $faketime = -x '/usr/bin/faketime' ? 1 : 0;
31
32
33$res = NPTest->testCmd(
34 "./$plugin $host_tcp_http -wt 300 -ct 600"
35 );
36cmp_ok( $res->return_code, '==', 0, "Webserver $host_tcp_http responded" );
37like( $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 );
42like( $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 );
47cmp_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?!)
49like( $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 );
54cmp_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'
59like( $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");
63like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" );
64like( $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");
67like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" );
68like( $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");
71like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" );
72like( $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");
75like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" );
76like( $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'");
79like( $res->output, '/^Host: testhost:8001\s*$/ms', "Host Header OK" );
80like( $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'");
83like( $res->output, '/^Host: testhost:8001\s*$/ms', "Host Header OK" );
84like( $res->output, '/CURLOPT_URL: http:\/\/'.$host_tcp_http.':80\//ms', "Url OK" );
85
86SKIP: {
87 skip "No internet access", 3 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
99SKIP: {
100 skip "No host serving monitoring in index file", 7 unless $host_tcp_http2;
101
102 $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'monitoring'" );
103 cmp_ok( $res->return_code, "==", 0, "Got a reference to 'monitoring'");
104
105 $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'mONiTORing'" );
106 cmp_ok( $res->return_code, "==", 2, "Not got 'mONiTORing'");
107 like ( $res->output, "/pattern not found/", "Error message says 'pattern not found'");
108
109 $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -R 'mONiTORing'" );
110 cmp_ok( $res->return_code, "==", 0, "But case insensitive doesn't mind 'mONiTORing'");
111
112 $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'monitoring' --invert-regex" );
113 cmp_ok( $res->return_code, "==", 2, "Invert results work when found");
114 like ( $res->output, "/pattern found/", "Error message says 'pattern found'");
115
116 $res = NPTest->testCmd( "./$plugin -H $host_tcp_http2 -r 'mONiTORing' --invert-regex" );
117 cmp_ok( $res->return_code, "==", 0, "And also when not found");
118}
119SKIP: {
120 skip "No internet access", 16 if $internet_access eq "no";
121
122 $res = NPTest->testCmd(
123 "./$plugin --ssl $host_tls_http"
124 );
125 cmp_ok( $res->return_code, '==', 0, "Can read https for $host_tls_http" );
126
127 $res = NPTest->testCmd( "./$plugin -C 1 --ssl $host_tls_http" );
128 cmp_ok( $res->return_code, '==', 0, "Checking certificate for $host_tls_http");
129 like ( $res->output, "/Certificate '$host_tls_cert' will expire on/", "Output OK" );
130 my $saved_cert_output = $res->output;
131
132 $res = NPTest->testCmd( "./$plugin -C 8000,1 --ssl $host_tls_http" );
133 cmp_ok( $res->return_code, '==', 1, "Checking certificate for $host_tls_http");
134 like ( $res->output, qr/WARNING - Certificate '$host_tls_cert' expires in \d+ day/, "Output Warning" );
135
136 $res = NPTest->testCmd( "./$plugin $host_tls_http -C 1" );
137 is( $res->return_code, 0, "Old syntax for cert checking okay" );
138 is( $res->output, $saved_cert_output, "Same output as new syntax" );
139
140 $res = NPTest->testCmd( "./$plugin -H $host_tls_http -C 1" );
141 is( $res->return_code, 0, "Updated syntax for cert checking okay" );
142 is( $res->output, $saved_cert_output, "Same output as new syntax" );
143
144 $res = NPTest->testCmd( "./$plugin -C 1 $host_tls_http" );
145 cmp_ok( $res->output, 'eq', $saved_cert_output, "--ssl option automatically added");
146
147 $res = NPTest->testCmd( "./$plugin $host_tls_http -C 1" );
148 cmp_ok( $res->output, 'eq', $saved_cert_output, "Old syntax for cert checking still works");
149
150 # run some certificate checks with faketime
151 SKIP: {
152 skip "No faketime binary found", 12 if !$faketime;
153 $res = NPTest->testCmd("LC_TIME=C TZ=UTC ./$plugin -C 1 $host_tls_http");
154 like($res->output, qr/OK - Certificate '$host_tls_cert' will expire on/, "Catch cert output");
155 is( $res->return_code, 0, "Catch cert output exit code" );
156 my($mon,$day,$hour,$min,$sec,$year) = ($res->output =~ /(\w+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+(\d+)/);
157 if(!defined $year) {
158 die("parsing date failed from: ".$res->output);
159 }
160 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};
161 my $ts = mktime($sec, $min, $hour, $day, $months->{$mon}, $year-1900);
162 my $time = strftime("%Y-%m-%d %H:%M:%S", localtime($ts));
163 $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");
164 like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' just expired/, "Output on expire date");
165 is( $res->return_code, 2, "Output on expire date" );
166
167 $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");
168 like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 0 minutes/, "cert expires in 1 second output");
169 is( $res->return_code, 2, "cert expires in 1 second exit code" );
170
171 $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");
172 like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 minutes/, "cert expires in 2 minutes output");
173 is( $res->return_code, 2, "cert expires in 2 minutes exit code" );
174
175 $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");
176 like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expires in 2 hours/, "cert expires in 2 hours output");
177 is( $res->return_code, 2, "cert expires in 2 hours exit code" );
178
179 $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");
180 like($res->output, qr/CRITICAL - Certificate '$host_tls_cert' expired on/, "Certificate expired output");
181 is( $res->return_code, 2, "Certificate expired exit code" );
182 };
183
184 $res = NPTest->testCmd( "./$plugin --ssl $host_tls_http -E" );
185 like ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' );
186 like ( $res->output, '/time_ssl=[\d\.]+/', 'Extended Performance Data SSL Output OK' );
187
188 $res = NPTest->testCmd(
189 "./$plugin --ssl -H www.e-paycobalt.com"
190 );
191 cmp_ok( $res->return_code, "==", 0, "Can read https for www.e-paycobalt.com (uses AES certificate)" );
192
193
194 $res = NPTest->testCmd( "./$plugin -H www.mozilla.com -u /firefox -f follow" );
195 is( $res->return_code, 0, "Redirection based on location is okay");
196
197 $res = NPTest->testCmd( "./$plugin -H www.mozilla.com --extended-perfdata" );
198 like ( $res->output, '/time_connect=[\d\.]+/', 'Extended Performance Data Output OK' );
199}
diff --git a/plugins/t/check_fping.t b/plugins/t/check_fping.t
index 08692e46..342b0a7e 100644
--- a/plugins/t/check_fping.t
+++ b/plugins/t/check_fping.t
@@ -15,15 +15,9 @@ BEGIN {$tests = 4; plan tests => $tests}
15my $successOutput = '/^FPING OK - /'; 15my $successOutput = '/^FPING OK - /';
16my $failureOutput = '/^FPING CRITICAL - /'; 16my $failureOutput = '/^FPING CRITICAL - /';
17 17
18my $host_responsive = getTestParameter( "host_responsive", "NP_HOST_RESPONSIVE", "localhost", 18my $host_responsive = getTestParameter("NP_HOST_RESPONSIVE", "The hostname of system responsive to network requests", "localhost");
19 "The hostname of system responsive to network requests" ); 19my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
20 20my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
21my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1",
22 "The hostname of system not responsive to network requests" );
23
24my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost",
25 "An invalid (not known to DNS) hostname" );
26
27 21
28my $t; 22my $t;
29 23
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;
11use vars qw($tests); 11use vars qw($tests);
12BEGIN {$tests = 4; plan tests => $tests} 12BEGIN {$tests = 4; plan tests => $tests}
13 13
14my $host_tcp_ftp = getTestParameter( "host_tcp_ftp", "NP_HOST_TCP_FTP", "localhost", 14my $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)"); 15my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
16 16my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
17my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1",
18 "The hostname of system not responsive to network requests" );
19
20my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost",
21 "An invalid (not known to DNS) hostname" );
22 17
23my $successOutput = '/FTP OK -\s+[0-9]?\.?[0-9]+ second response time/'; 18my $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..e92681e9 100644
--- a/plugins/t/check_http.t
+++ b/plugins/t/check_http.t
@@ -9,61 +9,46 @@ use Test::More;
9use POSIX qw/mktime strftime/; 9use POSIX qw/mktime strftime/;
10use NPTest; 10use NPTest;
11 11
12plan tests => 49; 12plan tests => 50;
13 13
14my $successOutput = '/OK.*HTTP.*second/'; 14my $successOutput = '/OK.*HTTP.*second/';
15 15
16my $res; 16my $res;
17 17my $plugin = 'check_http';
18my $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" ); 20my $host_tcp_http = getTestParameter("NP_HOST_TCP_HTTP", "A host providing the HTTP Service (a web server)", "localhost");
21 21my $host_tls_http = getTestParameter("NP_HOST_TLS_HTTP", "A host providing the HTTPS Service (a tls web server)", "localhost");
22my $host_tls_http = getTestParameter( "host_tls_http", "NP_HOST_TLS_HTTP", "localhost", 22my $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)" ); 23my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
24 24my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
25my $host_tls_cert = getTestParameter( "host_tls_cert", "NP_HOST_TLS_CERT", "localhost", 25my $internet_access = getTestParameter("NP_INTERNET_ACCESS", "Is this system directly connected to the internet?", "yes");
26 "the common name of the certificate." ); 26my $host_tcp_http2 = getTestParameter("NP_HOST_TCP_HTTP2", "A host providing an index page containing the string 'monitoring'", "test.monitoring-plugins.org");
27 27my $host_tcp_proxy = getTestParameter("NP_HOST_TCP_PROXY", "A host providing a HTTP proxy with CONNECT support", "localhost");
28 28my $port_tcp_proxy = getTestParameter("NP_PORT_TCP_PROXY", "Port of the proxy with HTTP and CONNECT support", "3128");
29my $host_nonresponsive = getTestParameter( "NP_HOST_NONRESPONSIVE",
30 "The hostname of system not responsive to network requests",
31 "10.0.0.1" );
32
33my $hostname_invalid = getTestParameter( "NP_HOSTNAME_INVALID",
34 "An invalid (not known to DNS) hostname",
35 "nosuchhost");
36
37my $internet_access = getTestParameter( "NP_INTERNET_ACCESS",
38 "Is this system directly connected to the internet?",
39 "yes");
40
41my $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
45my $faketime = -x '/usr/bin/faketime' ? 1 : 0; 30my $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 );
51cmp_ok( $res->return_code, '==', 0, "Webserver $host_tcp_http responded" ); 36cmp_ok( $res->return_code, '==', 0, "Webserver $host_tcp_http responded" );
52like( $res->output, $successOutput, "Output OK" ); 37like( $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 );
57like( $res->output, '/bob:there\r\ncarl:frown\r\n/', "Got headers with multiple -k options" ); 42like( $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 );
62cmp_ok( $res->return_code, '==', 2, "Webserver $host_nonresponsive not responding" ); 47cmp_ok( $res->return_code, '==', 2, "Webserver $host_nonresponsive not responding" );
63cmp_ok( $res->output, 'eq', "CRITICAL - Socket timeout after 3 seconds", "Output OK"); 48cmp_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 );
68cmp_ok( $res->return_code, '==', 2, "Webserver $hostname_invalid not valid" ); 53cmp_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" );
72like( $res->output, "/Unable to open TCP socket|Socket timeout after/", "Output OK"); 57like( $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");
76like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" ); 61like( $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");
79like( $res->output, '/^Host: '.$host_tcp_http.'\s*$/ms', "Host Header OK" ); 64like( $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");
82like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" ); 67like( $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");
85like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" ); 70like( $res->output, '/^Host: '.$host_tcp_http.':8080\s*$/ms', "Host Header OK" );
86 71
87SKIP: { 72SKIP: {
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
100SKIP: { 85SKIP: {
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}
120SKIP: { 105SKIP: {
121 skip "No internet access", 16 if $internet_access eq "no"; 106 skip "No internet access", 16 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", 12 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
182SKIP: {
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;
8use Test::More tests => 7; 8use Test::More tests => 7;
9use NPTest; 9use NPTest;
10 10
11my $host_tcp_smtp = getTestParameter( "host_tcp_smtp", "NP_HOST_TCP_SMTP", "mailhost", 11my $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)"); 12my $host_tcp_imap = getTestParameter("NP_HOST_TCP_IMAP", "A host providing an IMAP Service (a mail server)", $host_tcp_smtp);
13 13my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
14my $host_tcp_imap = getTestParameter( "host_tcp_imap", "NP_HOST_TCP_IMAP", $host_tcp_smtp, 14my $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
17my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1",
18 "The hostname of system not responsive to network requests" );
19
20my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost",
21 "An invalid (not known to DNS) hostname" );
22 15
23my $t; 16my $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
11plan tests => 10; 11plan tests => 10;
12 12
13my $host_tcp_jabber = getTestParameter( 13my $host_tcp_jabber = getTestParameter("NP_HOST_TCP_JABBER", "A host providing the Jabber Service", "jabber.de");
14 "NP_HOST_TCP_JABBER", 14my $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", 15my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
16 "jabber.org"
17 );
18
19my $host_nonresponsive = getTestParameter(
20 "NP_HOST_NONRESPONSIVE",
21 "The hostname of system not responsive to network requests",
22 "10.0.0.1",
23 );
24
25my $hostname_invalid = getTestParameter(
26 "NP_HOSTNAME_INVALID",
27 "An invalid (not known to DNS) hostname",
28 "nosuchhost",
29 );
30 16
31 17
32my $jabberOK = '/JABBER OK\s-\s\d+\.\d+\ssecond response time on '.$host_tcp_jabber.' port 5222/'; 18my $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;
9use Test::More; 9use Test::More;
10use NPTest; 10use NPTest;
11 11
12my $host_tcp_ldap = getTestParameter("NP_HOST_TCP_LDAP", 12my $host_tcp_ldap = getTestParameter("NP_HOST_TCP_LDAP", "A host providing the LDAP Service", "localhost");
13 "A host providing the LDAP Service", 13my $ldap_base_dn = getTestParameter("NP_LDAP_BASE_DN", "A base dn for the LDAP Service", "cn=admin");
14 "localhost" ); 14my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
15 15my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
16my $ldap_base_dn = getTestParameter("NP_LDAP_BASE_DN",
17 "A base dn for the LDAP Service",
18 "cn=admin" );
19
20my $host_nonresponsive = getTestParameter("host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1",
21 "The hostname of system not responsive to network requests" );
22
23my $hostname_invalid = getTestParameter("hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost",
24 "An invalid (not known to DNS) hostname" );
25 16
26my($result, $cmd); 17my($result, $cmd);
27my $command = './check_ldap'; 18my $command = './check_ldap';
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");
21plan tests => 15; 21plan tests => 15;
22 22
23my $bad_login_output = '/Access denied for user /'; 23my $bad_login_output = '/Access denied for user /';
24my $mysqlserver = getTestParameter( 24my $mysqlserver = getTestParameter("NP_MYSQL_SERVER", "A MySQL Server hostname or IP with no slaves setup");
25 "NP_MYSQL_SERVER", 25my $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" 26my $mysql_login_details = getTestParameter("NP_MYSQL_LOGIN_DETAILS", "Command line parameters to specify login access (requires REPLICATION CLIENT privleges)", "-u test -ptest");
27 ); 27my $with_slave = getTestParameter("NP_MYSQL_WITH_SLAVE", "MySQL server with slaves setup");
28my $mysqlsocket = getTestParameter( 28my $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 );
32my $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 );
38my $with_slave = getTestParameter(
39 "NP_MYSQL_WITH_SLAVE",
40 "MySQL server with slaves setup"
41 );
42my $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
49my $result; 30my $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
18plan skip_all => "check_mysql_query not compiled" unless (-x "check_mysql_query"); 18plan skip_all => "check_mysql_query not compiled" unless (-x "check_mysql_query");
19 19
20my $mysqlserver = getTestParameter( 20my $mysqlserver = getTestParameter("NP_MYSQL_SERVER", "A MySQL Server with no slaves setup");
21 "NP_MYSQL_SERVER", 21my $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 );
24my $mysql_login_details = getTestParameter(
25 "MYSQL_LOGIN_DETAILS",
26 "Command line parameters to specify login access",
27 "-u user -ppw -d db",
28 );
29my $result; 22my $result;
30 23
31if (! $mysqlserver) { 24if (! $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
16my $res; 16my $res;
17 17
18my $host_snmp = getTestParameter( "host_snmp", "NP_HOST_SNMP", "localhost", 18my $host_snmp = getTestParameter("NP_HOST_SNMP", "A host providing an SNMP Service", "localhost");
19 "A host providing an SNMP Service"); 19my $snmp_community = getTestParameter("NP_SNMP_COMMUNITY", "The SNMP Community string for SNMP Testing (assumes snmp v1)", "public");
20my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
21my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
22my $user_snmp = getTestParameter("NP_SNMP_USER", "An SNMP user", "auth_md5");
20 23
21my $snmp_community = getTestParameter( "snmp_community", "NP_SNMP_COMMUNITY", "public",
22 "The SNMP Community string for SNMP Testing (assumes snmp v1)" );
23
24my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1",
25 "The hostname of system not responsive to network requests" );
26
27my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost",
28 "An invalid (not known to DNS) hostname" );
29my $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" );
32is( $res->return_code, 3, "No host name" ); 26is( $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;
9use NPTest; 9use NPTest;
10 10
11# Required parameters 11# Required parameters
12my $ssh_host = getTestParameter("NP_SSH_HOST", 12my $ssh_host = getTestParameter("NP_SSH_HOST", "A host providing SSH service", "localhost");
13 "A host providing SSH service", 13my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1" );
14 "localhost"); 14my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost" );
15
16my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE",
17 "The hostname of system not responsive to network requests",
18 "10.0.0.1" );
19
20my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID",
21 "An invalid (not known to DNS) hostname",
22 "nosuchhost" );
23 15
24 16
25plan skip_all => "SSH_HOST must be defined" unless $ssh_host; 17plan skip_all => "SSH_HOST must be defined" unless $ssh_host;
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
18my $host_tcp_http = getTestParameter( "host_tcp_http", "NP_HOST_TCP_HTTP", "localhost", 18my $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)" ); 19my $host_tls_http = getTestParameter("NP_HOST_TLS_HTTP", "A host providing the HTTPS Service (a tls web server)", "localhost");
20 20my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
21my $host_tls_http = getTestParameter( "host_tls_http", "NP_HOST_TLS_HTTP", "localhost", 21my $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)" ); 22my $internet_access = getTestParameter("NP_INTERNET_ACCESS", "Is this system directly connected to the internet?", "yes");
23
24my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1",
25 "The hostname of system not responsive to network requests" );
26
27my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost",
28 "An invalid (not known to DNS) hostname" );
29
30my $internet_access = getTestParameter( "NP_INTERNET_ACCESS",
31 "Is this system directly connected to the internet?",
32 "yes");
33 23
34my $successOutput = '/^TCP OK\s-\s+[0-9]?\.?[0-9]+ second response time on port [0-9]+/'; 24my $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;
11use vars qw($tests); 11use vars qw($tests);
12BEGIN {$tests = 8; plan tests => $tests} 12BEGIN {$tests = 8; plan tests => $tests}
13 13
14my $host_udp_time = getTestParameter( "host_udp_time", "NP_HOST_UDP_TIME", "localhost", 14my $host_udp_time = getTestParameter("NP_HOST_UDP_TIME", "A host providing the UDP Time Service", "localhost");
15 "A host providing the UDP Time Service" ); 15my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
16 16my $hostname_invalid = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
17my $host_nonresponsive = getTestParameter( "host_nonresponsive", "NP_HOST_NONRESPONSIVE", "10.0.0.1",
18 "The hostname of system not responsive to network requests" );
19
20my $hostname_invalid = getTestParameter( "hostname_invalid", "NP_HOSTNAME_INVALID", "nosuchhost",
21 "An invalid (not known to DNS) hostname" );
22 17
23my $successOutput = '/^TIME OK - [0-9]+ second time difference/'; 18my $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-----
2MIIDYzCCAsygAwIBAgIJAJISzcX71f5pMA0GCSqGSIb3DQEBBAUAMH8xCzAJBgNV 2MIIEETCCAvmgAwIBAgIUFDsP6WnV/uqeQMpD/DYSqouE13kwDQYJKoZIhvcNAQEL
3BAYTAlVLMRMwEQYDVQQIEwpEZXJieXNoaXJlMQ8wDQYDVQQHEwZCZWxwZXIxFzAV 3BQAwgZcxCzAJBgNVBAYTAkRFMRAwDgYDVQQIDAdCYXZhcmlhMQ8wDQYDVQQHDAZN
4BgNVBAoTDk5hZ2lvcyBQbHVnaW5zMREwDwYDVQQDEwhUb24gVm9vbjEeMBwGCSqG 4dW5pY2gxGzAZBgNVBAoMEk1vbml0b3JpbmcgUGx1Z2luczEbMBkGA1UEAwwSTW9u
5SIb3DQEJARYPdG9udm9vbkBtYWMuY29tMB4XDTA5MDMwNjAwMTMxNVoXDTA5MDMw 5aXRvcmluZyBQbHVnaW5zMSswKQYJKoZIhvcNAQkBFhxkZXZlbEBtb25pdG9yaW5n
6NTAwMTMxNlowfzELMAkGA1UEBhMCVUsxEzARBgNVBAgTCkRlcmJ5c2hpcmUxDzAN 6LXBsdWdpbnMub3JnMB4XDTA4MDEwMTExMDAyNloXDTA4MDEwMjExMDAyNlowgZcx
7BgNVBAcTBkJlbHBlcjEXMBUGA1UEChMOTmFnaW9zIFBsdWdpbnMxETAPBgNVBAMT 7CzAJBgNVBAYTAkRFMRAwDgYDVQQIDAdCYXZhcmlhMQ8wDQYDVQQHDAZNdW5pY2gx
8CFRvbiBWb29uMR4wHAYJKoZIhvcNAQkBFg90b252b29uQG1hYy5jb20wgZ8wDQYJ 8GzAZBgNVBAoMEk1vbml0b3JpbmcgUGx1Z2luczEbMBkGA1UEAwwSTW9uaXRvcmlu
9KoZIhvcNAQEBBQADgY0AMIGJAoGBAOQHP4JnzACi4q6quXAiK+gTSffG6yyjEV+K 9ZyBQbHVnaW5zMSswKQYJKoZIhvcNAQkBFhxkZXZlbEBtb25pdG9yaW5nLXBsdWdp
10iyutRgBF2MdF03X5ls0wENw/5fnMTrHynl4XoGoV/rD4CR2hGT0m7dv7Vu0MRLlP 10bnMub3JnMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyeHKwKFjJWUX
11J1SCiFeMuQS30zzLMJr0A7IW869qRlKQmzxs1JT6XDbSoNQuF154zoxwNsKlMjoX 11YHKsisypUf9dHlIPQAISyGP1BX6UL26ZLvE6kKbx3LFQ9W2POGoQWlzFiB1soGeV
12tJSHN2YpAgMBAAGjgeYwgeMwHQYDVR0OBBYEFHWjM9OQldrDLMcAfPnUVfGxlzOp 12WDd0U0JtWdCKmOXWdcXpupQlTSUtRCMDQkfqLN8GR5TBTd73rezp5mz08nMfLwu0
13MIGzBgNVHSMEgaswgaiAFHWjM9OQldrDLMcAfPnUVfGxlzOpoYGEpIGBMH8xCzAJ 13p5VQ191Ui8JHFgrAOalAn8Uw5De8vj4VmTXmU5NJ2UFoC0ddU/Th/lwRCayHc1cn
14BgNVBAYTAlVLMRMwEQYDVQQIEwpEZXJieXNoaXJlMQ8wDQYDVQQHEwZCZWxwZXIx 14MVq2F7c/uhMUUQYNBmJy0pxoHawp+j9NKl/xIYsjgQNgahQyNuswuGHjaEwhPu+7
15FzAVBgNVBAoTDk5hZ2lvcyBQbHVnaW5zMREwDwYDVQQDEwhUb24gVm9vbjEeMBwG 15G03XsW4ehu+H1898M/MkSln6LQAU1syoJ8ypPM8tV+zgx4uwj7udnZ2hceN95uW7
16CSqGSIb3DQEJARYPdG9udm9vbkBtYWMuY29tggkAkhLNxfvV/mkwDAYDVR0TBAUw 160PWg5DQyUwIDAQABo1MwUTAdBgNVHQ4EFgQUt9ps3KJ1XiMuy/ijFBjMzf6jgwkw
17AwEB/zANBgkqhkiG9w0BAQQFAAOBgQDHjoXoGwBamCiNplTt93jH/TO08RATdZP5 17HwYDVR0jBBgwFoAUt9ps3KJ1XiMuy/ijFBjMzf6jgwkwDwYDVR0TAQH/BAUwAwEB
1845hlxv2+PKCjjTiFa2mjAvopFiqmYsr40XYEmpeYMiaOzOW5rBjtqBAT/JJWyfda 18/zANBgkqhkiG9w0BAQsFAAOCAQEAVPBZwMHbrnHFbmhbcPuvYd5cxk0uSVNAUzsl
19SCmj3swqyKus63rv/iuokIhZzBdhbB+eOJJrmwT2SEc5KdRaipH0QAGF1nZAAGzo 192biCq5P+ZHo10VHGygXtdV4utqk/IrAt2u5qSxycWPStCtAgTd3Q8ncfjOkaHM4z
206xW7hkzYog== 202bxTkhLyQeU8NWPuDBqDszo2GOaFTv+lm36LEKiAfqB1tjQVePSkycdrWIhkamBV
21EgMe6uHLdU7QQk1ajQfrBdakN1beqki/dKieA6gm+XF/QS4SSYINmsHB/2X5cT9U
22b/KMB8xurCnuJQuk1P4VsSkJCOSeHjWZgK9pKNdsIJZr4wDVfhjQgU0XT6xakSf7
23eCaHtO0VKsbLZoiTmpxidjsdYiXyeKYIQNtUpTjyJ5V/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-----
2MIICXAIBAAKBgQDkBz+CZ8wAouKuqrlwIivoE0n3xussoxFfiosrrUYARdjHRdN1 2MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDJ4crAoWMlZRdg
3+ZbNMBDcP+X5zE6x8p5eF6BqFf6w+AkdoRk9Ju3b+1btDES5TydUgohXjLkEt9M8 3cqyKzKlR/10eUg9AAhLIY/UFfpQvbpku8TqQpvHcsVD1bY84ahBaXMWIHWygZ5VY
4yzCa9AOyFvOvakZSkJs8bNSU+lw20qDULhdeeM6McDbCpTI6F7SUhzdmKQIDAQAB 4N3RTQm1Z0IqY5dZ1xem6lCVNJS1EIwNCR+os3wZHlMFN3vet7OnmbPTycx8vC7Sn
5AoGARgI3rHjjuDpKMGg4IMZNBqaNaiZHY9/44IVvrww21rSbFqtIfgsQEpU0R/rS 5lVDX3VSLwkcWCsA5qUCfxTDkN7y+PhWZNeZTk0nZQWgLR11T9OH+XBEJrIdzVycx
6R7xDWPztRGQqmwd/t6OfYNpqHbjO1MWzasVBVnzue5P59Y1xy1h0LZF8+a9GY++0 6WrYXtz+6ExRRBg0GYnLSnGgdrCn6P00qX/EhiyOBA2BqFDI26zC4YeNoTCE+77sb
7uAGUC24jsXSmypNVzoX+ZKyinA3oYV/etdPYx1W8Ms5XIzUCQQD7xwhMuLok6Kbq 7Tdexbh6G74fXz3wz8yRKWfotABTWzKgnzKk8zy1X7ODHi7CPu52dnaFx433m5bvQ
8UEgiSfBTbx+haP3IiqqMF14z8QoEyD3jchydNaXEYdQxN8jEl2aPrMqTc6x8Jq4/ 89aDkNDJTAgMBAAECggEACrLFfNnQmD24NGs/S4e2/VpsA9xTZI/3kNkDNgxULANP
9ai0OkB+fAkEA59pAmN81HylV7+CsVjLOSbJqzau7NDxSs2uutxhHZRwz0e25wVer 9aNZtxRajwI9A/BCXQ2UTgsZhzWnJxOJYXrlpl7PweY78mUesysb3MOUC6QisUm0M
10fA03l08u0ebC/TDHkmHV6ikCryM5HU2FNwJAVZJFzd2S1myEHmr+uTisB49jDrbi 10kimfdktHWOnAKLFFLNleN9DUVjjVkTeslijqhNX80f80py1grG2UuCLKCX4OqYIm
11WkBWypo+mCS6JPnxntXvx7auClq9haTSBY73eqldiFPuMZvr6P2rJqHxPQJBAOTM 11qACE8TMmSZLz42AO96TndNtKplQ8LuGLEmByW95wEfhx3Gm4ckkL7qII/U3DnQXr
12quaxjti7kATy8N73sD9mBKQGju1TgkFxSK+DFCGhnTnToXY9MAtxd6SoDYoyccYu 120T+3xLaj+eNJzYDpIFZiw4sNzOuAyCz+4Cc4sPDuMnzquXF+enpkemoycC1RmEpG
13dyPrzJAR/IYc+mYCdC0CQDKlZuMPVXEgvGaQapzMQ++5yJRvMZF4tWvONBs0OCE9 13KIDTwmFsc8TrbGV0qifC6fsCrDivdYLqL7R/q3IBQQKBgQDmfvO3VYTEKY8NA+AT
14QYarsTi5M20cymMBXHOLZIjqwsni4G/C9kqJSvC75Vg= 145s6+7NTxRsXxJUCEhCNBWimSH3EzmBAvrodLY6A0oYg8i81bgNX1I9GPVXJZ/QA7
15-----END RSA PRIVATE KEY----- 15ukd84HUIQoGS5Usmo4rp+kz4P6KkLXDemZtWPU5GXxicfajHRQlkbW6St6SpV7IS
16ibJcDADeoiaPL1xvue1ToP/LoQKBgQDgOFHjYpep00gabvjXfYW7vhrg1vVwaKUM
17rf0+UW8Exk4nbBw0eEC2YjxIwzdktlkdbzGaXYULnhg8GnfxYesMOpCLPw1JdB8o
18ixETAFpW5bKrUsjEFRUGhzWnsCSFIQ4smpmtGLTxOQ8AkoDdORY5Z+Wv7JtFF6Do
19PSoblckZcwKBgB3TD3YJesRnHDty5OuuUdIikuslXTd2uoJrFqS+JeLibqNeabnB
20u3/lxDULMbWj4U6VvRmbKOKDC+jY887Gq7lc0cff0yROxwqY3sCnwo3crg7QUmp7
21Nb5S8G3qoCSfndcq96wm/Me/O28uCbycVJfUdchY8uRUHIHYbP0FOBQBAoGBAMgh
22fPX4imaKr1DovDObVkK87EDDnU84GBm5MtDs3qrkVd3aIVK0Aw7HoAdSN58tI12i
23YiPmVVqJQhhjh6tsOuAvZdTj8ngdrbICbrsHFZt6an+A5LIgHyQ0iy+hiPdLCdvG
24ImTeKKMmyr04Bs1upueWVO0xw2VoMbcY4Py+NUEBAoGASQqedfCSKGLT+5lLZrhP
25CbFVMmswEPjBcRb1trcuA09vfExn9FfUNFnnw3i9miprED5kufvAjb+6nduXizKg
267HQYHCwVvakgtXgbiDMaNgYZcjWm+MdnfiwLJjJTO3DfI1JF2PJ8y9R95DPlAkDm
27xH3OV8KV4UiTEVxS7ksmGzY=
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-----
2MIIDYzCCAsygAwIBAgIJAL8LkpNwzYdxMA0GCSqGSIb3DQEBBAUAMH8xCzAJBgNV 2MIIEBjCCAu6gAwIBAgIJANbQ5QQrKhUGMA0GCSqGSIb3DQEBCwUAMIGXMQswCQYD
3BAYTAlVLMRMwEQYDVQQIEwpEZXJieXNoaXJlMQ8wDQYDVQQHEwZCZWxwZXIxFzAV 3VQQGEwJERTEQMA4GA1UECAwHQmF2YXJpYTEPMA0GA1UEBwwGTXVuaWNoMRswGQYD
4BgNVBAoTDk5hZ2lvcyBQbHVnaW5zMREwDwYDVQQDEwhUb24gVm9vbjEeMBwGCSqG 4VQQKDBJNb25pdG9yaW5nIFBsdWdpbnMxGzAZBgNVBAMMEk1vbml0b3JpbmcgUGx1
5SIb3DQEJARYPdG9udm9vbkBtYWMuY29tMB4XDTA5MDMwNTIxNDEyOFoXDTE5MDMw 5Z2luczErMCkGCSqGSIb3DQEJARYcZGV2ZWxAbW9uaXRvcmluZy1wbHVnaW5zLm9y
6MzIxNDEyOFowfzELMAkGA1UEBhMCVUsxEzARBgNVBAgTCkRlcmJ5c2hpcmUxDzAN 6ZzAeFw0xOTAyMTkxNTMxNDRaFw0yOTAyMTYxNTMxNDRaMIGXMQswCQYDVQQGEwJE
7BgNVBAcTBkJlbHBlcjEXMBUGA1UEChMOTmFnaW9zIFBsdWdpbnMxETAPBgNVBAMT 7RTEQMA4GA1UECAwHQmF2YXJpYTEPMA0GA1UEBwwGTXVuaWNoMRswGQYDVQQKDBJN
8CFRvbiBWb29uMR4wHAYJKoZIhvcNAQkBFg90b252b29uQG1hYy5jb20wgZ8wDQYJ 8b25pdG9yaW5nIFBsdWdpbnMxGzAZBgNVBAMMEk1vbml0b3JpbmcgUGx1Z2luczEr
9KoZIhvcNAQEBBQADgY0AMIGJAoGBAKcWMBtNtfY8vZXk0SN6/EYTVN/LOvaOSegy 9MCkGCSqGSIb3DQEJARYcZGV2ZWxAbW9uaXRvcmluZy1wbHVnaW5zLm9yZzCCASIw
10oVdLoGwuwjagk+XmCzvCqHZRp8lnCLay7AO8AQI7TSN02ihCcSrgGA9OT+HciIJ1 10DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKgV2yp8pQvJuN+aJGdAe6Hd0tja
11l5/kEYUAuA1PR6YKK/T713zUAlMzy2tsugx5+xSsSEwsXkmne52jJiG/wuE5CLT0 11uteCPcNIcM92WLOF69TLTSYon1XDon4tHTh4Z5d4lD8bfsGzFVBmDSgWidhAUf+v
129pF8HQqHAgMBAAGjgeYwgeMwHQYDVR0OBBYEFGioSPQ/rdE19+zaeY2YvHTXlUDI 12EqEXwbp293ej/Frc0pXCvmrz6kI1tWrLtQhL/VdbxFYxhV7JjKb+PY3SxGFpSLPe
13MIGzBgNVHSMEgaswgaiAFGioSPQ/rdE19+zaeY2YvHTXlUDIoYGEpIGBMH8xCzAJ 13PQ/5SwVndv7rZIwcjseL22K5Uy2TIrkgzzm2pRs/IvoxRybYr/+LGoHyrtJC6AO8
14BgNVBAYTAlVLMRMwEQYDVQQIEwpEZXJieXNoaXJlMQ8wDQYDVQQHEwZCZWxwZXIx 14ylp8A/etL0gwtUvRnrnZeTQ2pA1uZ5QN3anTL8JP/ZRZYNegIkaawqMtTKbhM6pi
15FzAVBgNVBAoTDk5hZ2lvcyBQbHVnaW5zMREwDwYDVQQDEwhUb24gVm9vbjEeMBwG 15u3/4a3Uppvt0y7vmGfQlYejxCpICnMrvHMpw8L58zv/98AbCGjDU3UwCt6MCAwEA
16CSqGSIb3DQEJARYPdG9udm9vbkBtYWMuY29tggkAvwuSk3DNh3EwDAYDVR0TBAUw 16AaNTMFEwHQYDVR0OBBYEFG/UH6nGYPlVcM75UXzXBF5GZyrcMB8GA1UdIwQYMBaA
17AwEB/zANBgkqhkiG9w0BAQQFAAOBgQCdqasaIO6JiV5ONFG6Tr1++85UfEdZKMUX 17FG/UH6nGYPlVcM75UXzXBF5GZyrcMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcN
18N2NHiNNUunolIZEYR+dW99ezKmHlDiQ/tMgoLVYpl2Ubho2pAkLGQR+W0ZASgWQ1 18AQELBQADggEBAGwitJPOnlIKLndNf+iCLMIs0dxsl8kAaejFcjoT0n4ja7Y6Zrqz
19NjfV27Rv0y6lYQMTA0lVAU93L1x9reo3FMedmL5+H+lIEpLCxEPtAJNISrJOneZB 19VSIidzz9vQWvy24xKJpAOdj/iLRHCUOG+Pf5fA6+/FiuqXr6gE2/lm0eC58BNONr
20W5jDadwkoQ== 20E5OzjQ/VoQ8RX4hDntgu6FYbaVa/vhwn16igt9qmdNGGZXf2/+DM3JADwyaA4EK8
21vm7KdofX9zkxXecHPNvf3jiVLPiDDt6tkGpHPEsyP/yc+RUdltUeZvHfliV0cCuC
22jJX+Fm9ysjSpHIFFr+jUMuMHibWoOD8iy3eYxfCDoWsH488pCbj8MNuAq6vd6DBk
23bOZxDz43vjWuYMkwXJTxJQh7Pne6kK0vE1g=
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-----
2MIICWwIBAAKBgQCnFjAbTbX2PL2V5NEjevxGE1Tfyzr2jknoMqFXS6BsLsI2oJPl 2MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCoFdsqfKULybjf
35gs7wqh2UafJZwi2suwDvAECO00jdNooQnEq4BgPTk/h3IiCdZef5BGFALgNT0em 3miRnQHuh3dLY2rrXgj3DSHDPdlizhevUy00mKJ9Vw6J+LR04eGeXeJQ/G37BsxVQ
4Civ0+9d81AJTM8trbLoMefsUrEhMLF5Jp3udoyYhv8LhOQi09PaRfB0KhwIDAQAB 4Zg0oFonYQFH/rxKhF8G6dvd3o/xa3NKVwr5q8+pCNbVqy7UIS/1XW8RWMYVeyYym
5AoGAfpxclcP8N3vteXErXURrd7pcXT0GECDgNjhvc9PV20RPXM+vYs1AA+fMeeQE 5/j2N0sRhaUiz3j0P+UsFZ3b+62SMHI7Hi9tiuVMtkyK5IM85tqUbPyL6MUcm2K//
6TaRqwO6x016aMRO4rz5ztYArecTBznkds1k59pkN/Ne/nsueU4tvGK8MNyS2o986 6ixqB8q7SQugDvMpafAP3rS9IMLVL0Z652Xk0NqQNbmeUDd2p0y/CT/2UWWDXoCJG
7Voohqkaq4Lcy1bcHJb9su1ELjegEr1R76Mz452Hsy+uTbAECQQDcg/tZWKVeh5CQ 7msKjLUym4TOqYrt/+Gt1Kab7dMu75hn0JWHo8QqSApzK7xzKcPC+fM7//fAGwhow
8dOEB3YWHwfn0NDgfPm/X2i2kAZ7n7URaUy/ffdlfsrr1mBtHCfedLoOxmmlNfEpM 81N1MArejAgMBAAECggEANuvdTwanTzC8jaNqHaq+OuemS2E9B8nwsGxtH/zFgvNR
9hXAAurSHAkEAwfk7fEb0iN0Sj9gTozO7c6Ky10KwePZyjVzqSQIiJq3NX8BEaIeb 9WZiMPtmrJnTkFWJcV+VPw/iMSAqN4nDHmBugVOb4Z4asxGTKK4T9shXJSnh0rqPU
1051TXxE5VxaLjjMLRkA0hWTYXClgERFZ6AQJAN7ChPqwzf08PRFwwIw911JY5cOHr 1000ZsvbmxY6z0+E5TesCJqQ+9GYTY1V357V7JchvaOxIRxWPqg9urHbru8OCtW/I5
11NoDHMCUql5vNLNdwBruxgGjBB/kUXEfgw60RusFvgt/zLh1wiii844JDawJAGQBF 11Fh5HPUZlgCvlMpjlhyjydIf/oXyVA3RNsXlwe8+2cKuGIrjEzm2j9o3VF0sctTX0
12sYP3urg7zzx7c3qUe5gJ0wLuefjR1PSX4ecbfb7DDMdcSdjIuG1QDiZGmd2f1KG7 12ItP8A9qDmDQN7GIWX0MW6gncojpS1omC2wcFsdjj/xfPyiDal1X4aq/2YqG8351c
13nwSCOtxk5dloW2KGAQJAQh/iBn0QhfKLFAP5eZBVk8E8XlZuw+S2DLy5SnBlIiYJ 13YlM/+6Va0u9WWE/i64gASTAVqpMV4Yg8y0gGycuA0QKBgQDbgI2QeLd3FvMcURiU
14GB5I2OClgtudXMv1labFrcST8O9eFrtsrhU1iUGUOw== 14l3w9qJgw/Jp3jaNC/9LkVGGz4f4lKKB67lPZvI4noMK8GqO/LcXgqP/RY1oJojoA
15-----END RSA PRIVATE KEY----- 15/6JKVvzYGASZ7VgMoG9bk1AneP1PGdibuTUEwimGlcObxnDFIC/yjwPFu3jIdqdS
16zZi1RZzyqAogN5y3SBEypSmn9wKBgQDECKsqqlcizmCl8v5aVk875AzGN+DOHZqx
17bkmztlnLO/2e2Fmk3G5Vvnui0FYisf8Eq19tUTQCF6lSfJlGQeFAT119wkFZhLu+
18FfLGqoEMH0ijJg/8PpdpFRK3I94YcISoTNN6yxMvE6xdDGfKCt5a+IX5bwQi9Zdc
19B242gEc6tQKBgA6tM8n7KFlAIZU9HuWgk2AUC8kKutFPmSD7tgAqXDYI4FNfugs+
20MEEYyHCB4UNujJBV4Ss6YZCAkh6eyD4U2aca1eElCfm40vBVMdzvpqZdAqLtWXxg
21D9l3mgszrFaYGCY2Fr6jLV9lP5g3xsxUjudf9jSLY9HvpfzjRrMaNATVAoGBALTl
22/vYfPMucwKlC5B7++J0e4/7iv6vUu9SyHocdZh1anb9AjPDKjXLIlZT4RhQ8R0XK
230wOw5JpttU2uN08TKkbLNk3/vYhbKVjPLjrQSseh8sjDLgsqw1QwIxYnniLVakVY
24p+rvjSNrNyqicQCMKQavwgocvSd5lJRTMwxOMezlAoGBAKWj71BX+0CK00/2S6lC
25TcNcuUPG0d8y1czZ4q6tUlG4htwq1FMOpaghATXjkdsOGTLS+H1aA0Kt7Ai9zDhc
26/bzOJEJ+jvBXV4Gcs7jl1r/HTKv0tT9ZSI5Vzkida0rfqxDGzcMVlLuCdH0cb8Iu
27N0wdmCAqlQwHR13+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..0caad23d
--- /dev/null
+++ b/plugins/tests/check_curl.t
@@ -0,0 +1,508 @@
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
17use strict;
18use Test::More;
19use NPTest;
20use FindBin qw($Bin);
21
22$ENV{'LC_TIME'} = "C";
23
24my $common_tests = 72;
25my $ssl_only_tests = 8;
26# Check that all dependent modules are available
27eval "use HTTP::Daemon 6.01;";
28plan skip_all => 'HTTP::Daemon >= 6.01 required' if $@;
29eval {
30 require HTTP::Status;
31 require HTTP::Response;
32};
33
34my $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)
38my $advanced_checks = 12;
39my $use_advanced_checks = 0;
40my $required_version = '7.49.0';
41my $virtual_host = 'www.somefunnyhost.com';
42my $virtual_port = 42;
43my $curl_version = '';
44open (my $fh, '-|', "./$plugin --version") or die;
45while (<$fh>) {
46 if (m{libcurl/([\d.]+)\s}) {
47 $curl_version = $1;
48 last;
49 }
50}
51close ($fh);
52if ($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
62if ($@) {
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
72my $servers = { http => 0 }; # HTTP::Daemon should always be available
73eval { require HTTP::Daemon::SSL };
74if ($@) {
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
83my $port_http = 50000 + int(rand(1000));
84my $port_https = $port_http + 1;
85my $port_https_expired = $port_http + 2;
86
87# This array keeps sockets around for implementing timeouts
88my @persist;
89
90# Start up all servers
91my @pids;
92my $pid = fork();
93if ($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 # give our webservers some time to startup
130 sleep(1);
131} else {
132 # Child
133 #print "child\n";
134 my $d = HTTP::Daemon->new(
135 LocalPort => $port_http,
136 LocalAddr => "127.0.0.1",
137 ) || die;
138 print "Please contact http at: <URL:", $d->url, ">\n";
139 run_server( $d );
140 exit;
141}
142
143# Run the same server on http and https
144sub run_server {
145 my $d = shift;
146 MAINLOOP: while (my $c = $d->accept ) {
147 while (my $r = $c->get_request) {
148 if ($r->method eq "GET" and $r->url->path =~ m^/statuscode/(\d+)^) {
149 $c->send_basic_header($1);
150 $c->send_crlf;
151 } elsif ($r->method eq "GET" and $r->url->path =~ m^/file/(.*)^) {
152 $c->send_basic_header;
153 $c->send_crlf;
154 $c->send_file_response("$Bin/var/$1");
155 } elsif ($r->method eq "GET" and $r->url->path eq "/slow") {
156 $c->send_basic_header;
157 $c->send_crlf;
158 sleep 1;
159 $c->send_response("slow");
160 } elsif ($r->url->path eq "/method") {
161 if ($r->method eq "DELETE") {
162 $c->send_error(HTTP::Status->RC_METHOD_NOT_ALLOWED);
163 } elsif ($r->method eq "foo") {
164 $c->send_error(HTTP::Status->RC_NOT_IMPLEMENTED);
165 } else {
166 $c->send_status_line(200, $r->method);
167 }
168 } elsif ($r->url->path eq "/postdata") {
169 $c->send_basic_header;
170 $c->send_crlf;
171 $c->send_response($r->method.":".$r->content);
172 } elsif ($r->url->path eq "/redirect") {
173 $c->send_redirect( "/redirect2" );
174 } elsif ($r->url->path eq "/redir_external") {
175 $c->send_redirect(($d->isa('HTTP::Daemon::SSL') ? "https" : "http") . "://169.254.169.254/redirect2" );
176 } elsif ($r->url->path eq "/redirect2") {
177 $c->send_basic_header;
178 $c->send_crlf;
179 $c->send_response(HTTP::Response->new( 200, 'OK', undef, 'redirected' ));
180 } elsif ($r->url->path eq "/redir_timeout") {
181 $c->send_redirect( "/timeout" );
182 } elsif ($r->url->path eq "/timeout") {
183 # Keep $c from being destroyed, but prevent severe leaks
184 unshift @persist, $c;
185 delete($persist[1000]);
186 next MAINLOOP;
187 } elsif ($r->url->path eq "/header_check") {
188 $c->send_basic_header;
189 $c->send_header('foo');
190 $c->send_crlf;
191 } elsif ($r->url->path eq "/header_broken_check") {
192 $c->send_basic_header;
193 $c->send_header('foo');
194 print $c "Test1:: broken\n";
195 print $c " Test2: leading whitespace\n";
196 $c->send_crlf;
197 } elsif ($r->url->path eq "/virtual_port") {
198 # return sent Host header
199 $c->send_basic_header;
200 $c->send_crlf;
201 $c->send_response(HTTP::Response->new( 200, 'OK', undef, $r->header ('Host')));
202 } else {
203 $c->send_error(HTTP::Status->RC_FORBIDDEN);
204 }
205 $c->close;
206 }
207 }
208}
209
210END {
211 foreach my $pid (@pids) {
212 if ($pid) { print "Killing $pid\n"; kill "INT", $pid }
213 }
214};
215
216if ($ARGV[0] && $ARGV[0] eq "-d") {
217 while (1) {
218 sleep 100;
219 }
220}
221
222my $result;
223my $command = "./$plugin -H 127.0.0.1";
224
225run_common_tests( { command => "$command -p $port_http" } );
226SKIP: {
227 skip "HTTP::Daemon::SSL not installed", $common_tests + $ssl_only_tests if ! exists $servers->{https};
228 run_common_tests( { command => "$command -p $port_https", ssl => 1 } );
229
230 $result = NPTest->testCmd( "$command -p $port_https -S -C 14" );
231 is( $result->return_code, 0, "$command -p $port_https -S -C 14" );
232 is( $result->output, "OK - Certificate 'Monitoring Plugins' will expire on Fri Feb 16 15:31:44 2029 +0000.", "output ok" );
233
234 $result = NPTest->testCmd( "$command -p $port_https -S -C 14000" );
235 is( $result->return_code, 1, "$command -p $port_https -S -C 14000" );
236 like( $result->output, '/WARNING - Certificate \'Monitoring Plugins\' expires in \d+ day\(s\) \(Fri Feb 16 15:31:44 2029 \+0000\)./', "output ok" );
237
238 # Expired cert tests
239 $result = NPTest->testCmd( "$command -p $port_https -S -C 13960,14000" );
240 is( $result->return_code, 2, "$command -p $port_https -S -C 13960,14000" );
241 like( $result->output, '/CRITICAL - Certificate \'Monitoring Plugins\' expires in \d+ day\(s\) \(Fri Feb 16 15:31:44 2029 \+0000\)./', "output ok" );
242
243 $result = NPTest->testCmd( "$command -p $port_https_expired -S -C 7" );
244 is( $result->return_code, 2, "$command -p $port_https_expired -S -C 7" );
245 is( $result->output,
246 'CRITICAL - Certificate \'Monitoring Plugins\' expired on Wed Jan 2 11:00:26 2008 +0000.',
247 "output ok" );
248
249}
250
251my $cmd;
252
253# advanced checks with virtual hostname and virtual port
254SKIP: {
255 skip "libcurl version is smaller than $required_version", 6 unless $use_advanced_checks;
256
257 # http without virtual port
258 $cmd = "./$plugin -H $virtual_host -I 127.0.0.1 -p $port_http -u /virtual_port -r ^$virtual_host:$port_http\$";
259 $result = NPTest->testCmd( $cmd );
260 is( $result->return_code, 0, $cmd);
261 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
262
263 # http with virtual port (!= 80)
264 $cmd = "./$plugin -H $virtual_host:$virtual_port -I 127.0.0.1 -p $port_http -u /virtual_port -r ^$virtual_host:$virtual_port\$";
265 $result = NPTest->testCmd( $cmd );
266 is( $result->return_code, 0, $cmd);
267 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
268
269 # http with virtual port (80)
270 $cmd = "./$plugin -H $virtual_host:80 -I 127.0.0.1 -p $port_http -u /virtual_port -r ^$virtual_host\$";
271 $result = NPTest->testCmd( $cmd );
272 is( $result->return_code, 0, $cmd);
273 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
274}
275
276# and the same for SSL
277SKIP: {
278 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;
279 # https without virtual port
280 $cmd = "./$plugin -H $virtual_host -I 127.0.0.1 -p $port_https --ssl -u /virtual_port -r ^$virtual_host:$port_https\$";
281 $result = NPTest->testCmd( $cmd );
282 is( $result->return_code, 0, $cmd);
283 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
284
285 # https with virtual port (!= 443)
286 $cmd = "./$plugin -H $virtual_host:$virtual_port -I 127.0.0.1 -p $port_https --ssl -u /virtual_port -r ^$virtual_host:$virtual_port\$";
287 $result = NPTest->testCmd( $cmd );
288 is( $result->return_code, 0, $cmd);
289 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
290
291 # https with virtual port (443)
292 $cmd = "./$plugin -H $virtual_host:443 -I 127.0.0.1 -p $port_https --ssl -u /virtual_port -r ^$virtual_host\$";
293 $result = NPTest->testCmd( $cmd );
294 is( $result->return_code, 0, $cmd);
295 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
296}
297
298
299sub run_common_tests {
300 my ($opts) = @_;
301 my $command = $opts->{command};
302 if ($opts->{ssl}) {
303 $command .= " --ssl";
304 }
305
306 $result = NPTest->testCmd( "$command -u /file/root" );
307 is( $result->return_code, 0, "/file/root");
308 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 274 bytes in [\d\.]+ second/', "Output correct" );
309
310 $result = NPTest->testCmd( "$command -u /file/root -s Root" );
311 is( $result->return_code, 0, "/file/root search for string");
312 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 274 bytes in [\d\.]+ second/', "Output correct" );
313
314 $result = NPTest->testCmd( "$command -u /file/root -s NonRoot" );
315 is( $result->return_code, 2, "Missing string check");
316 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");
317
318 $result = NPTest->testCmd( "$command -u /file/root -s NonRootWithOver30charsAndMoreFunThanAWetFish" );
319 is( $result->return_code, 2, "Missing string check");
320 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");
321
322 $result = NPTest->testCmd( "$command -u /header_check -d foo" );
323 is( $result->return_code, 0, "header_check search for string");
324 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 96 bytes in [\d\.]+ second/', "Output correct" );
325
326 $result = NPTest->testCmd( "$command -u /header_check -d bar" );
327 is( $result->return_code, 2, "Missing header string check");
328 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");
329
330 $result = NPTest->testCmd( "$command -u /header_broken_check" );
331 is( $result->return_code, 0, "header_check search for string");
332 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - 138 bytes in [\d\.]+ second/', "Output correct" );
333
334 my $cmd;
335 $cmd = "$command -u /slow";
336 $result = NPTest->testCmd( $cmd );
337 is( $result->return_code, 0, "$cmd");
338 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
339 $result->output =~ /in ([\d\.]+) second/;
340 cmp_ok( $1, ">", 1, "Time is > 1 second" );
341
342 $cmd = "$command -u /statuscode/200";
343 $result = NPTest->testCmd( $cmd );
344 is( $result->return_code, 0, $cmd);
345 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
346
347 $cmd = "$command -u /statuscode/200 -e 200";
348 $result = NPTest->testCmd( $cmd );
349 is( $result->return_code, 0, $cmd);
350 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - Status line output matched "200" - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
351
352 $cmd = "$command -u /statuscode/201";
353 $result = NPTest->testCmd( $cmd );
354 is( $result->return_code, 0, $cmd);
355 like( $result->output, '/^HTTP OK: HTTP/1.1 201 Created - \d+ bytes in [\d\.]+ second /', "Output correct: ".$result->output );
356
357 $cmd = "$command -u /statuscode/201 -e 201";
358 $result = NPTest->testCmd( $cmd );
359 is( $result->return_code, 0, $cmd);
360 like( $result->output, '/^HTTP OK: HTTP/1.1 201 Created - Status line output matched "201" - \d+ bytes in [\d\.]+ second /', "Output correct: ".$result->output );
361
362 $cmd = "$command -u /statuscode/201 -e 200";
363 $result = NPTest->testCmd( $cmd );
364 is( $result->return_code, 2, $cmd);
365 like( $result->output, '/^HTTP CRITICAL - Invalid HTTP response received from host on port \d+: HTTP/1.1 201 Created/', "Output correct: ".$result->output );
366
367 $cmd = "$command -u /statuscode/200 -e 200,201,202";
368 $result = NPTest->testCmd( $cmd );
369 is( $result->return_code, 0, $cmd);
370 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 );
371
372 $cmd = "$command -u /statuscode/201 -e 200,201,202";
373 $result = NPTest->testCmd( $cmd );
374 is( $result->return_code, 0, $cmd);
375 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 );
376
377 $cmd = "$command -u /statuscode/203 -e 200,201,202";
378 $result = NPTest->testCmd( $cmd );
379 is( $result->return_code, 2, $cmd);
380 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 );
381
382 $cmd = "$command -j HEAD -u /method";
383 $result = NPTest->testCmd( $cmd );
384 is( $result->return_code, 0, $cmd);
385 like( $result->output, '/^HTTP OK: HTTP/1.1 200 HEAD - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
386
387 $cmd = "$command -j POST -u /method";
388 $result = NPTest->testCmd( $cmd );
389 is( $result->return_code, 0, $cmd);
390 like( $result->output, '/^HTTP OK: HTTP/1.1 200 POST - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
391
392 $cmd = "$command -j GET -u /method";
393 $result = NPTest->testCmd( $cmd );
394 is( $result->return_code, 0, $cmd);
395 like( $result->output, '/^HTTP OK: HTTP/1.1 200 GET - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
396
397 $cmd = "$command -u /method";
398 $result = NPTest->testCmd( $cmd );
399 is( $result->return_code, 0, $cmd);
400 like( $result->output, '/^HTTP OK: HTTP/1.1 200 GET - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
401
402 $cmd = "$command -P foo -u /method";
403 $result = NPTest->testCmd( $cmd );
404 is( $result->return_code, 0, $cmd);
405 like( $result->output, '/^HTTP OK: HTTP/1.1 200 POST - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
406
407 $cmd = "$command -j DELETE -u /method";
408 $result = NPTest->testCmd( $cmd );
409 is( $result->return_code, 1, $cmd);
410 like( $result->output, '/^HTTP WARNING: HTTP/1.1 405 Method Not Allowed/', "Output correct: ".$result->output );
411
412 $cmd = "$command -j foo -u /method";
413 $result = NPTest->testCmd( $cmd );
414 is( $result->return_code, 2, $cmd);
415 like( $result->output, '/^HTTP CRITICAL: HTTP/1.1 501 Not Implemented/', "Output correct: ".$result->output );
416
417 $cmd = "$command -P stufftoinclude -u /postdata -s POST:stufftoinclude";
418 $result = NPTest->testCmd( $cmd );
419 is( $result->return_code, 0, $cmd);
420 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
421
422 $cmd = "$command -j PUT -P stufftoinclude -u /postdata -s PUT:stufftoinclude";
423 $result = NPTest->testCmd( $cmd );
424 is( $result->return_code, 0, $cmd);
425 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
426
427 # To confirm that the free doesn't segfault
428 $cmd = "$command -P stufftoinclude -j PUT -u /postdata -s PUT:stufftoinclude";
429 $result = NPTest->testCmd( $cmd );
430 is( $result->return_code, 0, $cmd);
431 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
432
433 $cmd = "$command -u /redirect";
434 $result = NPTest->testCmd( $cmd );
435 is( $result->return_code, 0, $cmd);
436 like( $result->output, '/^HTTP OK: HTTP/1.1 301 Moved Permanently - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
437
438 $cmd = "$command -f follow -u /redirect";
439 $result = NPTest->testCmd( $cmd );
440 is( $result->return_code, 0, $cmd);
441 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
442
443 $cmd = "$command -u /redirect -k 'follow: me'";
444 $result = NPTest->testCmd( $cmd );
445 is( $result->return_code, 0, $cmd);
446 like( $result->output, '/^HTTP OK: HTTP/1.1 301 Moved Permanently - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
447
448 $cmd = "$command -f follow -u /redirect -k 'follow: me'";
449 $result = NPTest->testCmd( $cmd );
450 is( $result->return_code, 0, $cmd);
451 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
452
453 $cmd = "$command -f sticky -u /redirect -k 'follow: me'";
454 $result = NPTest->testCmd( $cmd );
455 is( $result->return_code, 0, $cmd);
456 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
457
458 $cmd = "$command -f stickyport -u /redirect -k 'follow: me'";
459 $result = NPTest->testCmd( $cmd );
460 is( $result->return_code, 0, $cmd);
461 like( $result->output, '/^HTTP OK: HTTP/1.1 200 OK - \d+ bytes in [\d\.]+ second/', "Output correct: ".$result->output );
462
463 # These tests may block
464 print "ALRM\n";
465
466 # stickyport - on full urlS port is set back to 80 otherwise
467 $cmd = "$command -f stickyport -u /redir_external -t 5 -s redirected";
468 eval {
469 local $SIG{ALRM} = sub { die "alarm\n" };
470 alarm(2);
471 $result = NPTest->testCmd( $cmd );
472 alarm(0); };
473 isnt( $@, "alarm\n", $cmd );
474 is( $result->return_code, 0, $cmd );
475
476 # Let's hope there won't be any web server on :80 returning "redirected"!
477 $cmd = "$command -f sticky -u /redir_external -t 5 -s redirected";
478 eval {
479 local $SIG{ALRM} = sub { die "alarm\n" };
480 alarm(2);
481 $result = NPTest->testCmd( $cmd );
482 alarm(0); };
483 isnt( $@, "alarm\n", $cmd );
484 isnt( $result->return_code, 0, $cmd );
485
486 # Test an external address - timeout
487 SKIP: {
488 skip "This doesn't seem to work all the time", 1 unless ($ENV{HTTP_EXTERNAL});
489 $cmd = "$command -f follow -u /redir_external -t 5";
490 eval {
491 $result = NPTest->testCmd( $cmd, 2 );
492 };
493 like( $@, "/timeout in command: $cmd/", $cmd );
494 }
495
496 $cmd = "$command -u /timeout -t 5";
497 eval {
498 $result = NPTest->testCmd( $cmd, 2 );
499 };
500 like( $@, "/timeout in command: $cmd/", $cmd );
501
502 $cmd = "$command -f follow -u /redir_timeout -t 2";
503 eval {
504 $result = NPTest->testCmd( $cmd, 5 );
505 };
506 is( $@, "", $cmd );
507
508}
diff --git a/plugins/tests/check_http.t b/plugins/tests/check_http.t
index d6d31de1..2f051fad 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
15use strict; 17use strict;
16use Test::More; 18use Test::More;
@@ -30,13 +32,16 @@ eval {
30 require HTTP::Response; 32 require HTTP::Response;
31}; 33};
32 34
35my $plugin = 'check_http';
36$plugin = 'check_curl' if $0 =~ m/check_curl/mx;
37
33if ($@) { 38if ($@) {
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
@@ -185,7 +190,7 @@ if ($ARGV[0] && $ARGV[0] eq "-d") {
185} 190}
186 191
187my $result; 192my $result;
188my $command = "./check_http -H 127.0.0.1"; 193my $command = "./$plugin -H 127.0.0.1";
189 194
190run_common_tests( { command => "$command -p $port_http" } ); 195run_common_tests( { command => "$command -p $port_http" } );
191SKIP: { 196SKIP: {
@@ -194,21 +199,21 @@ SKIP: {
194 199
195 $result = NPTest->testCmd( "$command -p $port_https -S -C 14" ); 200 $result = NPTest->testCmd( "$command -p $port_https -S -C 14" );
196 is( $result->return_code, 0, "$command -p $port_https -S -C 14" ); 201 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" ); 202 is( $result->output, "OK - Certificate 'Monitoring Plugins' will expire on Fri Feb 16 15:31:44 2029 +0000.", "output ok" );
198 203
199 $result = NPTest->testCmd( "$command -p $port_https -S -C 14000" ); 204 $result = NPTest->testCmd( "$command -p $port_https -S -C 14000" );
200 is( $result->return_code, 1, "$command -p $port_https -S -C 14000" ); 205 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" ); 206 like( $result->output, '/WARNING - Certificate \'Monitoring Plugins\' expires in \d+ day\(s\) \(Fri Feb 16 15:31:44 2029 \+0000\)./', "output ok" );
202 207
203 # Expired cert tests 208 # Expired cert tests
204 $result = NPTest->testCmd( "$command -p $port_https -S -C 13960,14000" ); 209 $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" ); 210 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" ); 211 like( $result->output, '/CRITICAL - Certificate \'Monitoring Plugins\' expires in \d+ day\(s\) \(Fri Feb 16 15:31:44 2029 \+0000\)./', "output ok" );
207 212
208 $result = NPTest->testCmd( "$command -p $port_https_expired -S -C 7" ); 213 $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" ); 214 is( $result->return_code, 2, "$command -p $port_https_expired -S -C 7" );
210 is( $result->output, 215 is( $result->output,
211 'CRITICAL - Certificate \'Ton Voon\' expired on Thu Mar 5 00:13:16 2009 +0000.', 216 'CRITICAL - Certificate \'Monitoring Plugins\' expired on Wed Jan 2 11:00:26 2008 +0000.',
212 "output ok" ); 217 "output ok" );
213 218
214} 219}
diff --git a/plugins/tests/check_snmp.t b/plugins/tests/check_snmp.t
index 73a68b20..85d6bf55 100755
--- a/plugins/tests/check_snmp.t
+++ b/plugins/tests/check_snmp.t
@@ -7,6 +7,7 @@ use strict;
7use Test::More; 7use Test::More;
8use NPTest; 8use NPTest;
9use FindBin qw($Bin); 9use FindBin qw($Bin);
10use POSIX qw/strftime/;
10 11
11my $tests = 67; 12my $tests = 67;
12# Check that all dependent modules are available 13# Check that all dependent modules are available
@@ -37,6 +38,7 @@ if ($@) {
37 38
38my $port_snmp = 16100 + int(rand(100)); 39my $port_snmp = 16100 + int(rand(100));
39 40
41my $faketime = -x '/usr/bin/faketime' ? 1 : 0;
40 42
41# Start up server 43# Start up server
42my @pids; 44my @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:\\\\\"
119because we\'re not done yet!"').'/m', "Attempt to confuse parser No.3"); 121because we\'re not done yet!"').'/m', "Attempt to confuse parser No.3");
120 122
121system("rm -f ".$ENV{'MP_STATE_PATH'}."/check_snmp/*"); 123system("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" );
123is($res->return_code, 0, "Returns OK");
124is($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
127sleep 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.
128SKIP: {
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();
130is($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" );
131is($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
134is($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" );
135is($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" );
139is($res->return_code, 0, "OK for first call" );
140is($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" );
143sleep 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
146is($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" );
147is($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
149sleep 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" );
152is($res->return_code, 0, "OK as no thresholds" );
153is($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" );
158is($res->return_code, 0, "OK as no thresholds" ); 169 is($res->output, "SNMP OK - test'test 68662 | \"test'test\"=68662c ", "Check label");
159is($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'" );
162is($res->return_code, 0, "OK as no thresholds" ); 172 is($res->return_code, 0, "OK as no thresholds" );
163is($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" );
166is($res->return_code, 0, "OK as no thresholds" ); 176 is($res->return_code, 0, "OK as no thresholds" );
167is($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" );
170is($res->return_code, 0, "OK as no thresholds" ); 180 is($res->return_code, 0, "OK as no thresholds" );
171is($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'" );
174is($res->return_code, 0, "OK as no thresholds" ); 184 is($res->return_code, 0, "OK as no thresholds" );
175is($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'" );
178is($res->return_code, 0, "OK as no thresholds" );
179is($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
183is($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" );
184is($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};
187sleep 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" );
190is($res->return_code, 0, "OK as no thresholds" );
191is($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\"'" );
diff --git a/plugins/utils.c b/plugins/utils.c
index 231af92b..348ec022 100644
--- a/plugins/utils.c
+++ b/plugins/utils.c
@@ -36,9 +36,6 @@ extern const char *progname;
36#define STRLEN 64 36#define STRLEN 64
37#define TXTBLK 128 37#define TXTBLK 128
38 38
39unsigned int timeout_state = STATE_CRITICAL;
40unsigned int timeout_interval = DEFAULT_SOCKET_TIMEOUT;
41
42time_t start_time, end_time; 39time_t start_time, end_time;
43 40
44/* ************************************************************************** 41/* **************************************************************************
@@ -148,33 +145,6 @@ print_revision (const char *command_name, const char *revision)
148 command_name, revision, PACKAGE, VERSION); 145 command_name, revision, PACKAGE, VERSION);
149} 146}
150 147
151const char *
152state_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
168void
169timeout_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
178int 148int
179is_numeric (char *number) 149is_numeric (char *number)
180{ 150{
@@ -709,3 +679,18 @@ char *sperfdata_int (const char *label,
709 return data; 679 return data;
710} 680}
711 681
682int
683open_max (void)
684{
685 errno = 0;
686 if (maxfd > 0)
687 return(maxfd);
688
689 if ((maxfd = sysconf (_SC_OPEN_MAX)) < 0) {
690 if (errno == 0)
691 maxfd = DEFAULT_MAXFD; /* it's indeterminate */
692 else
693 die (STATE_UNKNOWN, _("sysconf error for _SC_OPEN_MAX\n"));
694 }
695 return(maxfd);
696}
diff --git a/plugins/utils.h b/plugins/utils.h
index a436e1ca..33a20547 100644
--- a/plugins/utils.h
+++ b/plugins/utils.h
@@ -29,13 +29,6 @@ suite of plugins. */
29void support (void); 29void support (void);
30void print_revision (const char *, const char *); 30void print_revision (const char *, const char *);
31 31
32/* Handle timeouts */
33
34extern unsigned int timeout_state;
35extern unsigned int timeout_interval;
36
37RETSIGTYPE timeout_alarm_handler (int);
38
39extern time_t start_time, end_time; 32extern time_t start_time, end_time;
40 33
41/* Test input types */ 34/* Test input types */
@@ -89,8 +82,6 @@ void usage4(const char *) __attribute__((noreturn));
89void usage5(void) __attribute__((noreturn)); 82void usage5(void) __attribute__((noreturn));
90void usage_va(const char *fmt, ...) __attribute__((noreturn)); 83void usage_va(const char *fmt, ...) __attribute__((noreturn));
91 84
92const char *state_text (int);
93
94#define max(a,b) (((a)>(b))?(a):(b)) 85#define max(a,b) (((a)>(b))?(a):(b))
95#define min(a,b) (((a)<(b))?(a):(b)) 86#define min(a,b) (((a)<(b))?(a):(b))
96 87
@@ -106,6 +97,8 @@ char *sperfdata (const char *, double, const char *, char *, char *,
106char *sperfdata_int (const char *, int, const char *, char *, char *, 97char *sperfdata_int (const char *, int, const char *, char *, char *,
107 int, int, int, int); 98 int, int, int, int);
108 99
100int open_max (void);
101
109/* The idea here is that, although not every plugin will use all of these, 102/* 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 103 most will or should. Therefore, for consistency, these very common
111 options should have only these meanings throughout the overall suite */ 104 options should have only these meanings throughout the overall suite */