Code

time data in performance string
[nagiosplug.git] / plugins / check_http.c
1 /****************************************************************************
2  *
3  * Program: HTTP plugin for Nagios
4  * License: GPL
5  *
6  * License Information:
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  *
22  * $Id$
23  *
24  *****************************************************************************/
26 #define PROGNAME "check_http"
27 #define REVISION "$Revision$"
28 #define COPYRIGHT "1999-2001"
29 #define AUTHORS "Ethan Galstad/Karl DeBisschop"
30 #define EMAIL "kdebisschop@users.sourceforge.net"
32 #include "config.h"
33 #include "common.h"
34 #include "version.h"
35 #include "netutils.h"
36 #include "utils.h"
38 #define SUMMARY "\
39 This plugin tests the HTTP service on the specified host. It can test\n\
40 normal (http) and secure (https) servers, follow redirects, search for\n\
41 strings and regular expressions, check connection times, and report on\n\
42 certificate expiration times.\n"
44 #define OPTIONS "\
45 \(-H <vhost> | -I <IP-address>) [-u <uri>] [-p <port>]\n\
46             [-w <warn time>] [-c <critical time>] [-t <timeout>] [-L]\n\
47             [-a auth] [-f <ok | warn | critcal | follow>] [-e <expect>]\n\
48             [-s string] [-r <regex> | -R <case-insensitive regex>]\n\
49             [-P string]"
51 #define LONGOPTIONS "\
52  -H, --hostname=ADDRESS\n\
53     Host name argument for servers using host headers (virtual host)\n\
54  -I, --IP-address=ADDRESS\n\
55    IP address or name (use numeric address if possible to bypass DNS lookup).\n\
56  -e, --expect=STRING\n\
57    String to expect in first (status) line of server response (default: %s)\n\
58    If specified skips all other status line logic (ex: 3xx, 4xx, 5xx processing)\n\
59  -s, --string=STRING\n\
60    String to expect in the content\n\
61  -u, --url=PATH\n\
62    URL to GET or POST (default: /)\n\
63  -p, --port=INTEGER\n\
64    Port number (default: %d)\n\
65  -P, --post=STRING\n\
66    URL encoded http POST data\n\
67  -w, --warning=INTEGER\n\
68    Response time to result in warning status (seconds)\n\
69  -c, --critical=INTEGER\n\
70    Response time to result in critical status (seconds)\n\
71  -t, --timeout=INTEGER\n\
72    Seconds before connection times out (default: %d)\n\
73  -a, --authorization=AUTH_PAIR\n\
74    Username:password on sites with basic authentication\n\
75  -L, --link=URL\n\
76    Wrap output in HTML link (obsoleted by urlize)\n\
77  -f, --onredirect=<ok|warning|critical|follow>\n\
78    How to handle redirected pages\n%s\
79  -v, --verbose\n\
80     Show details for command-line debugging (do not use with nagios server)\n\
81  -h, --help\n\
82     Print detailed help screen\n\
83  -V, --version\n\
84     Print version information\n"
86 #ifdef HAVE_SSL
87 #define SSLOPTIONS "\
88  -S, --ssl\n\
89     Connect via SSL\n\
90  -C, --certificate=INTEGER\n\
91     Minimum number of days a certificate has to be valid.\n\
92     (when this option is used the url is not checked.)\n"
93 #else
94 #define SSLOPTIONS ""
95 #endif
97 #define DESCRIPTION "\
98 This plugin will attempt to open an HTTP connection with the host. Successul\n\
99 connects return STATE_OK, refusals and timeouts return STATE_CRITICAL, other\n\
100 errors return STATE_UNKNOWN.  Successful connects, but incorrect reponse\n\
101 messages from the host result in STATE_WARNING return values.  If you are\n\
102 checking a virtual server that uses \"host headers\" you must supply the FQDN\n\
103 \(fully qualified domain name) as the [host_name] argument.\n"
105 #define SSLDESCRIPTION "\
106 This plugin can also check whether an SSL enabled web server is able to\n\
107 serve content (optionally within a specified time) or whether the X509 \n\
108 certificate is still valid for the specified number of days.\n\n\
109 CHECK CONTENT: check_http -w 5 -c 10 --ssl www.verisign.com\n\n\
110 When the 'www.verisign.com' server returns its content within 5 seconds, a\n\
111 STATE_OK will be returned. When the server returns its content but exceeds\n\
112 the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,\n\
113 a STATE_CRITICAL will be returned.\n\n\
114 CHECK CERTIFICATE: check_http www.verisign.com -C 14\n\n\
115 When the certificate of 'www.verisign.com' is valid for more than 14 days, a\n\
116 STATE_OK is returned. When the certificate is still valid, but for less than\n\
117 14 days, a STATE_WARNING is returned. A STATE_CRITICAL will be returned when\n\
118 the certificate is expired.\n"
120 #ifdef HAVE_SSL_H
121 #include <rsa.h>
122 #include <crypto.h>
123 #include <x509.h>
124 #include <pem.h>
125 #include <ssl.h>
126 #include <err.h>
127 #include <rand.h>
128 #endif
130 #ifdef HAVE_OPENSSL_SSL_H
131 #include <openssl/rsa.h>
132 #include <openssl/crypto.h>
133 #include <openssl/x509.h>
134 #include <openssl/pem.h>
135 #include <openssl/ssl.h>
136 #include <openssl/err.h>
137 #include <openssl/rand.h>
138 #endif
140 #ifdef HAVE_SSL
141 int check_cert = FALSE;
142 int days_till_exp;
143 unsigned char *randbuff;
144 SSL_CTX *ctx;
145 SSL *ssl;
146 X509 *server_cert;
147 int connect_SSL (void);
148 int check_certificate (X509 **);
149 #endif
151 #ifdef HAVE_REGEX_H
152 #define REGS 2
153 #define MAX_RE_SIZE 256
154 #include <regex.h>
155 regex_t preg;
156 regmatch_t pmatch[REGS];
157 char regexp[MAX_RE_SIZE];
158 char errbuf[MAX_INPUT_BUFFER];
159 int cflags = REG_NOSUB | REG_EXTENDED | REG_NEWLINE;
160 int errcode;
161 #endif
163 #define server_type_check(server_type) \
164 (strcmp (server_type, "https") ? FALSE : TRUE)
166 #define server_port_check(use_ssl) (use_ssl ? HTTPS_PORT : HTTP_PORT)
168 #define MAX_IPV4_HOSTLENGTH 64
169 #define HDR_LOCATION "%*[Ll]%*[Oo]%*[Cc]%*[Aa]%*[Tt]%*[Ii]%*[Oo]%*[Nn]: "
170 #define URI_HTTP "%[HTPShtps]://"
171 #define URI_HOST "%[a-zA-Z0-9.-]"
172 #define URI_PORT ":%[0-9]"
173 #define URI_PATH "%[/a-zA-Z0-9._-=@,]"
175 #define HTTP_PORT 80
176 #define HTTPS_PORT 443
177 #define HTTP_EXPECT "HTTP/1."
178 #define HTTP_URL "/"
180 time_t start_time, end_time;
181 char timestamp[10] = "";
182 int specify_port = FALSE;
183 int server_port = HTTP_PORT;
184 char server_port_text[6] = "";
185 char server_type[6] = "http";
186 char *server_address = NULL;
187 char *host_name = NULL;
188 char *server_url = NULL;
189 int server_url_length = 0;
190 int server_expect_yn = 0;
191 char server_expect[MAX_INPUT_BUFFER] = HTTP_EXPECT;
192 char string_expect[MAX_INPUT_BUFFER] = "";
193 int warning_time = 0;
194 int check_warning_time = FALSE;
195 int critical_time = 0;
196 int check_critical_time = FALSE;
197 char user_auth[MAX_INPUT_BUFFER] = "";
198 int display_html = FALSE;
199 int onredirect = STATE_OK;
200 int use_ssl = FALSE;
201 int verbose = FALSE;
202 int sd;
203 char *http_method = NULL;
204 char *http_post_data = NULL;
205 char buffer[MAX_INPUT_BUFFER];
207 void print_usage (void);
208 void print_help (void);
209 int process_arguments (int, char **);
210 int call_getopt (int, char **);
211 static char *base64 (char *bin, int len);
212 int check_http (void);
213 int my_recv (void);
214 int my_close (void);
216 int
217 main (int argc, char **argv)
219         int result = STATE_UNKNOWN;
221         if (process_arguments (argc, argv) == ERROR)
222                 usage ("check_http: could not parse arguments\n");
224         if (strstr (timestamp, ":")) {
225                 if (strstr (server_url, "?"))
226                         sprintf (server_url, "%s&%s", server_url, timestamp);
227                 else
228                         sprintf (server_url, "%s?%s", server_url, timestamp);
229         }
231         if (display_html == TRUE)
232                 printf ("<A HREF=\"http://%s:%d%s\" target=\"_blank\">",
233                         host_name, server_port, server_url);
235         /* initialize alarm signal handling, set socket timeout, start timer */
236         signal (SIGALRM, socket_timeout_alarm_handler);
237         alarm (socket_timeout);
238         time (&start_time);
240 #ifdef HAVE_SSL
241         if (use_ssl && check_cert == TRUE) {
242                 if (connect_SSL () != OK)
243                         terminate (STATE_CRITICAL,
244                                    "HTTP CRITICAL - Could not make SSL connection\n");
245                 if ((server_cert = SSL_get_peer_certificate (ssl)) != NULL) {
246                         result = check_certificate (&server_cert);
247                         X509_free (server_cert);
248                 }
249                 else {
250                         printf ("ERROR: Cannot retrieve server certificate.\n");
251                         result = STATE_CRITICAL;
252                 }
253                 SSL_shutdown (ssl);
254                 SSL_free (ssl);
255                 SSL_CTX_free (ctx);
256                 close (sd);
257         }
258         else {
259                 result = check_http ();
260         }
261 #else
262         result = check_http ();
263 #endif
264         return result;
266 \f
269 /* process command-line arguments */
270 int
271 process_arguments (int argc, char **argv)
273         int c, i = 1;
274         char optchars[MAX_INPUT_BUFFER];
276 #ifdef HAVE_GETOPT_H
277         int option_index = 0;
278         static struct option long_options[] = {
279                 STD_OPTS_LONG,
280                 {"link", no_argument, 0, 'L'},
281                 {"nohtml", no_argument, 0, 'n'},
282                 {"ssl", no_argument, 0, 'S'},
283                 {"verbose", no_argument, 0, 'v'},
284                 {"post", required_argument, 0, 'P'},
285                 {"IP-address", required_argument, 0, 'I'},
286                 {"string", required_argument, 0, 's'},
287                 {"regex", required_argument, 0, 'r'},
288                 {"ereg", required_argument, 0, 'r'},
289                 {"eregi", required_argument, 0, 'R'},
290                 {"onredirect", required_argument, 0, 'f'},
291                 {"certificate", required_argument, 0, 'C'},
292                 {0, 0, 0, 0}
293         };
294 #endif
296         if (argc < 2)
297                 return ERROR;
299         for (c = 1; c < argc; c++) {
300                 if (strcmp ("-to", argv[c]) == 0)
301                         strcpy (argv[c], "-t");
302                 if (strcmp ("-hn", argv[c]) == 0)
303                         strcpy (argv[c], "-H");
304                 if (strcmp ("-wt", argv[c]) == 0)
305                         strcpy (argv[c], "-w");
306                 if (strcmp ("-ct", argv[c]) == 0)
307                         strcpy (argv[c], "-c");
308                 if (strcmp ("-nohtml", argv[c]) == 0)
309                         strcpy (argv[c], "-n");
310         }
312         snprintf (optchars, MAX_INPUT_BUFFER, "%s%s", STD_OPTS,
313                   "P:I:a:e:p:s:R:r:u:f:C:nLS");
315         while (1) {
316 #ifdef HAVE_GETOPT_H
317                 c = getopt_long (argc, argv, optchars, long_options, &option_index);
318 #else
319                 c = getopt (argc, argv, optchars);
320 #endif
321                 if (c == -1 || c == EOF)
322                         break;
324                 switch (c) {
325                 case '?': /* usage */
326                         usage2 ("unknown argument", optarg);
327                         break;
328                 case 'h': /* help */
329                         print_help ();
330                         exit (STATE_OK);
331                         break;
332                 case 'V': /* version */
333                         print_revision (PROGNAME, REVISION);
334                         exit (STATE_OK);
335                         break;
336                 case 't': /* timeout period */
337                         if (!is_intnonneg (optarg))
338                                 usage2 ("timeout interval must be a non-negative integer", optarg);
339                         socket_timeout = atoi (optarg);
340                         break;
341                 case 'c': /* critical time threshold */
342                         if (!is_intnonneg (optarg))
343                                 usage2 ("invalid critical threshold", optarg);
344                         critical_time = atoi (optarg);
345                         check_critical_time = TRUE;
346                         break;
347                 case 'w': /* warning time threshold */
348                         if (!is_intnonneg (optarg))
349                                 usage2 ("invalid warning threshold", optarg);
350                         warning_time = atoi (optarg);
351                         check_warning_time = TRUE;
352                         break;
353                 case 'L': /* show html link */
354                         display_html = TRUE;
355                         break;
356                 case 'n': /* do not show html link */
357                         display_html = FALSE;
358                         break;
359                 case 'S': /* use SSL */
360 #ifndef HAVE_SSL
361                         usage ("check_http: invalid option - SSL is not available\n");
362 #endif
363                         use_ssl = TRUE;
364                         if (specify_port == FALSE)
365                                 server_port = HTTPS_PORT;
366                         break;
367                 case 'C': /* warning time threshold */
368 #ifdef HAVE_SSL
369                         if (!is_intnonneg (optarg))
370                                 usage2 ("invalid certificate expiration period", optarg);
371                         days_till_exp = atoi (optarg);
372                         check_cert = TRUE;
373 #else
374                         usage ("check_http: invalid option - SSL is not available\n");
375 #endif
376                         break;
377                 case 'f': /* onredirect */
378                         if (!strcmp (optarg, "follow"))
379                                 onredirect = STATE_DEPENDENT;
380                         if (!strcmp (optarg, "unknown"))
381                                 onredirect = STATE_UNKNOWN;
382                         if (!strcmp (optarg, "ok"))
383                                 onredirect = STATE_OK;
384                         if (!strcmp (optarg, "warning"))
385                                 onredirect = STATE_WARNING;
386                         if (!strcmp (optarg, "critical"))
387                                 onredirect = STATE_CRITICAL;
388                         if (verbose)
389                                 printf("option f:%d \n", onredirect);  
390                         break;
391                 /* Note: H, I, and u must be malloc'd or will fail on redirects */
392                 case 'H': /* Host Name (virtual host) */
393                         host_name = strscpy (host_name, optarg);
394                         break;
395                 case 'I': /* Server IP-address */
396                         server_address = strscpy (server_address, optarg);
397                         break;
398                 case 'u': /* Host or server */
399                         server_url = strscpy (server_url, optarg);
400                         server_url_length = strlen (optarg);
401                         break;
402                 case 'p': /* Host or server */
403                         if (!is_intnonneg (optarg))
404                                 usage2 ("invalid port number", optarg);
405                         server_port = atoi (optarg);
406                         specify_port = TRUE;
407                         break;
408                 case 'a': /* authorization info */
409                         strncpy (user_auth, optarg, MAX_INPUT_BUFFER - 1);
410                         user_auth[MAX_INPUT_BUFFER - 1] = 0;
411                         break;
412                 case 'P': /* HTTP POST data in URL encoded format */
413                         http_method = strscpy (http_method, "POST");
414                         http_post_data = strscpy (http_post_data, optarg);
415                         break;
416                 case 's': /* string or substring */
417                         strncpy (string_expect, optarg, MAX_INPUT_BUFFER - 1);
418                         string_expect[MAX_INPUT_BUFFER - 1] = 0;
419                         break;
420                 case 'e': /* string or substring */
421                         strncpy (server_expect, optarg, MAX_INPUT_BUFFER - 1);
422                         server_expect[MAX_INPUT_BUFFER - 1] = 0;
423                         server_expect_yn = 1;
424                         break;
425                 case 'R': /* regex */
426 #ifdef HAVE_REGEX_H
427                         cflags = REG_ICASE;
428 #else
429                         usage ("check_http: call for regex which was not a compiled option\n");
430 #endif
431                 case 'r': /* regex */
432 #ifdef HAVE_REGEX_H
433                         cflags |= REG_EXTENDED | REG_NOSUB | REG_NEWLINE;
434                         strncpy (regexp, optarg, MAX_INPUT_BUFFER - 1);
435                         regexp[MAX_INPUT_BUFFER - 1] = 0;
436                         errcode = regcomp (&preg, regexp, cflags);
437                         if (errcode != 0) {
438                                 regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
439                                 printf ("Could Not Compile Regular Expression: %s", errbuf);
440                                 return ERROR;
441                         }
442 #else
443                         usage ("check_http: call for regex which was not a compiled option\n");
444 #endif
445                         break;
446                 case 'v': /* verbose */
447                         verbose = TRUE;
448                         break;
449                 }
450         }
452         c = optind;
454         if (server_address == NULL && host_name == NULL) {
455                 server_address = strscpy (NULL, argv[c]);
456                 host_name = strscpy (NULL, argv[c++]);
457         }
459         if (server_address == NULL && host_name == NULL)
460                 usage ("check_http: you must specify a host name\n");
462         if (server_address == NULL)
463                 server_address = strscpy (NULL, host_name);
465         if (host_name == NULL)
466                 host_name = strscpy (NULL, server_address);
468         if (http_method == NULL)
469                 http_method = strscpy (http_method, "GET");
471         if (server_url == NULL) {
472                 server_url = strscpy (NULL, "/");
473                 server_url_length = strlen(HTTP_URL);
474         }
476         return TRUE;
478 \f
481 /* written by lauri alanko */
482 static char *
483 base64 (char *bin, int len)
486         char *buf = (char *) malloc ((len + 2) / 3 * 4 + 1);
487         int i = 0, j = 0;
489         char BASE64_END = '=';
490         char base64_table[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
491                 "abcdefghijklmnopqrstuvwxyz"
492                 "0123456789+/";
494         while (j < len - 2) {
495                 buf[i++] = base64_table[bin[j] >> 2];
496                 buf[i++] = base64_table[((bin[j] & 3) << 4) | (bin[j + 1] >> 4)];
497                 buf[i++] = base64_table[((bin[j + 1] & 15) << 2) | (bin[j + 2] >> 6)];
498                 buf[i++] = base64_table[bin[j + 2] & 63];
499                 j += 3;
500         }
502         switch (len - j) {
503         case 1:
504                 buf[i++] = base64_table[bin[j] >> 2];
505                 buf[i++] = base64_table[(bin[j] & 3) << 4];
506                 buf[i++] = BASE64_END;
507                 buf[i++] = BASE64_END;
508                 break;
509         case 2:
510                 buf[i++] = base64_table[bin[j] >> 2];
511                 buf[i++] = base64_table[((bin[j] & 3) << 4) | (bin[j + 1] >> 4)];
512                 buf[i++] = base64_table[(bin[j + 1] & 15) << 2];
513                 buf[i++] = BASE64_END;
514                 break;
515         case 0:
516                 break;
517         }
519         buf[i] = '\0';
520         return buf;
522 \f
525 int
526 check_http (void)
528         char *msg = NULL;
529         char *status_line = NULL;
530         char *header = NULL;
531         char *page = NULL;
532         char *auth = NULL;
533         int i = 0;
534         size_t pagesize = 0;
535         char *full_page = NULL;
536         char *pos = NULL;
538         /* try to connect to the host at the given port number */
539 #ifdef HAVE_SSL
540         if (use_ssl == TRUE) {
542                 if (connect_SSL () != OK) {
543                         msg = ssprintf (msg, "Unable to open TCP socket");
544                         terminate (STATE_CRITICAL, msg);
545                 }
547                 if ((server_cert = SSL_get_peer_certificate (ssl)) != NULL) {
548                         X509_free (server_cert);
549                 }
550                 else {
551                         printf ("ERROR: Cannot retrieve server certificate.\n");
552                         return STATE_CRITICAL;
553                 }
555                 sprintf (buffer, "%s %s HTTP/1.0\r\n", http_method, server_url);
556                 if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
557                         ERR_print_errors_fp (stderr);
558                         return STATE_CRITICAL;
559                 }
561                 /* optionally send the host header info (not clear if it's usable) */
562                 if (strcmp (host_name, "")) {
563                         sprintf (buffer, "Host: %s\r\n", host_name);
564                         if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
565                                 ERR_print_errors_fp (stderr);
566                                 return STATE_CRITICAL;
567                         }
568                 }
570                 /* send user agent */
571                 sprintf (buffer, "User-Agent: check_http/%s (nagios-plugins %s)\r\n",
572                          clean_revstring (REVISION), PACKAGE_VERSION);
573                 if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
574                         ERR_print_errors_fp (stderr);
575                         return STATE_CRITICAL;
576                 }
578                 /* optionally send the authentication info */
579                 if (strcmp (user_auth, "")) {
580                         auth = base64 (user_auth, strlen (user_auth));
581                         sprintf (buffer, "Authorization: Basic %s\r\n", auth);
582                         if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
583                                 ERR_print_errors_fp (stderr);
584                                 return STATE_CRITICAL;
585                         }
586                 }
588                 /* optionally send http POST data */
589                 if (http_post_data) {
590                         sprintf (buffer, "Content-Type: application/x-www-form-urlencoded\r\n");
591                         if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
592                                 ERR_print_errors_fp (stderr);
593                                 return STATE_CRITICAL;
594                         }
595                         sprintf (buffer, "Content-Length: %i\r\n\r\n", strlen (http_post_data));
596                         if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
597                                 ERR_print_errors_fp (stderr);
598                                 return STATE_CRITICAL;
599                         }
600                         http_post_data = strscat (http_post_data, "\r\n");
601                         if (SSL_write (ssl, http_post_data, strlen (http_post_data)) == -1) {
602                                 ERR_print_errors_fp (stderr);
603                                 return STATE_CRITICAL;
604                         }
605                 }
607                 /* send a newline so the server knows we're done with the request */
608                 sprintf (buffer, "\r\n\r\n");
609                 if (SSL_write (ssl, buffer, strlen (buffer)) == -1) {
610                         ERR_print_errors_fp (stderr);
611                         return STATE_CRITICAL;
612                 }
614         }
615         else {
616 #endif
617                 if (my_tcp_connect (server_address, server_port, &sd) != STATE_OK) {
618                         msg = ssprintf (msg, "Unable to open TCP socket");
619                         terminate (STATE_CRITICAL, msg);
620                 }
621                 sprintf (buffer, "%s %s HTTP/1.0\r\n", http_method, server_url);
622                 send (sd, buffer, strlen (buffer), 0);
623                 
626                 /* optionally send the host header info */
627                 if (strcmp (host_name, "")) {
628                         sprintf (buffer, "Host: %s\r\n", host_name);
629                         send (sd, buffer, strlen (buffer), 0);
630                 }
632                 /* send user agent */
633                 sprintf (buffer,
634                          "User-Agent: check_http/%s (nagios-plugins %s)\r\n",
635                          clean_revstring (REVISION), PACKAGE_VERSION);
636                 send (sd, buffer, strlen (buffer), 0);
638                 /* optionally send the authentication info */
639                 if (strcmp (user_auth, "")) {
640                         auth = base64 (user_auth, strlen (user_auth));
641                         sprintf (buffer, "Authorization: Basic %s\r\n", auth);
642                         send (sd, buffer, strlen (buffer), 0);
643                 }
645                 /* optionally send http POST data */
646                 /* written by Chris Henesy <lurker@shadowtech.org> */
647                 if (http_post_data) {
648                         sprintf (buffer, "Content-Type: application/x-www-form-urlencoded\r\n");
649                         send (sd, buffer, strlen (buffer), 0);
650                         sprintf (buffer, "Content-Length: %i\r\n\r\n", strlen (http_post_data));
651                         send (sd, buffer, strlen (buffer), 0);
652                         http_post_data = strscat (http_post_data, "\r\n");
653                         send (sd, http_post_data, strlen (http_post_data), 0);
654                 }
656                 /* send a newline so the server knows we're done with the request */
657                 sprintf (buffer, "\r\n\r\n");
658                 send (sd, buffer, strlen (buffer), 0);
659 #ifdef HAVE_SSL
660         }
661 #endif
663         /* fetch the page */
664         pagesize = (size_t) 0;
665         while ((i = my_recv ()) > 0) {
666                 full_page = strscat (full_page, buffer);
667                 pagesize += i;
668         }
670         if (i < 0)
671                 terminate (STATE_CRITICAL, "Error in recv()");
673         /* return a CRITICAL status if we couldn't read any data */
674         if (pagesize == (size_t) 0)
675                 terminate (STATE_CRITICAL, "No data received %s", timestamp);
677         /* close the connection */
678         my_close ();
680         /* reset the alarm */
681         alarm (0);
683         /* leave full_page untouched so we can free it later */
684         page = full_page;
686         if (verbose)
687                 printf ("Page is %d characters\n", pagesize);
689         /* find status line and null-terminate it */
690         status_line = page;
691         page += (size_t) strcspn (page, "\r\n");
692         pos = page;
693         page += (size_t) strspn (page, "\r\n");
694         status_line[pos - status_line] = 0;
695         strip (status_line);
696         if (verbose)
697                 printf ("STATUS: %s\n", status_line);
699         /* find header info and null terminate it */
700         header = page;
701         while (strcspn (page, "\r\n") > 0) {
702                 page += (size_t) strcspn (page, "\r\n");
703                 pos = page;
704                 if ((strspn (page, "\r") == 1 && strspn (page, "\r\n") >= 2) ||
705                     (strspn (page, "\n") == 1 && strspn (page, "\r\n") >= 2))
706                         page += (size_t) 2;
707                 else
708                         page += (size_t) 1;
709         }
710         page += (size_t) strspn (page, "\r\n");
711         header[pos - header] = 0;
712         if (verbose)
713                 printf ("**** HEADER ****\n%s\n**** CONTENT ****\n%s\n", header, page);
715         /* make sure the status line matches the response we are looking for */
716         if (!strstr (status_line, server_expect)) {
717                 if (server_port == HTTP_PORT)
718                         msg = ssprintf (msg, "Invalid HTTP response received from host\n");
719                 else
720                         msg = ssprintf (msg,
721                                         "Invalid HTTP response received from host on port %d\n",
722                                         server_port);
723                 terminate (STATE_CRITICAL, msg);
724         }
727         /* Exit here if server_expect was set by user and not default */
728         if ( server_expect_yn  )  {
729                 msg = ssprintf (msg, "HTTP OK: Status line output matched \"%s\"\n",
730                           server_expect);
731                 if (verbose)
732                         printf ("%s\n",msg);
734         }
735         else {
736         
738                 /* check the return code */
739                 /* server errors result in a critical state */
740                 if (strstr (status_line, "500") ||
741                   strstr (status_line, "501") ||
742                 strstr (status_line, "502") ||
743                     strstr (status_line, "503")) {
744                         msg = ssprintf (msg, "HTTP CRITICAL: %s\n", status_line);
745                         terminate (STATE_CRITICAL, msg);
746                 }
748                 /* client errors result in a warning state */
749                 if (strstr (status_line, "400") ||
750                   strstr (status_line, "401") ||
751                 strstr (status_line, "402") ||
752                     strstr (status_line, "403") ||
753                     strstr (status_line, "404")) {
754                         msg = ssprintf (msg, "HTTP WARNING: %s\n", status_line);
755                         terminate (STATE_WARNING, msg);
756                 }
758                 /* check redirected page if specified */
759                 if (strstr (status_line, "300") ||
760                   strstr (status_line, "301") ||
761                 strstr (status_line, "302") ||
762                     strstr (status_line, "303") ||
763                     strstr (status_line, "304")) {
764                         if (onredirect == STATE_DEPENDENT) {
765                         
766                                 pos = header;
767                                 while (pos) {
768                                         server_address = realloc (server_address, MAX_IPV4_HOSTLENGTH);
769                                         if (server_address == NULL)
770                                                 terminate (STATE_UNKNOWN,
771                                                                                  "HTTP UNKNOWN: could not allocate server_address");
772                                         if (strspn (pos, "\r\n") > server_url_length) {
773                                                 server_url = realloc (server_url, strspn (pos, "\r\n"));
774                                                 if (server_url == NULL)
775                                                         terminate (STATE_UNKNOWN,
776                                                                                          "HTTP UNKNOWN: could not allocate server_url");
777                                                 server_url_length = strspn (pos, "\r\n");
778                                         }
779                                         if (sscanf (pos, HDR_LOCATION URI_HTTP URI_HOST URI_PORT URI_PATH, server_type, server_address, server_port_text, server_url) == 4) {
780                                                 host_name = strscpy (host_name, server_address);
781                                                 use_ssl = server_type_check (server_type);
782                                                 server_port = atoi (server_port_text);
783                                                 check_http ();
784                                         }
785                                         else if (sscanf (pos, HDR_LOCATION URI_HTTP URI_HOST URI_PATH, server_type, server_address, server_url) == 3 ) { 
786                                                 host_name = strscpy (host_name, server_address);
787                                                 use_ssl = server_type_check (server_type);
788                                                 server_port = server_port_check (use_ssl);
789                                                 check_http ();
790                                         }
791                                         else if (sscanf (pos, HDR_LOCATION URI_HTTP URI_HOST URI_PORT, server_type, server_address, server_port_text) == 3) {
792                                                 host_name = strscpy (host_name, server_address);
793                                                 strcpy (server_url, "/");
794                                                 use_ssl = server_type_check (server_type);
795                                                 server_port = atoi (server_port_text);
796                                                 check_http ();
797                                         }
798                                         else if (sscanf (pos, HDR_LOCATION URI_HTTP URI_HOST, server_type, server_address) == 2) {
799                                                 host_name = strscpy (host_name, server_address);
800                                                 strcpy (server_url, "/");
801                                                 use_ssl = server_type_check (server_type);
802                                                 server_port = server_port_check (use_ssl);
803                                                 check_http ();
804                                         }
805                                         else if (sscanf (pos, HDR_LOCATION URI_PATH, server_url) == 1) {
806                                                 check_http ();
807                                         }       
808                                         pos += (size_t) strcspn (pos, "\r\n");
809                                         pos += (size_t) strspn (pos, "\r\n");
810                                 } /* end while (pos) */
811                                 printf ("HTTP UNKNOWN: Could not find redirect location - %s%s",
812                                         status_line, (display_html ? "</A>" : ""));
813                                 exit (STATE_UNKNOWN);
814                         } /* end if (onredirect == STATE_DEPENDENT) */
815                         
816                         else if (onredirect == STATE_UNKNOWN)
817                                 printf ("HTTP UNKNOWN");
818                         else if (onredirect == STATE_OK)
819                                 printf ("HTTP ok");
820                         else if (onredirect == STATE_WARNING)
821                                 printf ("HTTP WARNING");
822                         else if (onredirect == STATE_CRITICAL)
823                                 printf ("HTTP CRITICAL");
824                         time (&end_time);
825                         msg = ssprintf (msg, ": %s - %d second response time %s%s|time=%d\n",
826                                  status_line, (int) (end_time - start_time), timestamp,
827                            (display_html ? "</A>" : ""), (int) (end_time - start_time));
828                         terminate (onredirect, msg);
829                 } /* end if (strstr (status_line, "30[0-4]") */
832         } /* end else (server_expect_yn)  */
834                 
835         /* check elapsed time */
836         time (&end_time);
837         msg = ssprintf (msg, "HTTP problem: %s - %d second response time %s%s|time=%d\n",
838                        status_line, (int) (end_time - start_time), timestamp,
839                        (display_html ? "</A>" : ""), (int) (end_time - start_time));
840         if (check_critical_time == TRUE && (end_time - start_time) > critical_time)
841                 terminate (STATE_CRITICAL, msg);
842         if (check_warning_time == TRUE && (end_time - start_time) > warning_time)
843                 terminate (STATE_WARNING, msg);
845         /* Page and Header content checks go here */
846         /* these checks should be last */
848         if (strlen (string_expect)) {
849                 if (strstr (page, string_expect)) {
850                         printf ("HTTP ok: %s - %d second response time %s%s|time=%d\n",
851                                 status_line, (int) (end_time - start_time),
852                                 timestamp, (display_html ? "</A>" : ""), (int) (end_time - start_time));
853                         exit (STATE_OK);
854                 }
855                 else {
856                         printf ("HTTP CRITICAL: string not found%s|time=%d\n",
857                                 (display_html ? "</A>" : ""), (int) (end_time - start_time));
858                         exit (STATE_CRITICAL);
859                 }
860         }
861 #ifdef HAVE_REGEX_H
862         if (strlen (regexp)) {
863                 errcode = regexec (&preg, page, REGS, pmatch, 0);
864                 if (errcode == 0) {
865                         printf ("HTTP ok: %s - %d second response time %s%s|time=%d\n",
866                                 status_line, (int) (end_time - start_time),
867                                 timestamp, (display_html ? "</A>" : ""), (int) (end_time - start_time));
868                         exit (STATE_OK);
869                 }
870                 else {
871                         if (errcode == REG_NOMATCH) {
872                                 printf ("HTTP CRITICAL: pattern not found%s|time=%d\n",
873                                         (display_html ? "</A>" : ""), (int) (end_time - start_time));
874                                 exit (STATE_CRITICAL);
875                         }
876                         else {
877                                 regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
878                                 printf ("Execute Error: %s\n", errbuf);
879                                 exit (STATE_CRITICAL);
880                         }
881                 }
882         }
883 #endif
885         /* We only get here if all tests have been passed */
886         msg = ssprintf (msg, "HTTP ok: %s - %d second response time %s%s|time=%d\n",
887                         status_line, (int) (end_time - start_time),
888                         timestamp, (display_html ? "</A>" : ""), (int) (end_time - start_time));
889         terminate (STATE_OK, msg);
890         return STATE_UNKNOWN;
895 #ifdef HAVE_SSL
896 int connect_SSL (void)
898         SSL_METHOD *meth;
900         randbuff = strscpy (NULL, "qwertyuiopasdfghjkl");
901         RAND_seed (randbuff, strlen (randbuff));
902         /* Initialize SSL context */
903         SSLeay_add_ssl_algorithms ();
904         meth = SSLv23_client_method ();
905         SSL_load_error_strings ();
906         if ((ctx = SSL_CTX_new (meth)) == NULL) {
907                 printf ("ERROR: Cannot create SSL context.\n");
908                 return STATE_CRITICAL;
909         }
911         /* Initialize alarm signal handling */
912         signal (SIGALRM, socket_timeout_alarm_handler);
914         /* Set socket timeout */
915         alarm (socket_timeout);
917         /* Save start time */
918         time (&start_time);
920         /* Make TCP connection */
921         if (my_tcp_connect (server_address, server_port, &sd) == STATE_OK) {
922                 /* Do the SSL handshake */
923                 if ((ssl = SSL_new (ctx)) != NULL) {
924                         SSL_set_cipher_list(ssl, "ALL");
925                         SSL_set_fd (ssl, sd);
926                         if (SSL_connect (ssl) != -1)
927                                 return OK;
928                         ERR_print_errors_fp (stderr);
929                 }
930                 else {
931                         printf ("ERROR: Cannot initiate SSL handshake.\n");
932                 }
933                 SSL_free (ssl);
934         }
936         SSL_CTX_free (ctx);
937         close (sd);
939         return STATE_CRITICAL;
941 #endif
943 #ifdef HAVE_SSL
944 int
945 check_certificate (X509 ** certificate)
947         ASN1_STRING *tm;
948         int offset;
949         struct tm stamp;
950         int days_left;
951         /* int result = STATE_OK; */
952         /* char timestamp[14]; */
955         /* Retrieve timestamp of certificate */
956         tm = X509_get_notAfter (*certificate);
958         /* Generate tm structure to process timestamp */
959         if (tm->type == V_ASN1_UTCTIME) {
960                 if (tm->length < 10) {
961                         printf ("ERROR: Wrong time format in certificate.\n");
962                         return STATE_CRITICAL;
963                 }
964                 else {
965                         stamp.tm_year = (tm->data[0] - '0') * 10 + (tm->data[1] - '0');
966                         if (stamp.tm_year < 50)
967                                 stamp.tm_year += 100;
968                         offset = 0;
969                 }
970         }
971         else {
972                 if (tm->length < 12) {
973                         printf ("ERROR: Wrong time format in certificate.\n");
974                         return STATE_CRITICAL;
975                 }
976                 else {
977                         stamp.tm_year =
978                                 (tm->data[0] - '0') * 1000 + (tm->data[1] - '0') * 100 +
979                                 (tm->data[2] - '0') * 10 + (tm->data[3] - '0');
980                         stamp.tm_year -= 1900;
981                         offset = 2;
982                 }
983         }
984         stamp.tm_mon =
985                 (tm->data[2 + offset] - '0') * 10 + (tm->data[3 + offset] - '0') - 1;
986         stamp.tm_mday =
987                 (tm->data[4 + offset] - '0') * 10 + (tm->data[5 + offset] - '0');
988         stamp.tm_hour =
989                 (tm->data[6 + offset] - '0') * 10 + (tm->data[7 + offset] - '0');
990         stamp.tm_min =
991                 (tm->data[8 + offset] - '0') * 10 + (tm->data[9 + offset] - '0');
992         stamp.tm_sec = 0;
993         stamp.tm_isdst = -1;
995         days_left = (mktime (&stamp) - time (NULL)) / 86400;
996         sprintf
997                 (timestamp, "%02d/%02d/%04d %02d:%02d",
998                  stamp.tm_mon + 1,
999                  stamp.tm_mday, stamp.tm_year + 1900, stamp.tm_hour, stamp.tm_min);
1001         if (days_left > 0 && days_left <= days_till_exp) {
1002                 printf ("Certificate expires in %d day(s) (%s).\n", days_left, timestamp);
1003                 return STATE_WARNING;
1004         }
1005         if (days_left < 0) {
1006                 printf ("Certificate expired on %s.\n", timestamp);
1007                 return STATE_CRITICAL;
1008         }
1010         if (days_left == 0) {
1011                 printf ("Certificate expires today (%s).\n", timestamp);
1012                 return STATE_WARNING;
1013         }
1015         printf ("Certificate will expire on %s.\n", timestamp);
1017         return STATE_OK;
1019 #endif
1020 \f
1023 int
1024 my_recv (void)
1026         int i;
1027 #ifdef HAVE_SSL
1028         if (use_ssl) {
1029                 i = SSL_read (ssl, buffer, MAX_INPUT_BUFFER - 1);
1030         }
1031         else {
1032                 i = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
1033         }
1034 #else
1035         i = recv (sd, buffer, MAX_INPUT_BUFFER - 1, 0);
1036 #endif
1037         return i;
1041 int
1042 my_close (void)
1044 #ifdef HAVE_SSL
1045         if (use_ssl == TRUE) {
1046                 SSL_shutdown (ssl);
1047                 SSL_free (ssl);
1048                 SSL_CTX_free (ctx);
1049                 return 0;
1050         }
1051         else {
1052 #endif
1053                 return close (sd);
1054 #ifdef HAVE_SSL
1055         }
1056 #endif
1058 \f
1061 void
1062 print_help (void)
1064         print_revision (PROGNAME, REVISION);
1065         printf
1066                 ("Copyright (c) %s %s <%s>\n\n%s\n",
1067                  COPYRIGHT, AUTHORS, EMAIL, SUMMARY);
1068         print_usage ();
1069         printf ("NOTE: One or both of -H and -I must be specified\n");
1070         printf ("\nOptions:\n" LONGOPTIONS "\n", HTTP_EXPECT, HTTP_PORT,
1071                 DEFAULT_SOCKET_TIMEOUT, SSLOPTIONS);
1072 #ifdef HAVE_SSL
1073         printf (SSLDESCRIPTION);
1074 #endif
1078 void
1079 print_usage (void)
1081         printf ("Usage:\n" " %s %s\n"
1082 #ifdef HAVE_GETOPT_H
1083                 " %s (-h | --help) for detailed help\n"
1084                 " %s (-V | --version) for version information\n",
1085 #else
1086                 " %s -h for detailed help\n"
1087                 " %s -V for version information\n",
1088 #endif
1089         PROGNAME, OPTIONS, PROGNAME, PROGNAME);