plugins/check_http.c

   1 /*****************************************************************************
   2 *
   3 * Nagios check_http plugin
   4 *
   5 * License: GPL
   6 * Copyright (c) 1999-2008 Nagios Plugins Development Team
   7 *
   8 * Last Modified: $Date$
   9 *
  10 * Description:
  11 *
  12 * This file contains the check_http plugin
  13 *
  14 * This plugin tests the HTTP service on the specified host. It can test
  15 * normal (http) and secure (https) servers, follow redirects, search for
  16 * strings and regular expressions, check connection times, and report on
  17 * certificate expiration times.
  18 *
  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 * $Id$
  34 *
  35 *****************************************************************************/
  36
  37 /* splint -I. -I../../plugins -I../../lib/ -I/usr/kerberos/include/ ../../plugins/check_http.c */
  38
  39 const char *progname = "check_http";
  40 const char *revision = "$Revision$";
  41 const char *copyright = "1999-2008";
  42 const char *email = "nagiosplug-devel@lists.sourceforge.net";
  43
  44 #include "common.h"
  45 #include "netutils.h"
  46 #include "utils.h"
  47 #include "base64.h"
  48 #include <ctype.h>
  49
  50 #define INPUT_DELIMITER ";"
  51
  52 #define HTTP_EXPECT "HTTP/1."
  53 enum {
  54   MAX_IPV4_HOSTLENGTH = 255,
  55   HTTP_PORT = 80,
  56   HTTPS_PORT = 443,
  57   MAX_PORT = 65535
  58 };
  59
  60 #ifdef HAVE_SSL
  61 int check_cert = FALSE;
  62 int days_till_exp;
  63 char *randbuff;
  64 X509 *server_cert;
  65 #  define my_recv(buf, len) ((use_ssl) ? np_net_ssl_read(buf, len) : read(sd, buf, len))
  66 #  define my_send(buf, len) ((use_ssl) ? np_net_ssl_write(buf, len) : send(sd, buf, len, 0))
  67 #else /* ifndef HAVE_SSL */
  68 #  define my_recv(buf, len) read(sd, buf, len)
  69 #  define my_send(buf, len) send(sd, buf, len, 0)
  70 #endif /* HAVE_SSL */
  71 int no_body = FALSE;
  72 int maximum_age = -1;
  73
  74 enum {
  75   REGS = 2,
  76   MAX_RE_SIZE = 256
  77 };
  78 #include "regex.h"
  79 regex_t preg;
  80 regmatch_t pmatch[REGS];
  81 char regexp[MAX_RE_SIZE];
  82 char errbuf[MAX_INPUT_BUFFER];
  83 int cflags = REG_NOSUB | REG_EXTENDED | REG_NEWLINE;
  84 int errcode;
  85 int invert_regex = 0;
  86
  87 struct timeval tv;
  88
  89 #define HTTP_URL "/"
  90 #define CRLF "\r\n"
  91
  92 int specify_port = FALSE;
  93 int server_port = HTTP_PORT;
  94 char server_port_text[6] = "";
  95 char server_type[6] = "http";
  96 char *server_address;
  97 char *host_name;
  98 char *server_url;
  99 char *user_agent;
 100 int server_url_length;
 101 int server_expect_yn = 0;
 102 char server_expect[MAX_INPUT_BUFFER] = HTTP_EXPECT;
 103 char string_expect[MAX_INPUT_BUFFER] = "";
 104 double warning_time = 0;
 105 int check_warning_time = FALSE;
 106 double critical_time = 0;
 107 int check_critical_time = FALSE;
 108 char user_auth[MAX_INPUT_BUFFER] = "";
 109 int display_html = FALSE;
 110 char **http_opt_headers;
 111 int http_opt_headers_count = 0;
 112 int onredirect = STATE_OK;
 113 int use_ssl = FALSE;
 114 int verbose = FALSE;
 115 int sd;
 116 int min_page_len = 0;
 117 int max_page_len = 0;
 118 int redir_depth = 0;
 119 int max_depth = 15;
 120 char *http_method;
 121 char *http_post_data;
 122 char *http_content_type;
 123 char buffer[MAX_INPUT_BUFFER];
 124
 125 int process_arguments (int, char **);
 126 int check_http (void);
 127 void redir (char *pos, char *status_line);
 128 int server_type_check(const char *type);
 129 int server_port_check(int ssl_flag);
 130 char *perfd_time (double microsec);
 131 char *perfd_size (int page_len);
 132 void print_help (void);
 133 void print_usage (void);
 134
 135 int
 136 main (int argc, char **argv)
 137 {
 138   int result = STATE_UNKNOWN;
 139
 140         setlocale (LC_ALL, "");
 141         bindtextdomain (PACKAGE, LOCALEDIR);
 142         textdomain (PACKAGE);
 143
 144   /* Set default URL. Must be malloced for subsequent realloc if --onredirect=follow */
 145   server_url = strdup(HTTP_URL);
 146   server_url_length = strlen(server_url);
 147   asprintf (&user_agent, "User-Agent: check_http/%s (nagios-plugins %s)",
 148             clean_revstring (revision), VERSION);
 149
 150         /* Parse extra opts if any */
 151         argv=np_extra_opts (&argc, argv, progname);
 152
 153   if (process_arguments (argc, argv) == ERROR)
 154     usage4 (_("Could not parse arguments"));
 155
 156   if (display_html == TRUE)
 157     printf ("<A HREF=\"%s://%s:%d%s\" target=\"_blank\">",
 158       use_ssl ? "https" : "http", host_name ? host_name : server_address,
 159       server_port, server_url);
 160
 161   /* initialize alarm signal handling, set socket timeout, start timer */
 162   (void) signal (SIGALRM, socket_timeout_alarm_handler);
 163   (void) alarm (socket_timeout);
 164   gettimeofday (&tv, NULL);
 165
 166   result = check_http ();
 167   return result;
 168 }
 169
 170
 171
 172 /* process command-line arguments */
 173 int
 174 process_arguments (int argc, char **argv)
 175 {
 176   int c = 1;
 177   char *p;
 178
 179   enum {
 180     INVERT_REGEX = CHAR_MAX + 1
 181   };
 182
 183   int option = 0;
 184   static struct option longopts[] = {
 185     STD_LONG_OPTS,
 186     {"link", no_argument, 0, 'L'},
 187     {"nohtml", no_argument, 0, 'n'},
 188     {"ssl", no_argument, 0, 'S'},
 189     {"post", required_argument, 0, 'P'},
 190     {"IP-address", required_argument, 0, 'I'},
 191     {"url", required_argument, 0, 'u'},
 192     {"port", required_argument, 0, 'p'},
 193     {"authorization", required_argument, 0, 'a'},
 194     {"string", required_argument, 0, 's'},
 195     {"expect", required_argument, 0, 'e'},
 196     {"regex", required_argument, 0, 'r'},
 197     {"ereg", required_argument, 0, 'r'},
 198     {"eregi", required_argument, 0, 'R'},
 199     {"linespan", no_argument, 0, 'l'},
 200     {"onredirect", required_argument, 0, 'f'},
 201     {"certificate", required_argument, 0, 'C'},
 202     {"useragent", required_argument, 0, 'A'},
 203     {"header", required_argument, 0, 'k'},
 204     {"no-body", no_argument, 0, 'N'},
 205     {"max-age", required_argument, 0, 'M'},
 206     {"content-type", required_argument, 0, 'T'},
 207     {"pagesize", required_argument, 0, 'm'},
 208     {"invert-regex", no_argument, NULL, INVERT_REGEX},
 209     {"use-ipv4", no_argument, 0, '4'},
 210     {"use-ipv6", no_argument, 0, '6'},
 211     {0, 0, 0, 0}
 212   };
 213
 214   if (argc < 2)
 215     return ERROR;
 216
 217   for (c = 1; c < argc; c++) {
 218     if (strcmp ("-to", argv[c]) == 0)
 219       strcpy (argv[c], "-t");
 220     if (strcmp ("-hn", argv[c]) == 0)
 221       strcpy (argv[c], "-H");
 222     if (strcmp ("-wt", argv[c]) == 0)
 223       strcpy (argv[c], "-w");
 224     if (strcmp ("-ct", argv[c]) == 0)
 225       strcpy (argv[c], "-c");
 226     if (strcmp ("-nohtml", argv[c]) == 0)
 227       strcpy (argv[c], "-n");
 228   }
 229
 230   while (1) {
 231     c = getopt_long (argc, argv, "Vvh46t:c:w:A:k:H:P:T:I:a:e:p:s:R:r:u:f:C:nlLSm:M:N", longopts, &option);
 232     if (c == -1 || c == EOF)
 233       break;
 234
 235     switch (c) {
 236     case '?': /* usage */
 237       usage5 ();
 238       break;
 239     case 'h': /* help */
 240       print_help ();
 241       exit (STATE_OK);
 242       break;
 243     case 'V': /* version */
 244       print_revision (progname, revision);
 245       exit (STATE_OK);
 246       break;
 247     case 't': /* timeout period */
 248       if (!is_intnonneg (optarg))
 249         usage2 (_("Timeout interval must be a positive integer"), optarg);
 250       else
 251         socket_timeout = atoi (optarg);
 252       break;
 253     case 'c': /* critical time threshold */
 254       if (!is_nonnegative (optarg))
 255         usage2 (_("Critical threshold must be integer"), optarg);
 256       else {
 257         critical_time = strtod (optarg, NULL);
 258         check_critical_time = TRUE;
 259       }
 260       break;
 261     case 'w': /* warning time threshold */
 262       if (!is_nonnegative (optarg))
 263         usage2 (_("Warning threshold must be integer"), optarg);
 264       else {
 265         warning_time = strtod (optarg, NULL);
 266         check_warning_time = TRUE;
 267       }
 268       break;
 269     case 'A': /* User Agent String */
 270       asprintf (&user_agent, "User-Agent: %s", optarg);
 271       break;
 272     case 'k': /* Additional headers */
 273       if (http_opt_headers_count == 0)
 274         http_opt_headers = malloc (sizeof (char *) * (++http_opt_headers_count));
 275       else
 276         http_opt_headers = realloc (http_opt_headers, sizeof (char *) * (++http_opt_headers_count));
 277       http_opt_headers[http_opt_headers_count - 1] = optarg;
 278       /* asprintf (&http_opt_headers, "%s", optarg); */
 279       break;
 280     case 'L': /* show html link */
 281       display_html = TRUE;
 282       break;
 283     case 'n': /* do not show html link */
 284       display_html = FALSE;
 285       break;
 286     case 'C': /* Check SSL cert validity */
 287 #ifdef HAVE_SSL
 288       if (!is_intnonneg (optarg))
 289         usage2 (_("Invalid certificate expiration period"), optarg);
 290       else {
 291         days_till_exp = atoi (optarg);
 292         check_cert = TRUE;
 293       }
 294      /* Fall through to -S option */
 295 #endif
 296     case 'S': /* use SSL */
 297 #ifndef HAVE_SSL
 298       usage4 (_("Invalid option - SSL is not available"));
 299 #endif
 300       use_ssl = TRUE;
 301       if (specify_port == FALSE)
 302         server_port = HTTPS_PORT;
 303       break;
 304     case 'f': /* onredirect */
 305       if (!strcmp (optarg, "follow"))
 306         onredirect = STATE_DEPENDENT;
 307       if (!strcmp (optarg, "unknown"))
 308         onredirect = STATE_UNKNOWN;
 309       if (!strcmp (optarg, "ok"))
 310         onredirect = STATE_OK;
 311       if (!strcmp (optarg, "warning"))
 312         onredirect = STATE_WARNING;
 313       if (!strcmp (optarg, "critical"))
 314         onredirect = STATE_CRITICAL;
 315       if (verbose)
 316         printf(_("option f:%d \n"), onredirect);
 317       break;
 318     /* Note: H, I, and u must be malloc'd or will fail on redirects */
 319     case 'H': /* Host Name (virtual host) */
 320       host_name = strdup (optarg);
 321       if (host_name[0] == '[') {
 322         if ((p = strstr (host_name, "]:")) != NULL) /* [IPv6]:port */
 323           server_port = atoi (p + 2);
 324       } else if ((p = strchr (host_name, ':')) != NULL
 325                  && strchr (++p, ':') == NULL) /* IPv4:port or host:port */
 326           server_port = atoi (p);
 327       break;
 328     case 'I': /* Server IP-address */
 329       server_address = strdup (optarg);
 330       break;
 331     case 'u': /* URL path */
 332       server_url = strdup (optarg);
 333       server_url_length = strlen (server_url);
 334       break;
 335     case 'p': /* Server port */
 336       if (!is_intnonneg (optarg))
 337         usage2 (_("Invalid port number"), optarg);
 338       else {
 339         server_port = atoi (optarg);
 340         specify_port = TRUE;
 341       }
 342       break;
 343     case 'a': /* authorization info */
 344       strncpy (user_auth, optarg, MAX_INPUT_BUFFER - 1);
 345       user_auth[MAX_INPUT_BUFFER - 1] = 0;
 346       break;
 347     case 'P': /* HTTP POST data in URL encoded format */
 348       if (http_method || http_post_data) break;
 349       http_method = strdup("POST");
 350       http_post_data = strdup (optarg);
 351       break;
 352     case 's': /* string or substring */
 353       strncpy (string_expect, optarg, MAX_INPUT_BUFFER - 1);
 354       string_expect[MAX_INPUT_BUFFER - 1] = 0;
 355       break;
 356     case 'e': /* string or substring */
 357       strncpy (server_expect, optarg, MAX_INPUT_BUFFER - 1);
 358       server_expect[MAX_INPUT_BUFFER - 1] = 0;
 359       server_expect_yn = 1;
 360       break;
 361     case 'T': /* Content-type */
 362       asprintf (&http_content_type, "%s", optarg);
 363       break;
 364     case 'l': /* linespan */
 365       cflags &= ~REG_NEWLINE;
 366       break;
 367     case 'R': /* regex */
 368       cflags |= REG_ICASE;
 369     case 'r': /* regex */
 370       strncpy (regexp, optarg, MAX_RE_SIZE - 1);
 371       regexp[MAX_RE_SIZE - 1] = 0;
 372       errcode = regcomp (&preg, regexp, cflags);
 373       if (errcode != 0) {
 374         (void) regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
 375         printf (_("Could Not Compile Regular Expression: %s"), errbuf);
 376         return ERROR;
 377       }
 378       break;
 379     case INVERT_REGEX:
 380       invert_regex = 1;
 381       break;
 382     case '4':
 383       address_family = AF_INET;
 384       break;
 385     case '6':
 386 #ifdef USE_IPV6
 387       address_family = AF_INET6;
 388 #else
 389       usage4 (_("IPv6 support not available"));
 390 #endif
 391       break;
 392     case 'v': /* verbose */
 393       verbose = TRUE;
 394       break;
 395     case 'm': /* min_page_length */
 396       {
 397       char *tmp;
 398       if (strchr(optarg, ':') != (char *)NULL) {
 399         /* range, so get two values, min:max */
 400         tmp = strtok(optarg, ":");
 401         if (tmp == NULL) {
 402           printf("Bad format: try \"-m min:max\"\n");
 403           exit (STATE_WARNING);
 404         } else
 405           min_page_len = atoi(tmp);
 406
 407         tmp = strtok(NULL, ":");
 408         if (tmp == NULL) {
 409           printf("Bad format: try \"-m min:max\"\n");
 410           exit (STATE_WARNING);
 411         } else
 412           max_page_len = atoi(tmp);
 413       } else
 414         min_page_len = atoi (optarg);
 415       break;
 416       }
 417     case 'N': /* no-body */
 418       no_body = TRUE;
 419       break;
 420     case 'M': /* max-age */
 421                   {
 422                     int L = strlen(optarg);
 423                     if (L && optarg[L-1] == 'm')
 424                       maximum_age = atoi (optarg) * 60;
 425                     else if (L && optarg[L-1] == 'h')
 426                       maximum_age = atoi (optarg) * 60 * 60;
 427                     else if (L && optarg[L-1] == 'd')
 428                       maximum_age = atoi (optarg) * 60 * 60 * 24;
 429                     else if (L && (optarg[L-1] == 's' ||
 430                                    isdigit (optarg[L-1])))
 431                       maximum_age = atoi (optarg);
 432                     else {
 433                       fprintf (stderr, "unparsable max-age: %s\n", optarg);
 434                       exit (STATE_WARNING);
 435                     }
 436                   }
 437                   break;
 438     }
 439   }
 440
 441   c = optind;
 442
 443   if (server_address == NULL && c < argc)
 444     server_address = strdup (argv[c++]);
 445
 446   if (host_name == NULL && c < argc)
 447     host_name = strdup (argv[c++]);
 448
 449   if (server_address == NULL) {
 450     if (host_name == NULL)
 451       usage4 (_("You must specify a server address or host name"));
 452     else
 453       server_address = strdup (host_name);
 454   }
 455
 456   if (check_critical_time && critical_time>(double)socket_timeout)
 457     socket_timeout = (int)critical_time + 1;
 458
 459   if (http_method == NULL)
 460     http_method = strdup ("GET");
 461
 462   return TRUE;
 463 }
 464
 465
 466
 467 /* Returns 1 if we're done processing the document body; 0 to keep going */
 468 static int
 469 document_headers_done (char *full_page)
 470 {
 471   const char *body;
 472
 473   for (body = full_page; *body; body++) {
 474     if (!strncmp (body, "\n\n", 2) || !strncmp (body, "\n\r\n", 3))
 475       break;
 476   }
 477
 478   if (!*body)
 479     return 0;  /* haven't read end of headers yet */
 480
 481   full_page[body - full_page] = 0;
 482   return 1;
 483 }
 484
 485 static time_t
 486 parse_time_string (const char *string)
 487 {
 488   struct tm tm;
 489   time_t t;
 490   memset (&tm, 0, sizeof(tm));
 491
 492   /* Like this: Tue, 25 Dec 2001 02:59:03 GMT */
 493
 494   if (isupper (string[0])  &&  /* Tue */
 495     islower (string[1])  &&
 496     islower (string[2])  &&
 497     ',' ==   string[3]   &&
 498     ' ' ==   string[4]   &&
 499     (isdigit(string[5]) || string[5] == ' ') &&   /* 25 */
 500     isdigit (string[6])  &&
 501     ' ' ==   string[7]   &&
 502     isupper (string[8])  &&  /* Dec */
 503     islower (string[9])  &&
 504     islower (string[10]) &&
 505     ' ' ==   string[11]  &&
 506     isdigit (string[12]) &&  /* 2001 */
 507     isdigit (string[13]) &&
 508     isdigit (string[14]) &&
 509     isdigit (string[15]) &&
 510     ' ' ==   string[16]  &&
 511     isdigit (string[17]) &&  /* 02: */
 512     isdigit (string[18]) &&
 513     ':' ==   string[19]  &&
 514     isdigit (string[20]) &&  /* 59: */
 515     isdigit (string[21]) &&
 516     ':' ==   string[22]  &&
 517     isdigit (string[23]) &&  /* 03 */
 518     isdigit (string[24]) &&
 519     ' ' ==   string[25]  &&
 520     'G' ==   string[26]  &&  /* GMT */
 521     'M' ==   string[27]  &&  /* GMT */
 522     'T' ==   string[28]) {
 523
 524     tm.tm_sec  = 10 * (string[23]-'0') + (string[24]-'0');
 525     tm.tm_min  = 10 * (string[20]-'0') + (string[21]-'0');
 526     tm.tm_hour = 10 * (string[17]-'0') + (string[18]-'0');
 527     tm.tm_mday = 10 * (string[5] == ' ' ? 0 : string[5]-'0') + (string[6]-'0');
 528     tm.tm_mon = (!strncmp (string+8, "Jan", 3) ? 0 :
 529       !strncmp (string+8, "Feb", 3) ? 1 :
 530       !strncmp (string+8, "Mar", 3) ? 2 :
 531       !strncmp (string+8, "Apr", 3) ? 3 :
 532       !strncmp (string+8, "May", 3) ? 4 :
 533       !strncmp (string+8, "Jun", 3) ? 5 :
 534       !strncmp (string+8, "Jul", 3) ? 6 :
 535       !strncmp (string+8, "Aug", 3) ? 7 :
 536       !strncmp (string+8, "Sep", 3) ? 8 :
 537       !strncmp (string+8, "Oct", 3) ? 9 :
 538       !strncmp (string+8, "Nov", 3) ? 10 :
 539       !strncmp (string+8, "Dec", 3) ? 11 :
 540       -1);
 541     tm.tm_year = ((1000 * (string[12]-'0') +
 542       100 * (string[13]-'0') +
 543       10 * (string[14]-'0') +
 544       (string[15]-'0'))
 545       - 1900);
 546
 547     tm.tm_isdst = 0;  /* GMT is never in DST, right? */
 548
 549     if (tm.tm_mon < 0 || tm.tm_mday < 1 || tm.tm_mday > 31)
 550       return 0;
 551
 552     /*
 553     This is actually wrong: we need to subtract the local timezone
 554     offset from GMT from this value.  But, that's ok in this usage,
 555     because we only comparing these two GMT dates against each other,
 556     so it doesn't matter what time zone we parse them in.
 557     */
 558
 559     t = mktime (&tm);
 560     if (t == (time_t) -1) t = 0;
 561
 562     if (verbose) {
 563       const char *s = string;
 564       while (*s && *s != '\r' && *s != '\n')
 565       fputc (*s++, stdout);
 566       printf (" ==> %lu\n", (unsigned long) t);
 567     }
 568
 569     return t;
 570
 571   } else {
 572     return 0;
 573   }
 574 }
 575
 576
 577
 578 static void
 579 check_document_dates (const char *headers)
 580 {
 581   const char *s;
 582   char *server_date = 0;
 583   char *document_date = 0;
 584
 585   s = headers;
 586   while (*s) {
 587     const char *field = s;
 588     const char *value = 0;
 589
 590     /* Find the end of the header field */
 591     while (*s && !isspace(*s) && *s != ':')
 592       s++;
 593
 594     /* Remember the header value, if any. */
 595     if (*s == ':')
 596       value = ++s;
 597
 598     /* Skip to the end of the header, including continuation lines. */
 599     while (*s && !(*s == '\n' && (s[1] != ' ' && s[1] != '\t')))
 600       s++;
 601
 602     /* Avoid stepping over end-of-string marker */
 603     if (*s)
 604       s++;
 605
 606     /* Process this header. */
 607     if (value && value > field+2) {
 608       char *ff = (char *) malloc (value-field);
 609       char *ss = ff;
 610       while (field < value-1)
 611         *ss++ = tolower(*field++);
 612       *ss++ = 0;
 613
 614       if (!strcmp (ff, "date") || !strcmp (ff, "last-modified")) {
 615         const char *e;
 616         while (*value && isspace (*value))
 617           value++;
 618         for (e = value; *e && *e != '\r' && *e != '\n'; e++)
 619           ;
 620         ss = (char *) malloc (e - value + 1);
 621         strncpy (ss, value, e - value);
 622         ss[e - value] = 0;
 623         if (!strcmp (ff, "date")) {
 624           if (server_date) free (server_date);
 625           server_date = ss;
 626         } else {
 627           if (document_date) free (document_date);
 628           document_date = ss;
 629         }
 630       }
 631       free (ff);
 632     }
 633   }
 634
 635   /* Done parsing the body.  Now check the dates we (hopefully) parsed.  */
 636   if (!server_date || !*server_date) {
 637     die (STATE_UNKNOWN, _("HTTP UNKNOWN - Server date unknown\n"));
 638   } else if (!document_date || !*document_date) {
 639     die (STATE_CRITICAL, _("HTTP CRITICAL - Document modification date unknown\n"));
 640   } else {
 641     time_t srv_data = parse_time_string (server_date);
 642     time_t doc_data = parse_time_string (document_date);
 643
 644     if (srv_data <= 0) {
 645       die (STATE_CRITICAL, _("HTTP CRITICAL - Server date \"%100s\" unparsable"), server_date);
 646     } else if (doc_data <= 0) {
 647       die (STATE_CRITICAL, _("HTTP CRITICAL - Document date \"%100s\" unparsable"), document_date);
 648     } else if (doc_data > srv_data + 30) {
 649       die (STATE_CRITICAL, _("HTTP CRITICAL - Document is %d seconds in the future\n"), (int)doc_data - (int)srv_data);
 650     } else if (doc_data < srv_data - maximum_age) {
 651     int n = (srv_data - doc_data);
 652     if (n > (60 * 60 * 24 * 2))
 653       die (STATE_CRITICAL,
 654         _("HTTP CRITICAL - Last modified %.1f days ago\n"),
 655         ((float) n) / (60 * 60 * 24));
 656   else
 657     die (STATE_CRITICAL,
 658         _("HTTP CRITICAL - Last modified %d:%02d:%02d ago\n"),
 659         n / (60 * 60), (n / 60) % 60, n % 60);
 660     }
 661
 662     free (server_date);
 663     free (document_date);
 664   }
 665 }
 666
 667 int
 668 get_content_length (const char *headers)
 669 {
 670   const char *s;
 671   int content_length = 0;
 672
 673   s = headers;
 674   while (*s) {
 675     const char *field = s;
 676     const char *value = 0;
 677
 678     /* Find the end of the header field */
 679     while (*s && !isspace(*s) && *s != ':')
 680       s++;
 681
 682     /* Remember the header value, if any. */
 683     if (*s == ':')
 684       value = ++s;
 685
 686     /* Skip to the end of the header, including continuation lines. */
 687     while (*s && !(*s == '\n' && (s[1] != ' ' && s[1] != '\t')))
 688       s++;
 689     s++;
 690
 691     /* Process this header. */
 692     if (value && value > field+2) {
 693       char *ff = (char *) malloc (value-field);
 694       char *ss = ff;
 695       while (field < value-1)
 696         *ss++ = tolower(*field++);
 697       *ss++ = 0;
 698
 699       if (!strcmp (ff, "content-length")) {
 700         const char *e;
 701         while (*value && isspace (*value))
 702           value++;
 703         for (e = value; *e && *e != '\r' && *e != '\n'; e++)
 704           ;
 705         ss = (char *) malloc (e - value + 1);
 706         strncpy (ss, value, e - value);
 707         ss[e - value] = 0;
 708         content_length = atoi(ss);
 709         free (ss);
 710       }
 711       free (ff);
 712     }
 713   }
 714   return (content_length);
 715 }
 716
 717 int
 718 check_http (void)
 719 {
 720   char *msg;
 721   char *status_line;
 722   char *status_code;
 723   char *header;
 724   char *page;
 725   char *auth;
 726   int http_status;
 727   int i = 0;
 728   size_t pagesize = 0;
 729   char *full_page;
 730   char *buf;
 731   char *pos;
 732   long microsec;
 733   double elapsed_time;
 734   int page_len = 0;
 735   int result = STATE_UNKNOWN;
 736
 737   /* try to connect to the host at the given port number */
 738   if (my_tcp_connect (server_address, server_port, &sd) != STATE_OK)
 739     die (STATE_CRITICAL, _("HTTP CRITICAL - Unable to open TCP socket\n"));
 740 #ifdef HAVE_SSL
 741   if (use_ssl == TRUE) {
 742     np_net_ssl_init(sd);
 743     if (check_cert == TRUE) {
 744       result = np_net_ssl_check_cert(days_till_exp);
 745       np_net_ssl_cleanup();
 746       if (sd) close(sd);
 747       return result;
 748     }
 749   }
 750 #endif /* HAVE_SSL */
 751
 752   /* If a hostname is provided, use HTTP/1.1 and send the hostname before the
 753   *  Useragent. This fixes an issue with getting 301 responses from servers
 754   *  with virtual hosts */
 755   if (host_name)
 756     asprintf (&buf, "%s %s HTTP/1.1\r\nHost: %s\r\n%s\r\n", http_method, server_url, host_name, user_agent);
 757   else
 758     asprintf (&buf, "%s %s HTTP/1.0\r\n%s\r\n", http_method, server_url, user_agent);
 759
 760   /* tell HTTP/1.1 servers not to keep the connection alive */
 761   asprintf (&buf, "%sConnection: close\r\n", buf);
 762
 763   /* optionally send any other header tag */
 764   if (http_opt_headers_count) {
 765     for (i = 0; i < http_opt_headers_count ; i++) {
 766       for ((pos = strtok(http_opt_headers[i], INPUT_DELIMITER)); pos; (pos = strtok(NULL, INPUT_DELIMITER)))
 767         asprintf (&buf, "%s%s\r\n", buf, pos);
 768     }
 769     free(http_opt_headers);
 770   }
 771
 772   /* optionally send the authentication info */
 773   if (strlen(user_auth)) {
 774     base64_encode_alloc (user_auth, strlen (user_auth), &auth);
 775     asprintf (&buf, "%sAuthorization: Basic %s\r\n", buf, auth);
 776   }
 777
 778   /* either send http POST data */
 779   if (http_post_data) {
 780     if (http_content_type) {
 781       asprintf (&buf, "%sContent-Type: %s\r\n", buf, http_content_type);
 782     } else {
 783       asprintf (&buf, "%sContent-Type: application/x-www-form-urlencoded\r\n", buf);
 784     }
 785
 786     asprintf (&buf, "%sContent-Length: %i\r\n\r\n", buf, (int)strlen (http_post_data));
 787     asprintf (&buf, "%s%s%s", buf, http_post_data, CRLF);
 788   }
 789   else {
 790     /* or just a newline so the server knows we're done with the request */
 791     asprintf (&buf, "%s%s", buf, CRLF);
 792   }
 793
 794   if (verbose) printf ("%s\n", buf);
 795   my_send (buf, strlen (buf));
 796
 797   /* fetch the page */
 798   full_page = strdup("");
 799   while ((i = my_recv (buffer, MAX_INPUT_BUFFER-1)) > 0) {
 800     buffer[i] = '\0';
 801     asprintf (&full_page, "%s%s", full_page, buffer);
 802     pagesize += i;
 803
 804                 if (no_body && document_headers_done (full_page)) {
 805                   i = 0;
 806                   break;
 807                 }
 808   }
 809
 810   if (i < 0 && errno != ECONNRESET) {
 811 #ifdef HAVE_SSL
 812     /*
 813     if (use_ssl) {
 814       sslerr=SSL_get_error(ssl, i);
 815       if ( sslerr == SSL_ERROR_SSL ) {
 816         die (STATE_WARNING, _("HTTP WARNING - Client Certificate Required\n"));
 817       } else {
 818         die (STATE_CRITICAL, _("HTTP CRITICAL - Error on receive\n"));
 819       }
 820     }
 821     else {
 822     */
 823 #endif
 824       die (STATE_CRITICAL, _("HTTP CRITICAL - Error on receive\n"));
 825 #ifdef HAVE_SSL
 826       /* XXX
 827     }
 828     */
 829 #endif
 830   }
 831
 832   /* return a CRITICAL status if we couldn't read any data */
 833   if (pagesize == (size_t) 0)
 834     die (STATE_CRITICAL, _("HTTP CRITICAL - No data received from host\n"));
 835
 836   /* close the connection */
 837 #ifdef HAVE_SSL
 838   np_net_ssl_cleanup();
 839 #endif
 840   if (sd) close(sd);
 841
 842   /* reset the alarm */
 843   alarm (0);
 844
 845   /* leave full_page untouched so we can free it later */
 846   page = full_page;
 847
 848   if (verbose)
 849     printf ("%s://%s:%d%s is %d characters\n",
 850       use_ssl ? "https" : "http", server_address,
 851       server_port, server_url, (int)pagesize);
 852
 853   /* find status line and null-terminate it */
 854   status_line = page;
 855   page += (size_t) strcspn (page, "\r\n");
 856   pos = page;
 857   page += (size_t) strspn (page, "\r\n");
 858   status_line[strcspn(status_line, "\r\n")] = 0;
 859   strip (status_line);
 860   if (verbose)
 861     printf ("STATUS: %s\n", status_line);
 862
 863   /* find header info and null-terminate it */
 864   header = page;
 865   while (strcspn (page, "\r\n") > 0) {
 866     page += (size_t) strcspn (page, "\r\n");
 867     pos = page;
 868     if ((strspn (page, "\r") == 1 && strspn (page, "\r\n") >= 2) ||
 869         (strspn (page, "\n") == 1 && strspn (page, "\r\n") >= 2))
 870       page += (size_t) 2;
 871     else
 872       page += (size_t) 1;
 873   }
 874   page += (size_t) strspn (page, "\r\n");
 875   header[pos - header] = 0;
 876   if (verbose)
 877     printf ("**** HEADER ****\n%s\n**** CONTENT ****\n%s\n", header,
 878                 (no_body ? "  [[ skipped ]]" : page));
 879
 880   /* make sure the status line matches the response we are looking for */
 881   if (!strstr (status_line, server_expect)) {
 882     if (server_port == HTTP_PORT)
 883       asprintf (&msg,
 884                 _("Invalid HTTP response received from host\n"));
 885     else
 886       asprintf (&msg,
 887                 _("Invalid HTTP response received from host on port %d\n"),
 888                 server_port);
 889     die (STATE_CRITICAL, "HTTP CRITICAL - %s", msg);
 890   }
 891
 892   /* Exit here if server_expect was set by user and not default */
 893   if ( server_expect_yn  )  {
 894     asprintf (&msg,
 895               _("HTTP OK: Status line output matched \"%s\"\n"),
 896               server_expect);
 897     if (verbose)
 898       printf ("%s\n",msg);
 899   }
 900   else {
 901     /* Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF */
 902     /* HTTP-Version   = "HTTP" "/" 1*DIGIT "." 1*DIGIT */
 903     /* Status-Code = 3 DIGITS */
 904
 905     status_code = strchr (status_line, ' ') + sizeof (char);
 906     if (strspn (status_code, "1234567890") != 3)
 907       die (STATE_CRITICAL, _("HTTP CRITICAL: Invalid Status Line (%s)\n"), status_line);
 908
 909     http_status = atoi (status_code);
 910
 911     /* check the return code */
 912
 913     if (http_status >= 600 || http_status < 100)
 914       die (STATE_CRITICAL, _("HTTP CRITICAL: Invalid Status (%s)\n"), status_line);
 915
 916     /* server errors result in a critical state */
 917     else if (http_status >= 500)
 918       die (STATE_CRITICAL, _("HTTP CRITICAL: %s\n"), status_line);
 919
 920     /* client errors result in a warning state */
 921     else if (http_status >= 400)
 922       die (STATE_WARNING, _("HTTP WARNING: %s\n"), status_line);
 923
 924     /* check redirected page if specified */
 925     else if (http_status >= 300) {
 926
 927       if (onredirect == STATE_DEPENDENT)
 928         redir (header, status_line);
 929       else if (onredirect == STATE_UNKNOWN)
 930         printf (_("HTTP UNKNOWN"));
 931       else if (onredirect == STATE_OK)
 932         printf (_("HTTP OK"));
 933       else if (onredirect == STATE_WARNING)
 934         printf (_("HTTP WARNING"));
 935       else if (onredirect == STATE_CRITICAL)
 936         printf (_("HTTP CRITICAL"));
 937       microsec = deltime (tv);
 938       elapsed_time = (double)microsec / 1.0e6;
 939       die (onredirect,
 940            _(" - %s - %.3f second response time %s|%s %s\n"),
 941            status_line, elapsed_time,
 942            (display_html ? "</A>" : ""),
 943            perfd_time (elapsed_time), perfd_size (pagesize));
 944     } /* end if (http_status >= 300) */
 945
 946   } /* end else (server_expect_yn)  */
 947
 948         if (maximum_age >= 0) {
 949           check_document_dates (header);
 950         }
 951
 952   /* check elapsed time */
 953   microsec = deltime (tv);
 954   elapsed_time = (double)microsec / 1.0e6;
 955   asprintf (&msg,
 956             _(" - %s - %.3f second response time %s|%s %s\n"),
 957             status_line, elapsed_time,
 958             (display_html ? "</A>" : ""),
 959             perfd_time (elapsed_time), perfd_size (pagesize));
 960   if (check_critical_time == TRUE && elapsed_time > critical_time)
 961     die (STATE_CRITICAL, "HTTP %s: %s", _("CRITICAL"), msg);
 962   if (check_warning_time == TRUE && elapsed_time > warning_time)
 963     die (STATE_WARNING, "HTTP %s: %s", _("WARNING"), msg);
 964
 965   /* Page and Header content checks go here */
 966   /* these checks should be last */
 967
 968   if (strlen (string_expect)) {
 969     if (strstr (page, string_expect)) {
 970       printf (_("HTTP OK %s - %.3f second response time %s|%s %s\n"),
 971               status_line, elapsed_time,
 972               (display_html ? "</A>" : ""),
 973               perfd_time (elapsed_time), perfd_size (pagesize));
 974       exit (STATE_OK);
 975     }
 976     else {
 977       printf (_("HTTP CRITICAL - string not found%s|%s %s\n"),
 978               (display_html ? "</A>" : ""),
 979               perfd_time (elapsed_time), perfd_size (pagesize));
 980       exit (STATE_CRITICAL);
 981     }
 982   }
 983
 984   if (strlen (regexp)) {
 985     errcode = regexec (&preg, page, REGS, pmatch, 0);
 986     if ((errcode == 0 && invert_regex == 0) || (errcode == REG_NOMATCH && invert_regex == 1)) {
 987       printf (_("HTTP OK %s - %.3f second response time %s|%s %s\n"),
 988               status_line, elapsed_time,
 989               (display_html ? "</A>" : ""),
 990               perfd_time (elapsed_time), perfd_size (pagesize));
 991       exit (STATE_OK);
 992     }
 993     else if ((errcode == REG_NOMATCH && invert_regex == 0) || (errcode == 0 && invert_regex == 1)) {
 994       if (invert_regex == 0)
 995         msg = strdup(_("pattern not found"));
 996       else
 997         msg = strdup(_("pattern found"));
 998       printf (("%s - %s%s|%s %s\n"),
 999         _("HTTP CRITICAL"),
1000         msg,
1001         (display_html ? "</A>" : ""),
1002         perfd_time (elapsed_time), perfd_size (pagesize));
1003       exit (STATE_CRITICAL);
1004     }
1005     else {
1006       regerror (errcode, &preg, errbuf, MAX_INPUT_BUFFER);
1007       printf (_("HTTP CRITICAL - Execute Error: %s\n"), errbuf);
1008       exit (STATE_CRITICAL);
1009     }
1010   }
1011
1012   /* make sure the page is of an appropriate size */
1013   /* page_len = get_content_length(header); */
1014   page_len = pagesize;
1015   if ((max_page_len > 0) && (page_len > max_page_len)) {
1016     printf (_("HTTP WARNING: page size %d too large%s|%s\n"),
1017       page_len, (display_html ? "</A>" : ""), perfd_size (page_len) );
1018     exit (STATE_WARNING);
1019   } else if ((min_page_len > 0) && (page_len < min_page_len)) {
1020     printf (_("HTTP WARNING: page size %d too small%s|%s\n"),
1021       page_len, (display_html ? "</A>" : ""), perfd_size (page_len) );
1022     exit (STATE_WARNING);
1023   }
1024   /* We only get here if all tests have been passed */
1025   asprintf (&msg, _("HTTP OK %s - %d bytes in %.3f seconds %s|%s %s\n"),
1026             status_line, page_len, elapsed_time,
1027             (display_html ? "</A>" : ""),
1028             perfd_time (elapsed_time), perfd_size (page_len));
1029   die (STATE_OK, "%s", msg);
1030   return STATE_UNKNOWN;
1031 }
1032
1033
1034
1035 /* per RFC 2396 */
1036 #define URI_HTTP "%5[HTPShtps]"
1037 #define URI_HOST "%255[-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]"
1038 #define URI_PORT "%6d" /* MAX_PORT's width is 5 chars, 6 to detect overflow */
1039 #define URI_PATH "%[-_.!~*'();/?:@&=+$,%#abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]"
1040 #define HD1 URI_HTTP "://" URI_HOST ":" URI_PORT "/" URI_PATH
1041 #define HD2 URI_HTTP "://" URI_HOST "/" URI_PATH
1042 #define HD3 URI_HTTP "://" URI_HOST ":" URI_PORT
1043 #define HD4 URI_HTTP "://" URI_HOST
1044 #define HD5 URI_PATH
1045
1046 void
1047 redir (char *pos, char *status_line)
1048 {
1049   int i = 0;
1050   char *x;
1051   char xx[2];
1052   char type[6];
1053   char *addr;
1054   char *url;
1055
1056   addr = malloc (MAX_IPV4_HOSTLENGTH + 1);
1057   if (addr == NULL)
1058     die (STATE_UNKNOWN, _("HTTP UNKNOWN - Could not allocate addr\n"));
1059
1060   url = malloc (strcspn (pos, "\r\n"));
1061   if (url == NULL)
1062     die (STATE_UNKNOWN, _("HTTP UNKNOWN - Could not allocate url\n"));
1063
1064   while (pos) {
1065     sscanf (pos, "%1[Ll]%*1[Oo]%*1[Cc]%*1[Aa]%*1[Tt]%*1[Ii]%*1[Oo]%*1[Nn]:%n", xx, &i);
1066     if (i == 0) {
1067       pos += (size_t) strcspn (pos, "\r\n");
1068       pos += (size_t) strspn (pos, "\r\n");
1069       if (strlen(pos) == 0)
1070         die (STATE_UNKNOWN,
1071              _("HTTP UNKNOWN - Could not find redirect location - %s%s\n"),
1072              status_line, (display_html ? "</A>" : ""));
1073       continue;
1074     }
1075
1076     pos += i;
1077     pos += strspn (pos, " \t");
1078
1079     /*
1080      * RFC 2616 (4.2):  ``Header fields can be extended over multiple lines by
1081      * preceding each extra line with at least one SP or HT.''
1082      */
1083     for (; (i = strspn (pos, "\r\n")); pos += i) {
1084       pos += i;
1085       if (!(i = strspn (pos, " \t"))) {
1086         die (STATE_UNKNOWN, _("HTTP UNKNOWN - Empty redirect location%s\n"),
1087              display_html ? "</A>" : "");
1088       }
1089     }
1090
1091     url = realloc (url, strcspn (pos, "\r\n") + 1);
1092     if (url == NULL)
1093       die (STATE_UNKNOWN, _("HTTP UNKNOWN - could not allocate url\n"));
1094
1095     /* URI_HTTP, URI_HOST, URI_PORT, URI_PATH */
1096     if (sscanf (pos, HD1, type, addr, &i, url) == 4)
1097       use_ssl = server_type_check (type);
1098
1099     /* URI_HTTP URI_HOST URI_PATH */
1100     else if (sscanf (pos, HD2, type, addr, url) == 3 ) {
1101       use_ssl = server_type_check (type);
1102       i = server_port_check (use_ssl);
1103     }
1104
1105     /* URI_HTTP URI_HOST URI_PORT */
1106     else if (sscanf (pos, HD3, type, addr, &i) == 3) {
1107       strcpy (url, HTTP_URL);
1108       use_ssl = server_type_check (type);
1109     }
1110
1111     /* URI_HTTP URI_HOST */
1112     else if (sscanf (pos, HD4, type, addr) == 2) {
1113       strcpy (url, HTTP_URL);
1114       use_ssl = server_type_check (type);
1115       i = server_port_check (use_ssl);
1116     }
1117
1118     /* URI_PATH */
1119     else if (sscanf (pos, HD5, url) == 1) {
1120       /* relative url */
1121       if ((url[0] != '/')) {
1122         if ((x = strrchr(server_url, '/')))
1123           *x = '\0';
1124         asprintf (&url, "%s/%s", server_url, url);
1125       }
1126       i = server_port;
1127       strcpy (type, server_type);
1128       strcpy (addr, host_name ? host_name : server_address);
1129     }
1130
1131     else {
1132       die (STATE_UNKNOWN,
1133            _("HTTP UNKNOWN - Could not parse redirect location - %s%s\n"),
1134            pos, (display_html ? "</A>" : ""));
1135     }
1136
1137     break;
1138
1139   } /* end while (pos) */
1140
1141   if (++redir_depth > max_depth)
1142     die (STATE_WARNING,
1143          _("HTTP WARNING - maximum redirection depth %d exceeded - %s://%s:%d%s%s\n"),
1144          max_depth, type, addr, i, url, (display_html ? "</A>" : ""));
1145
1146   if (server_port==i &&
1147       !strcmp(server_address, addr) &&
1148       (host_name && !strcmp(host_name, addr)) &&
1149       !strcmp(server_url, url))
1150     die (STATE_WARNING,
1151          _("HTTP WARNING - redirection creates an infinite loop - %s://%s:%d%s%s\n"),
1152          type, addr, i, url, (display_html ? "</A>" : ""));
1153
1154   strcpy (server_type, type);
1155
1156   free (host_name);
1157   host_name = strdup (addr);
1158
1159   free (server_address);
1160   server_address = strdup (addr);
1161
1162   free (server_url);
1163   if ((url[0] == '/'))
1164     server_url = strdup (url);
1165   else if (asprintf(&server_url, "/%s", url) == -1)
1166     die (STATE_UNKNOWN, _("HTTP UNKNOWN - Could not allocate server_url%s\n"),
1167          display_html ? "</A>" : "");
1168   free(url);
1169
1170   if ((server_port = i) > MAX_PORT)
1171     die (STATE_UNKNOWN,
1172          _("HTTP UNKNOWN - Redirection to port above %d - %s://%s:%d%s%s\n"),
1173          MAX_PORT, server_type, server_address, server_port, server_url,
1174          display_html ? "</A>" : "");
1175
1176   if (verbose)
1177     printf (_("Redirection to %s://%s:%d%s\n"), server_type,
1178             host_name ? host_name : server_address, server_port, server_url);
1179
1180   check_http ();
1181 }
1182
1183
1184
1185 int
1186 server_type_check (const char *type)
1187 {
1188   if (strcmp (type, "https"))
1189     return FALSE;
1190   else
1191     return TRUE;
1192 }
1193
1194 int
1195 server_port_check (int ssl_flag)
1196 {
1197   if (ssl_flag)
1198     return HTTPS_PORT;
1199   else
1200     return HTTP_PORT;
1201 }
1202
1203 char *perfd_time (double elapsed_time)
1204 {
1205   return fperfdata ("time", elapsed_time, "s",
1206             check_warning_time, warning_time,
1207             check_critical_time, critical_time,
1208                    TRUE, 0, FALSE, 0);
1209 }
1210
1211
1212
1213 char *perfd_size (int page_len)
1214 {
1215   return perfdata ("size", page_len, "B",
1216             (min_page_len>0?TRUE:FALSE), min_page_len,
1217             (min_page_len>0?TRUE:FALSE), 0,
1218             TRUE, 0, FALSE, 0);
1219 }
1220
1221 void
1222 print_help (void)
1223 {
1224   print_revision (progname, revision);
1225
1226   printf ("Copyright (c) 1999 Ethan Galstad <nagios@nagios.org>\n");
1227   printf (COPYRIGHT, copyright, email);
1228
1229   printf ("%s\n", _("This plugin tests the HTTP service on the specified host. It can test"));
1230   printf ("%s\n", _("normal (http) and secure (https) servers, follow redirects, search for"));
1231   printf ("%s\n", _("strings and regular expressions, check connection times, and report on"));
1232   printf ("%s\n", _("certificate expiration times."));
1233
1234   printf ("\n\n");
1235
1236   print_usage ();
1237
1238   printf (_("NOTE: One or both of -H and -I must be specified"));
1239
1240   printf ("\n");
1241
1242   printf (_(UT_HELP_VRSN));
1243   printf (_(UT_EXTRA_OPTS));
1244
1245   printf (" %s\n", "-H, --hostname=ADDRESS");
1246   printf ("    %s\n", _("Host name argument for servers using host headers (virtual host)"));
1247   printf ("    %s\n", _("Append a port to include it in the header (eg: example.com:5000)"));
1248   printf (" %s\n", "-I, --IP-address=ADDRESS");
1249   printf ("    %s\n", _("IP address or name (use numeric address if possible to bypass DNS lookup)."));
1250   printf (" %s\n", "-p, --port=INTEGER");
1251   printf (" %s", _("Port number (default: "));
1252   printf ("%d)\n", HTTP_PORT);
1253
1254   printf (_(UT_IPv46));
1255
1256 #ifdef HAVE_SSL
1257   printf (" %s\n", "-S, --ssl");
1258   printf ("   %s\n", _("Connect via SSL. Port defaults to 443"));
1259   printf (" %s\n", "-C, --certificate=INTEGER");
1260   printf ("   %s\n", _("Minimum number of days a certificate has to be valid. Port defaults to 443"));
1261   printf ("   %s\n", _("(when this option is used the url is not checked.)\n"));
1262 #endif
1263
1264   printf (" %s\n", "-e, --expect=STRING");
1265   printf ("    %s\n", _("String to expect in first (status) line of server response (default: "));
1266   printf ("%s)\n", HTTP_EXPECT);
1267   printf ("    %s\n", _("If specified skips all other status line logic (ex: 3xx, 4xx, 5xx processing)"));
1268   printf (" %s\n", "-s, --string=STRING");
1269   printf ("    %s\n", _("String to expect in the content"));
1270   printf (" %s\n", "-u, --url=PATH");
1271   printf ("    %s\n", _("URL to GET or POST (default: /)"));
1272   printf (" %s\n", "-P, --post=STRING");
1273   printf ("    %s\n", _("URL encoded http POST data"));
1274   printf (" %s\n", "-N, --no-body");
1275   printf ("    %s\n", _("Don't wait for document body: stop reading after headers."));
1276   printf ("    %s\n", _("(Note that this still does an HTTP GET or POST, not a HEAD.)"));
1277   printf (" %s\n", "-M, --max-age=SECONDS");
1278   printf ("    %s\n", _("Warn if document is more than SECONDS old. the number can also be of"));
1279   printf ("    %s\n", _("the form \"10m\" for minutes, \"10h\" for hours, or \"10d\" for days."));
1280   printf (" %s\n", "-T, --content-type=STRING");
1281   printf ("    %s\n", _("specify Content-Type header media type when POSTing\n"));
1282
1283   printf (" %s\n", "-l, --linespan");
1284   printf ("    %s\n", _("Allow regex to span newlines (must precede -r or -R)"));
1285   printf (" %s\n", "-r, --regex, --ereg=STRING");
1286   printf ("    %s\n", _("Search page for regex STRING"));
1287   printf (" %s\n", "-R, --eregi=STRING");
1288   printf ("    %s\n", _("Search page for case-insensitive regex STRING"));
1289   printf (" %s\n", "--invert-regex");
1290   printf ("    %s\n", _("Return CRITICAL if found, OK if not\n"));
1291
1292   printf (" %s\n", "-a, --authorization=AUTH_PAIR");
1293   printf ("    %s\n", _("Username:password on sites with basic authentication"));
1294   printf (" %s\n", "-A, --useragent=STRING");
1295   printf ("    %s\n", _("String to be sent in http header as \"User Agent\""));
1296   printf (" %s\n", "-k, --header=STRING");
1297   printf ("    %s\n", _(" Any other tags to be sent in http header. Use multiple times for additional headers"));
1298   printf (" %s\n", "-L, --link");
1299   printf ("    %s\n", _("Wrap output in HTML link (obsoleted by urlize)"));
1300   printf (" %s\n", "-f, --onredirect=<ok|warning|critical|follow>");
1301   printf ("    %s\n", _("How to handle redirected pages"));
1302   printf (" %s\n", "-m, --pagesize=INTEGER<:INTEGER>");
1303   printf ("    %s\n", _("Minimum page size required (bytes) : Maximum page size required (bytes)"));
1304
1305   printf (_(UT_WARN_CRIT));
1306
1307   printf (_(UT_TIMEOUT), DEFAULT_SOCKET_TIMEOUT);
1308
1309   printf (_(UT_VERBOSE));
1310
1311   printf ("\n");
1312   printf ("%s\n", _("Notes:"));
1313   printf (" %s\n", _("This plugin will attempt to open an HTTP connection with the host."));
1314   printf (" %s\n", _("Successful connects return STATE_OK, refusals and timeouts return STATE_CRITICAL"));
1315   printf (" %s\n", _("other errors return STATE_UNKNOWN.  Successful connects, but incorrect reponse"));
1316   printf (" %s\n", _("messages from the host result in STATE_WARNING return values.  If you are"));
1317   printf (" %s\n", _("checking a virtual server that uses 'host headers' you must supply the FQDN"));
1318   printf (" %s\n", _("(fully qualified domain name) as the [host_name] argument."));
1319   printf ("\n");
1320   printf (_(UT_EXTRA_OPTS_NOTES));
1321
1322 #ifdef HAVE_SSL
1323   printf ("\n");
1324   printf (" %s\n", _("This plugin can also check whether an SSL enabled web server is able to"));
1325   printf (" %s\n", _("serve content (optionally within a specified time) or whether the X509 "));
1326   printf (" %s\n", _("certificate is still valid for the specified number of days."));
1327   printf ("\n");
1328   printf ("%s\n", _("Examples:"));
1329   printf (" %s\n\n", "CHECK CONTENT: check_http -w 5 -c 10 --ssl -H www.verisign.com");
1330   printf (" %s\n", _("When the 'www.verisign.com' server returns its content within 5 seconds,"));
1331   printf (" %s\n", _("a STATE_OK will be returned. When the server returns its content but exceeds"));
1332   printf (" %s\n", _("the 5-second threshold, a STATE_WARNING will be returned. When an error occurs,"));
1333   printf (" %s\n\n", _("a STATE_CRITICAL will be returned."));
1334
1335   printf (" %s\n\n", "CHECK CERTIFICATE: check_http -H www.verisign.com -C 14");
1336   printf (" %s\n", _("When the certificate of 'www.verisign.com' is valid for more than 14 days,"));
1337   printf (" %s\n", _("a STATE_OK is returned. When the certificate is still valid, but for less than"));
1338   printf (" %s\n", _("14 days, a STATE_WARNING is returned. A STATE_CRITICAL will be returned when"));
1339   printf (" %s\n", _("the certificate is expired."));
1340 #endif
1341
1342   printf (_(UT_SUPPORT));
1343
1344 }
1345
1346
1347
1348 void
1349 print_usage (void)
1350 {
1351   printf (_("Usage:"));
1352   printf (" %s -H <vhost> | -I <IP-address> [-u <uri>] [-p <port>]\n",progname);
1353   printf ("       [-w <warn time>] [-c <critical time>] [-t <timeout>] [-L]\n");
1354   printf ("       [-a auth] [-f <ok | warn | critcal | follow>] [-e <expect>]\n");
1355   printf ("       [-s string] [-l] [-r <regex> | -R <case-insensitive regex>] [-P string]\n");
1356   printf ("       [-m <min_pg_size>:<max_pg_size>] [-4|-6] [-N] [-M <age>] [-A string]\n");
1357   printf ("       [-k string] [-S] [-C <age>] [-T <content-type>]\n");
1358 }