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