plugins/check_pgsql.c

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