plugins/check_pgsql.c

   1 /******************************************************************************
   2  *
   3  * Program: PostgreSQL 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  *****************************************************************************/
  25
  26 const char *progname = "check_pgsql";
  27 #define REVISION "$Revision$"
  28 #define COPYRIGHT "1999-2001"
  29 #define AUTHOR "Karl DeBisschop"
  30 #define EMAIL "kdebisschop@users.sourceforge.net"
  31 #define SUMMARY "Tests to see if a PostgreSQL DBMS is accepting connections.\n"
  32
  33 #define OPTIONS "[-c critical_time] [-w warning_time] [-t timeout] [-H host]\n\
  34              [-P port] [-d database] [-l logname] [-p password]"
  35
  36 #define LONGOPTIONS "\
  37   -c, --critical=INTEGER\n\
  38     Exit STATE_CRITICAL if connection time exceeds threshold (default: %d)\n\
  39   -w, --warning=INTEGER\n\
  40     Exit STATE_WARNING if connection time exceeds threshold (default: %d)\n\
  41   -t, --timeout=INTEGER\n\
  42     Terminate test if timeout limit is exceeded (default: %d)\n\
  43   -H, --hostname=STRING\n\
  44     Name or numeric IP address of machine running backend\n\
  45   -P, --port=INTEGER\n\
  46     Port running backend (default: %d)\n\
  47   -d, --database=STRING\n\
  48     Database to check (default: %s)\n\
  49   -l, --logname = STRING\n\
  50     Login name of user\n\
  51   -p, --password = STRING\n\
  52     Password (BIG SECURITY ISSUE)\n"
  53
  54 #define DESCRIPTION "All parameters are optional.\n\
  55 \n\
  56 This plugin tests a PostgreSQL DBMS to determine whether it is active and\n\
  57 accepting queries. In its current operation, it simply connects to the\n\
  58 specified database, and then disconnects. If no database is specified, it\n\
  59 connects to the template1 database, which is present in every functioning \n\
  60 PostgreSQL DBMS.\n\
  61 \n\
  62 The plugin will connect to a local postmaster if no host is specified. To\n\
  63 connect to a remote host, be sure that the remote postmaster accepts TCP/IP\n\
  64 connections (start the postmaster with the -i option).\n\
  65 \n\
  66 Typically, the nagios user (unless the --logname option is used) should be\n\
  67 able to connect to the database without a password. The plugin can also send\n\
  68 a password, but no effort is made to obsure or encrypt the password.\n"
  69
  70 #define DEFAULT_DB "template1"
  71 #define DEFAULT_HOST "127.0.0.1"
  72 enum {
  73         DEFAULT_PORT = 5432,
  74         DEFAULT_WARN = 2,
  75         DEFAULT_CRIT = 8,
  76         DEFAULT_TIMEOUT = 30
  77 };
  78
  79 #include "config.h"
  80 #include "common.h"
  81 #include "utils.h"
  82 #include <libpq-fe.h>
  83
  84 int process_arguments (int, char **);
  85 int validate_arguments (void);
  86 void print_usage (void);
  87 void print_help (void);
  88 int is_pg_dbname (char *);
  89 int is_pg_logname (char *);
  90
  91 char *pghost = NULL;                                            /* host name of the backend server */
  92 char *pgport = NULL;                                            /* port of the backend server */
  93 int default_port = DEFAULT_PORT;
  94 char *pgoptions = NULL;
  95 char *pgtty = NULL;
  96 char dbName[NAMEDATALEN] = DEFAULT_DB;
  97 char *pguser = NULL;
  98 char *pgpasswd = NULL;
  99 int twarn = DEFAULT_WARN;
 100 int tcrit = DEFAULT_CRIT;
 101
 102 PGconn *conn;
 103 /*PGresult   *res;*/
 104 \f
 105
 106 /******************************************************************************
 107
 108 The (psuedo?)literate programming XML is contained within \@\@\- <XML> \-\@\@
 109 tags in the comments. With in the tags, the XML is assembled sequentially.
 110 You can define entities in tags. You also have all the #defines available as
 111 entities.
 112
 113 Please note that all tags must be lowercase to use the DocBook XML DTD.
 114
 115 @@-<article>
 116
 117 <sect1>
 118 <title>Quick Reference</title>
 119 <!-- The refentry forms a manpage -->
 120 <refentry>
 121 <refmeta>
 122 <manvolnum>5<manvolnum>
 123 </refmeta>
 124 <refnamdiv>
 125 <refname>&progname;</refname>
 126 <refpurpose>&SUMMARY;</refpurpose>
 127 </refnamdiv>
 128 </refentry>
 129 </sect1>
 130
 131 <sect1>
 132 <title>FAQ</title>
 133 </sect1>
 134
 135 <sect1>
 136 <title>Theory, Installation, and Operation</title>
 137
 138 <sect2>
 139 <title>General Description</title>
 140 <para>
 141 &DESCRIPTION;
 142 </para>
 143 </sect2>
 144
 145 <sect2>
 146 <title>Future Enhancements</title>
 147 <para>ToDo List</para>
 148 <itemizedlist>
 149 <listitem>Add option to get password from a secured file rather than the command line</listitem>
 150 <listitem>Add option to specify the query to execute</listitem>
 151 </itemizedlist>
 152 </sect2>
 153
 154
 155 <sect2>
 156 <title>Functions</title>
 157 -@@
 158 ******************************************************************************/
 159
 160 int
 161 main (int argc, char **argv)
 162 {
 163         int elapsed_time;
 164
 165         /* begin, by setting the parameters for a backend connection if the
 166          * parameters are null, then the system will try to use reasonable
 167          * defaults by looking up environment variables or, failing that,
 168          * using hardwired constants */
 169
 170         pgoptions = NULL;  /* special options to start up the backend server */
 171         pgtty = NULL;      /* debugging tty for the backend server */
 172
 173         if (process_arguments (argc, argv) == ERROR)
 174                 usage ("Could not parse arguments");
 175
 176         /* Set signal handling and alarm */
 177         if (signal (SIGALRM, timeout_alarm_handler) == SIG_ERR) {
 178                 printf ("Cannot catch SIGALRM");
 179                 return STATE_UNKNOWN;
 180         }
 181         alarm (timeout_interval);
 182
 183         /* make a connection to the database */
 184         time (&start_time);
 185         conn =
 186                 PQsetdbLogin (pghost, pgport, pgoptions, pgtty, dbName, pguser, pgpasswd);
 187         time (&end_time);
 188         elapsed_time = (int) (end_time - start_time);
 189
 190         /* check to see that the backend connection was successfully made */
 191         if (PQstatus (conn) == CONNECTION_BAD) {
 192                 printf ("PGSQL: CRITICAL - no connection to '%s' (%s).\n", dbName,
 193                                                 PQerrorMessage (conn));
 194                 PQfinish (conn);
 195                 return STATE_CRITICAL;
 196         }
 197         else if (elapsed_time > tcrit) {
 198                 PQfinish (conn);
 199                 printf ("PGSQL: CRITICAL - database %s (%d sec.)\n", dbName,
 200                                                 elapsed_time);
 201                 return STATE_CRITICAL;
 202         }
 203         else if (elapsed_time > twarn) {
 204                 PQfinish (conn);
 205                 printf ("PGSQL: WARNING - database %s (%d sec.)\n", dbName, elapsed_time);
 206                 return STATE_WARNING;
 207         }
 208         else {
 209                 PQfinish (conn);
 210                 printf ("PGSQL: ok - database %s (%d sec.)\n", dbName, elapsed_time);
 211                 return STATE_OK;
 212         }
 213 }
 214 \f
 215
 216
 217
 218 void
 219 print_help (void)
 220 {
 221         print_revision (progname, REVISION);
 222         printf
 223                 ("Copyright (c) %s %s <%s>\n\n%s\n",
 224                  COPYRIGHT, AUTHOR, EMAIL, SUMMARY);
 225         print_usage ();
 226         printf
 227                 ("\nOptions:\n" LONGOPTIONS "\n" DESCRIPTION "\n",
 228                  DEFAULT_WARN, DEFAULT_CRIT, DEFAULT_TIMEOUT, DEFAULT_PORT, DEFAULT_DB);
 229         support ();
 230 }
 231
 232 void
 233 print_usage (void)
 234 {
 235         printf ("Usage:\n" " %s %s\n"
 236                                         " %s (-h | --help) for detailed help\n"
 237                                         " %s (-V | --version) for version information\n",
 238                                         progname, OPTIONS, progname, progname);
 239 }
 240 \f
 241
 242
 243 /* process command-line arguments */
 244 int
 245 process_arguments (int argc, char **argv)
 246 {
 247         int c;
 248
 249         int option_index = 0;
 250         static struct option long_options[] = {
 251                 {"help", no_argument, 0, 'h'},
 252                 {"version", no_argument, 0, 'V'},
 253                 {"timeout", required_argument, 0, 't'},
 254                 {"critical", required_argument, 0, 'c'},
 255                 {"warning", required_argument, 0, 'w'},
 256                 {"hostname", required_argument, 0, 'H'},
 257                 {"logname", required_argument, 0, 'l'},
 258                 {"password", required_argument, 0, 'p'},
 259                 {"authorization", required_argument, 0, 'a'},
 260                 {"port", required_argument, 0, 'P'},
 261                 {"database", required_argument, 0, 'd'},
 262                 {0, 0, 0, 0}
 263         };
 264
 265         while (1) {
 266                 c = getopt_long (argc, argv, "hVt:c:w:H:P:d:l:p:a:",
 267                                  long_options, &option_index);
 268
 269                 if (c == EOF)
 270                         break;
 271
 272                 switch (c) {
 273                 case '?':     /* usage */
 274                         usage3 ("Unknown argument", optopt);
 275                 case 'h':     /* help */
 276                         print_help ();
 277                         exit (STATE_OK);
 278                 case 'V':     /* version */
 279                         print_revision (progname, REVISION);
 280                         exit (STATE_OK);
 281                 case 't':     /* timeout period */
 282                         if (!is_integer (optarg))
 283                                 usage2 ("Timeout Interval must be an integer", optarg);
 284                         timeout_interval = atoi (optarg);
 285                         break;
 286                 case 'c':     /* critical time threshold */
 287                         if (!is_integer (optarg))
 288                                 usage2 ("Invalid critical threshold", optarg);
 289                         tcrit = atoi (optarg);
 290                         break;
 291                 case 'w':     /* warning time threshold */
 292                         if (!is_integer (optarg))
 293                                 usage2 ("Invalid critical threshold", optarg);
 294                         twarn = atoi (optarg);
 295                         break;
 296                 case 'H':     /* host */
 297                         if (!is_host (optarg))
 298                                 usage2 ("You gave an invalid host name", optarg);
 299                         pghost = optarg;
 300                         break;
 301                 case 'P':     /* port */
 302                         if (!is_integer (optarg))
 303                                 usage2 ("Port must be an integer", optarg);
 304                         pgport = optarg;
 305                         break;
 306                 case 'd':     /* database name */
 307                         if (!is_pg_dbname (optarg))
 308                                 usage2 ("Database name is not valid", optarg);
 309                         strncpy (dbName, optarg, NAMEDATALEN - 1);
 310                         dbName[NAMEDATALEN - 1] = 0;
 311                         break;
 312                 case 'l':     /* login name */
 313                         if (!is_pg_logname (optarg))
 314                                 usage2 ("user name is not valid", optarg);
 315                         pguser = optarg;
 316                         break;
 317                 case 'p':     /* authentication password */
 318                 case 'a':
 319                         pgpasswd = optarg;
 320                         break;
 321                 }
 322         }
 323
 324         return validate_arguments ();
 325 }
 326
 327
 328 /******************************************************************************
 329
 330 @@-
 331 <sect3>
 332 <title>validate_arguments</title>
 333
 334 <para>&PROTO_validate_arguments;</para>
 335
 336 <para>Given a database name, this function returns TRUE if the string
 337 is a valid PostgreSQL database name, and returns false if it is
 338 not.</para>
 339
 340 <para>Valid PostgreSQL database names are less than &NAMEDATALEN;
 341 characters long and consist of letters, numbers, and underscores. The
 342 first character cannot be a number, however.</para>
 343
 344 </sect3>
 345 -@@
 346 ******************************************************************************/
 347
 348 int
 349 validate_arguments ()
 350 {
 351         return OK;
 352 }
 353 \f
 354
 355
 356 /******************************************************************************
 357
 358 @@-
 359 <sect3>
 360 <title>is_pg_dbname</title>
 361
 362 <para>&PROTO_is_pg_dbname;</para>
 363
 364 <para>Given a database name, this function returns TRUE if the string
 365 is a valid PostgreSQL database name, and returns false if it is
 366 not.</para>
 367
 368 <para>Valid PostgreSQL database names are less than &NAMEDATALEN;
 369 characters long and consist of letters, numbers, and underscores. The
 370 first character cannot be a number, however.</para>
 371
 372 </sect3>
 373 -@@
 374 ******************************************************************************/
 375
 376 int
 377 is_pg_dbname (char *dbname)
 378 {
 379         char txt[NAMEDATALEN];
 380         char tmp[NAMEDATALEN];
 381         if (strlen (dbname) > NAMEDATALEN - 1)
 382                 return (FALSE);
 383         strncpy (txt, dbname, NAMEDATALEN - 1);
 384         txt[NAMEDATALEN - 1] = 0;
 385         if (sscanf (txt, "%[_a-zA-Z]%[^_a-zA-Z0-9]", tmp, tmp) == 1)
 386                 return (TRUE);
 387         if (sscanf (txt, "%[_a-zA-Z]%[_a-zA-Z0-9]%[^_a-zA-Z0-9]", tmp, tmp, tmp) ==
 388                         2) return (TRUE);
 389         return (FALSE);
 390 }
 391
 392 /**
 393
 394 the tango program should eventually create an entity here based on the
 395 function prototype
 396
 397 @@-
 398 <sect3>
 399 <title>is_pg_logname</title>
 400
 401 <para>&PROTO_is_pg_logname;</para>
 402
 403 <para>Given a username, this function returns TRUE if the string is a
 404 valid PostgreSQL username, and returns false if it is not. Valid PostgreSQL
 405 usernames are less than &NAMEDATALEN; characters long and consist of
 406 letters, numbers, dashes, and underscores, plus possibly some other
 407 characters.</para>
 408
 409 <para>Currently this function only checks string length. Additional checks
 410 should be added.</para>
 411
 412 </sect3>
 413 -@@
 414 ******************************************************************************/
 415
 416 int
 417 is_pg_logname (char *username)
 418 {
 419         if (strlen (username) > NAMEDATALEN - 1)
 420                 return (FALSE);
 421         return (TRUE);
 422 }
 423
 424 /******************************************************************************
 425 @@-
 426 </sect2>
 427 </sect1>
 428 </article>
 429 -@@
 430 ******************************************************************************/