debian/pkg-monitoring-plugins
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pkg-monitoring-plugins/plugins/check_dbi.c

826 lines
22 KiB
C
Raw Blame History

/*****************************************************************************
*
* Monitoring check_dbi plugin
*
* License: GPL
* Copyright (c) 2011 Monitoring Plugins Development Team
* Author: Sebastian 'tokkee' Harl <sh@teamix.net>
*
* Description:
*
* This file contains the check_dbi plugin
*
* Runs an arbitrary (SQL) command and checks the result.
*
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*
*****************************************************************************/
const char *progname = "check_dbi";
const char *copyright = "2011";
const char *email = "devel@monitoring-plugins.org";
#include "common.h"
#include "utils.h"
#include "utils_cmd.h"
#include "netutils.h"
#include "regex.h"
/* required for NAN */
#ifndef _ISOC99_SOURCE
#define _ISOC99_SOURCE
#endif
#include <assert.h>
#include <math.h>
#include <dbi/dbi.h>
#include <stdarg.h>
typedef enum {
METRIC_CONN_TIME,
METRIC_SERVER_VERSION,
METRIC_QUERY_RESULT,
METRIC_QUERY_TIME,
} np_dbi_metric_t;
typedef enum {
TYPE_NUMERIC,
TYPE_STRING,
} np_dbi_type_t;
typedef struct {
char *key;
char *value;
} driver_option_t;
char *host = NULL;
int verbose = 0;
char *warning_range = NULL;
char *critical_range = NULL;
thresholds *dbi_thresholds = NULL;
char *expect = NULL;
regex_t expect_re;
char *expect_re_str = NULL;
int expect_re_cflags = 0;
np_dbi_metric_t metric = METRIC_QUERY_RESULT;
np_dbi_type_t type = TYPE_NUMERIC;
char *np_dbi_driver = NULL;
driver_option_t *np_dbi_options = NULL;
int np_dbi_options_num = 0;
char *np_dbi_database = NULL;
char *np_dbi_query = NULL;
int process_arguments (int, char **);
int validate_arguments (void);
void print_usage (void);
void print_help (void);
double timediff (struct timeval, struct timeval);
void np_dbi_print_error (dbi_conn, char *, ...);
int do_query (dbi_conn, const char **, double *, double *);
int
main (int argc, char **argv)
{
int status = STATE_UNKNOWN;
dbi_driver driver;
dbi_conn conn;
unsigned int server_version;
struct timeval start_timeval, end_timeval;
double conn_time = 0.0;
double query_time = 0.0;
const char *query_val_str = NULL;
double query_val = 0.0;
int i;
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* Parse extra opts if any */
argv = np_extra_opts (&argc, argv, progname);
if (process_arguments (argc, argv) == ERROR)
usage4 (_("Could not parse arguments"));
/* Set signal handling and alarm */
if (signal (SIGALRM, timeout_alarm_handler) == SIG_ERR) {
usage4 (_("Cannot catch SIGALRM"));
}
alarm (timeout_interval);
if (verbose > 2)
printf ("Initializing DBI\n");
dbi_inst *instance_p = { 0 };
if (dbi_initialize_r(NULL, instance_p) < 0) {
printf ("UNKNOWN - failed to initialize DBI; possibly you don't have any drivers installed.\n");
return STATE_UNKNOWN;
}
if (instance_p == NULL) {
printf ("UNKNOWN - failed to initialize DBI.\n");
return STATE_UNKNOWN;
}
if (verbose)
printf ("Opening DBI driver '%s'\n", np_dbi_driver);
driver = dbi_driver_open_r(np_dbi_driver, instance_p);
if (! driver) {
printf ("UNKNOWN - failed to open DBI driver '%s'; possibly it's not installed.\n",
np_dbi_driver);
printf ("Known drivers:\n");
for (driver = dbi_driver_list_r(NULL, instance_p); driver; driver = dbi_driver_list_r(driver, instance_p)) {
printf (" - %s\n", dbi_driver_get_name (driver));
}
return STATE_UNKNOWN;
}
/* make a connection to the database */
gettimeofday (&start_timeval, NULL);
conn = dbi_conn_open (driver);
if (! conn) {
printf ("UNKNOWN - failed top open connection object.\n");
dbi_conn_close (conn);
return STATE_UNKNOWN;
}
for (i = 0; i < np_dbi_options_num; ++i) {
const char *opt;
if (verbose > 1)
printf ("Setting DBI driver option '%s' to '%s'\n",
np_dbi_options[i].key, np_dbi_options[i].value);
if (! dbi_conn_set_option (conn, np_dbi_options[i].key, np_dbi_options[i].value))
continue;
/* else: status != 0 */
np_dbi_print_error (conn, "UNKNOWN - failed to set option '%s' to '%s'",
np_dbi_options[i].key, np_dbi_options[i].value);
printf ("Known driver options:\n");
for (opt = dbi_conn_get_option_list (conn, NULL); opt;
opt = dbi_conn_get_option_list (conn, opt)) {
printf (" - %s\n", opt);
}
dbi_conn_close (conn);
return STATE_UNKNOWN;
}
if (host) {
if (verbose > 1)
printf ("Setting DBI driver option 'host' to '%s'\n", host);
dbi_conn_set_option (conn, "host", host);
}
if (verbose) {
const char *dbname, *host;
dbname = dbi_conn_get_option (conn, "dbname");
host = dbi_conn_get_option (conn, "host");
if (! dbname)
dbname = "<unspecified>";
if (! host)
host = "<unspecified>";
printf ("Connecting to database '%s' at host '%s'\n",
dbname, host);
}
if (dbi_conn_connect (conn) < 0) {
np_dbi_print_error (conn, "UNKNOWN - failed to connect to database");
return STATE_UNKNOWN;
}
gettimeofday (&end_timeval, NULL);
conn_time = timediff (start_timeval, end_timeval);
server_version = dbi_conn_get_engine_version (conn);
if (verbose)
printf ("Connected to server version %u\n", server_version);
if (metric == METRIC_SERVER_VERSION)
status = get_status (server_version, dbi_thresholds);
if (verbose)
printf ("Time elapsed: %f\n", conn_time);
if (metric == METRIC_CONN_TIME)
status = get_status (conn_time, dbi_thresholds);
/* select a database */
if (np_dbi_database) {
if (verbose > 1)
printf ("Selecting database '%s'\n", np_dbi_database);
if (dbi_conn_select_db (conn, np_dbi_database)) {
np_dbi_print_error (conn, "UNKNOWN - failed to select database '%s'",
np_dbi_database);
return STATE_UNKNOWN;
}
}
if (np_dbi_query) {
/* execute query */
status = do_query (conn, &query_val_str, &query_val, &query_time);
if (status != STATE_OK)
/* do_query prints an error message in this case */
return status;
if (metric == METRIC_QUERY_RESULT) {
if (expect) {
if ((! query_val_str) || strcmp (query_val_str, expect))
status = STATE_CRITICAL;
else
status = STATE_OK;
}
else if (expect_re_str) {
int err;
err = regexec (&expect_re, query_val_str, 0, NULL, /* flags = */ 0);
if (! err)
status = STATE_OK;
else if (err == REG_NOMATCH)
status = STATE_CRITICAL;
else {
char errmsg[1024];
regerror (err, &expect_re, errmsg, sizeof (errmsg));
printf ("ERROR - failed to execute regular expression: %s\n",
errmsg);
status = STATE_CRITICAL;
}
}
else
status = get_status (query_val, dbi_thresholds);
}
else if (metric == METRIC_QUERY_TIME)
status = get_status (query_time, dbi_thresholds);
}
if (verbose)
printf("Closing connection\n");
dbi_conn_close (conn);
/* In case of METRIC_QUERY_RESULT, isnan(query_val) indicates an error
* which should have been reported and handled (abort) before
* ... unless we expected a string to be returned */
assert ((metric != METRIC_QUERY_RESULT) || (! isnan (query_val))
|| (type == TYPE_STRING));
assert ((type != TYPE_STRING) || (expect || expect_re_str));
printf ("%s - connection time: %fs", state_text (status), conn_time);
if (np_dbi_query) {
if (type == TYPE_STRING) {
assert (expect || expect_re_str);
printf (", '%s' returned '%s' in %fs", np_dbi_query,
query_val_str ? query_val_str : "<nothing>", query_time);
if (status != STATE_OK) {
if (expect)
printf (" (expected '%s')", expect);
else if (expect_re_str)
printf (" (expected regex /%s/%s)", expect_re_str,
((expect_re_cflags & REG_ICASE) ? "i" : ""));
}
}
else if (isnan (query_val))
printf (", '%s' query execution time: %fs", np_dbi_query, query_time);
else
printf (", '%s' returned %f in %fs", np_dbi_query, query_val, query_time);
}
printf (" | conntime=%fs;%s;%s;0; server_version=%u;%s;%s;0;", conn_time,
((metric == METRIC_CONN_TIME) && warning_range) ? warning_range : "",
((metric == METRIC_CONN_TIME) && critical_range) ? critical_range : "",
server_version,
((metric == METRIC_SERVER_VERSION) && warning_range) ? warning_range : "",
((metric == METRIC_SERVER_VERSION) && critical_range) ? critical_range : "");
if (np_dbi_query) {
if (! isnan (query_val)) /* this is also true when -e is used */
printf (" query=%f;%s;%s;;", query_val,
((metric == METRIC_QUERY_RESULT) && warning_range) ? warning_range : "",
((metric == METRIC_QUERY_RESULT) && critical_range) ? critical_range : "");
printf (" querytime=%fs;%s;%s;0;", query_time,
((metric == METRIC_QUERY_TIME) && warning_range) ? warning_range : "",
((metric == METRIC_QUERY_TIME) && critical_range) ? critical_range : "");
}
printf ("\n");
return status;
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
int option = 0;
static struct option longopts[] = {
STD_LONG_OPTS,
{"expect", required_argument, 0, 'e'},
{"regex", required_argument, 0, 'r'},
{"regexi", required_argument, 0, 'R'},
{"metric", required_argument, 0, 'm'},
{"driver", required_argument, 0, 'd'},
{"option", required_argument, 0, 'o'},
{"query", required_argument, 0, 'q'},
{"database", required_argument, 0, 'D'},
{0, 0, 0, 0}
};
while (1) {
c = getopt_long (argc, argv, "Vvht:c:w:e:r:R:m:H:d:o:q:D:",
longopts, &option);
if (c == EOF)
break;
switch (c) {
case '?': /* usage */
usage5 ();
case 'h': /* help */
print_help ();
exit (STATE_UNKNOWN);
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_UNKNOWN);
case 'c': /* critical range */
critical_range = optarg;
type = TYPE_NUMERIC;
break;
case 'w': /* warning range */
warning_range = optarg;
type = TYPE_NUMERIC;
break;
case 'e':
expect = optarg;
type = TYPE_STRING;
break;
case 'R':
expect_re_cflags = REG_ICASE;
/* fall through */
case 'r':
{
int err;
expect_re_cflags |= REG_EXTENDED | REG_NOSUB | REG_NEWLINE;
expect_re_str = optarg;
type = TYPE_STRING;
err = regcomp (&expect_re, expect_re_str, expect_re_cflags);
if (err) {
char errmsg[1024];
regerror (err, &expect_re, errmsg, sizeof (errmsg));
printf ("ERROR - failed to compile regular expression: %s\n",
errmsg);
return ERROR;
}
break;
}
case 'm':
if (! strcasecmp (optarg, "CONN_TIME"))
metric = METRIC_CONN_TIME;
else if (! strcasecmp (optarg, "SERVER_VERSION"))
metric = METRIC_SERVER_VERSION;
else if (! strcasecmp (optarg, "QUERY_RESULT"))
metric = METRIC_QUERY_RESULT;
else if (! strcasecmp (optarg, "QUERY_TIME"))
metric = METRIC_QUERY_TIME;
else
usage2 (_("Invalid metric"), optarg);
break;
case 't': /* timeout */
if (!is_intnonneg (optarg))
usage2 (_("Timeout interval must be a positive integer"), optarg);
else
timeout_interval = atoi (optarg);
break;
case 'H': /* host */
if (!is_host (optarg))
usage2 (_("Invalid hostname/address"), optarg);
else
host = optarg;
break;
case 'v':
verbose++;
break;
case 'd':
np_dbi_driver = optarg;
break;
case 'o':
{
driver_option_t *new;
char *k, *v;
k = optarg;
v = strchr (k, (int)'=');
if (! v)
usage2 (_("Option must be '<key>=<value>'"), optarg);
*v = '\0';
++v;
new = realloc (np_dbi_options,
(np_dbi_options_num + 1) * sizeof (*new));
if (! new) {
printf ("UNKNOWN - failed to reallocate memory\n");
exit (STATE_UNKNOWN);
}
np_dbi_options = new;
new = np_dbi_options + np_dbi_options_num;
++np_dbi_options_num;
new->key = k;
new->value = v;
}
break;
case 'q':
np_dbi_query = optarg;
break;
case 'D':
np_dbi_database = optarg;
break;
}
}
set_thresholds (&dbi_thresholds, warning_range, critical_range);
return validate_arguments ();
}
int
validate_arguments ()
{
if (! np_dbi_driver)
usage ("Must specify a DBI driver");
if (((metric == METRIC_QUERY_RESULT) || (metric == METRIC_QUERY_TIME))
&& (! np_dbi_query))
usage ("Must specify a query to execute (metric == QUERY_RESULT)");
if ((metric != METRIC_CONN_TIME)
&& (metric != METRIC_SERVER_VERSION)
&& (metric != METRIC_QUERY_RESULT)
&& (metric != METRIC_QUERY_TIME))
usage ("Invalid metric specified");
if (expect && (warning_range || critical_range || expect_re_str))
usage ("Do not mix -e and -w/-c/-r/-R");
if (expect_re_str && (warning_range || critical_range || expect))
usage ("Do not mix -r/-R and -w/-c/-e");
if (expect && (metric != METRIC_QUERY_RESULT))
usage ("Option -e requires metric QUERY_RESULT");
if (expect_re_str && (metric != METRIC_QUERY_RESULT))
usage ("Options -r/-R require metric QUERY_RESULT");
return OK;
}
void
print_help (void)
{
print_revision (progname, NP_VERSION);
printf (COPYRIGHT, copyright, email);
printf (_("This program connects to an (SQL) database using DBI and checks the\n"
"specified metric against threshold levels. The default metric is\n"
"the result of the specified query.\n"));
printf ("\n\n");
print_usage ();
printf (UT_HELP_VRSN);
/* include this conditionally to avoid 'zero-length printf format string'
* compiler warnings */
#ifdef NP_EXTRA_OPTS
printf (UT_EXTRA_OPTS);
#endif
printf ("\n");
printf (" %s\n", "-d, --driver=STRING");
printf (" %s\n", _("DBI driver to use"));
printf (" %s\n", "-o, --option=STRING");
printf (" %s\n", _("DBI driver options"));
printf (" %s\n", "-q, --query=STRING");
printf (" %s\n", _("query to execute"));
printf ("\n");
printf (UT_WARN_CRIT_RANGE);
printf (" %s\n", "-e, --expect=STRING");
printf (" %s\n", _("String to expect as query result"));
printf (" %s\n", _("Do not mix with -w, -c, -r, or -R!"));
printf (" %s\n", "-r, --regex=REGEX");
printf (" %s\n", _("Extended POSIX regular expression to check query result against"));
printf (" %s\n", _("Do not mix with -w, -c, -e, or -R!"));
printf (" %s\n", "-R, --regexi=REGEX");
printf (" %s\n", _("Case-insensitive extended POSIX regex to check query result against"));
printf (" %s\n", _("Do not mix with -w, -c, -e, or -r!"));
printf (" %s\n", "-m, --metric=METRIC");
printf (" %s\n", _("Metric to check thresholds against. Available metrics:"));
printf (" CONN_TIME - %s\n", _("time used for setting up the database connection"));
printf (" QUERY_RESULT - %s\n", _("result (first column of first row) of the query"));
printf (" QUERY_TIME - %s\n", _("time used to execute the query"));
printf (" %s\n", _("(ignore the query result)"));
printf ("\n");
printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT);
printf (UT_VERBOSE);
printf ("\n");
printf (" %s\n", _("A DBI driver (-d option) is required. If the specified metric operates"));
printf (" %s\n\n", _("on a query, one has to be specified (-q option)."));
printf (" %s\n", _("This plugin connects to an (SQL) database using libdbi and, optionally,"));
printf (" %s\n", _("executes the specified query. The first column of the first row of the"));
printf (" %s\n", _("result will be parsed and, in QUERY_RESULT mode, compared with the"));
printf (" %s\n", _("warning and critical ranges. The result from the query has to be numeric"));
printf (" %s\n\n", _("(strings representing numbers are fine)."));
printf (" %s\n", _("The number and type of required DBI driver options depends on the actual"));
printf (" %s\n", _("driver. See its documentation at http://libdbi-drivers.sourceforge.net/"));
printf (" %s\n\n", _("for details."));
printf (" %s\n", _("Examples:"));
printf (" check_dbi -d pgsql -o username=postgres -m QUERY_RESULT \\\n");
printf (" -q 'SELECT COUNT(*) FROM pg_stat_activity' -w 5 -c 10\n");
printf (" Warning if more than five connections; critical if more than ten.\n\n");
printf (" check_dbi -d mysql -H localhost -o username=user -o password=secret \\\n");
printf (" -q 'SELECT COUNT(*) FROM logged_in_users -w 5:20 -c 0:50\n");
printf (" Warning if less than 5 or more than 20 users are logged in; critical\n");
printf (" if more than 50 users.\n\n");
printf (" check_dbi -d firebird -o username=user -o password=secret -o dbname=foo \\\n");
printf (" -m CONN_TIME -w 0.5 -c 2\n");
printf (" Warning if connecting to the database takes more than half of a second;\n");
printf (" critical if it takes more than 2 seconds.\n\n");
printf (" check_dbi -d mysql -H localhost -o username=user \\\n");
printf (" -q 'SELECT concat(@@version, \" \", @@version_comment)' \\\n");
printf (" -r '^5\\.[01].*MySQL Enterprise Server'\n");
printf (" Critical if the database server is not a MySQL enterprise server in either\n");
printf (" version 5.0.x or 5.1.x.\n\n");
printf (" check_dbi -d pgsql -u username=user -m SERVER_VERSION \\\n");
printf (" -w 090000:090099 -c 090000:090199\n");
printf (" Warn if the PostgreSQL server version is not 9.0.x; critical if the version\n");
printf (" is less than 9.x or higher than 9.1.x.\n");
printf (UT_SUPPORT);
}
void
print_usage (void)
{
printf ("%s\n", _("Usage:"));
printf ("%s -d <DBI driver> [-o <DBI driver option> [...]] [-q <query>]\n", progname);
printf (" [-H <host>] [-c <critical range>] [-w <warning range>] [-m <metric>]\n");
printf (" [-e <string>] [-r|-R <regex>]\n");
}
#define CHECK_IGNORE_ERROR(s) \
do { \
if (metric != METRIC_QUERY_RESULT) \
return (s); \
} while (0)
const char *
get_field_str (dbi_conn conn, dbi_result res, unsigned short field_type)
{
const char *str;
if (field_type != DBI_TYPE_STRING) {
printf ("CRITICAL - result value is not a string\n");
return NULL;
}
str = dbi_result_get_string_idx (res, 1);
if ((! str) || (strcmp (str, "ERROR") == 0)) {
CHECK_IGNORE_ERROR (NULL);
np_dbi_print_error (conn, "CRITICAL - failed to fetch string value");
return NULL;
}
if ((verbose && (type == TYPE_STRING)) || (verbose > 2))
printf ("Query returned string '%s'\n", str);
return str;
}
double
get_field (dbi_conn conn, dbi_result res, unsigned short *field_type)
{
double val = NAN;
if (*field_type == DBI_TYPE_INTEGER) {
val = (double)dbi_result_get_longlong_idx (res, 1);
}
else if (*field_type == DBI_TYPE_DECIMAL) {
val = dbi_result_get_double_idx (res, 1);
}
else if (*field_type == DBI_TYPE_STRING) {
const char *val_str;
char *endptr = NULL;
val_str = get_field_str (conn, res, *field_type);
if (! val_str) {
CHECK_IGNORE_ERROR (NAN);
*field_type = DBI_TYPE_ERROR;
return NAN;
}
val = strtod (val_str, &endptr);
if (endptr == val_str) {
CHECK_IGNORE_ERROR (NAN);
printf ("CRITICAL - result value is not a numeric: %s\n", val_str);
*field_type = DBI_TYPE_ERROR;
return NAN;
}
else if ((endptr != NULL) && (*endptr != '\0')) {
if (verbose)
printf ("Garbage after value: %s\n", endptr);
}
}
else {
CHECK_IGNORE_ERROR (NAN);
printf ("CRITICAL - cannot parse value of type %s (%i)\n",
(*field_type == DBI_TYPE_BINARY)
? "BINARY"
: (*field_type == DBI_TYPE_DATETIME)
? "DATETIME"
: "<unknown>",
*field_type);
*field_type = DBI_TYPE_ERROR;
return NAN;
}
return val;
}
double
get_query_result (dbi_conn conn, dbi_result res, const char **res_val_str, double *res_val)
{
unsigned short field_type;
double val = NAN;
if (dbi_result_get_numrows (res) == DBI_ROW_ERROR) {
CHECK_IGNORE_ERROR (STATE_OK);
np_dbi_print_error (conn, "CRITICAL - failed to fetch rows");
return STATE_CRITICAL;
}
if (dbi_result_get_numrows (res) < 1) {
CHECK_IGNORE_ERROR (STATE_OK);
printf ("WARNING - no rows returned\n");
return STATE_WARNING;
}
if (dbi_result_get_numfields (res) == DBI_FIELD_ERROR) {
CHECK_IGNORE_ERROR (STATE_OK);
np_dbi_print_error (conn, "CRITICAL - failed to fetch fields");
return STATE_CRITICAL;
}
if (dbi_result_get_numfields (res) < 1) {
CHECK_IGNORE_ERROR (STATE_OK);
printf ("WARNING - no fields returned\n");
return STATE_WARNING;
}
if (dbi_result_first_row (res) != 1) {
CHECK_IGNORE_ERROR (STATE_OK);
np_dbi_print_error (conn, "CRITICAL - failed to fetch first row");
return STATE_CRITICAL;
}
field_type = dbi_result_get_field_type_idx (res, 1);
if (field_type != DBI_TYPE_ERROR) {
if (type == TYPE_STRING)
/* the value will be freed in dbi_result_free */
*res_val_str = strdup (get_field_str (conn, res, field_type));
else
val = get_field (conn, res, &field_type);
}
*res_val = val;
if (field_type == DBI_TYPE_ERROR) {
CHECK_IGNORE_ERROR (STATE_OK);
np_dbi_print_error (conn, "CRITICAL - failed to fetch data");
return STATE_CRITICAL;
}
dbi_result_free (res);
return STATE_OK;
}
#undef CHECK_IGNORE_ERROR
int
do_query (dbi_conn conn, const char **res_val_str, double *res_val, double *res_time)
{
dbi_result res;
struct timeval timeval_start, timeval_end;
int status = STATE_OK;
assert (np_dbi_query);
if (verbose)
printf ("Executing query '%s'\n", np_dbi_query);
gettimeofday (&timeval_start, NULL);
res = dbi_conn_query (conn, np_dbi_query);
if (! res) {
np_dbi_print_error (conn, "CRITICAL - failed to execute query '%s'", np_dbi_query);
return STATE_CRITICAL;
}
status = get_query_result (conn, res, res_val_str, res_val);
gettimeofday (&timeval_end, NULL);
*res_time = timediff (timeval_start, timeval_end);
if (verbose)
printf ("Time elapsed: %f\n", *res_time);
return status;
}
double
timediff (struct timeval start, struct timeval end)
{
double diff;
while (start.tv_usec > end.tv_usec) {
--end.tv_sec;
end.tv_usec += 1000000;
}
diff = (double)(end.tv_sec - start.tv_sec)
+ (double)(end.tv_usec - start.tv_usec) / 1000000.0;
return diff;
}
void
np_dbi_print_error (dbi_conn conn, char *fmt, ...)
{
const char *errmsg = NULL;
va_list ap;
va_start (ap, fmt);
dbi_conn_error (conn, &errmsg);
vprintf (fmt, ap);
printf (": %s\n", errmsg);
va_end (ap);
}
Reference in a new issue View git blame Copy permalink