int
main (int argc, char *argv[])
{
LDAP *ld;
LDAPMessage *result;
/* should be int result = STATE_UNKNOWN; */
int status = STATE_UNKNOWN;
long microsec;
double elapsed_time;
/* for ldap tls */
int tls;
int version=3;
/* for entry counting */
LDAPMessage *next_entry;
int status_entries = STATE_OK;
int num_entries = 0;
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
if (strstr(argv[0],"check_ldaps")) {
xasprintf (&progname, "check_ldaps");
}
/* Parse extra opts if any */
argv=np_extra_opts (&argc, argv, progname);
if (process_arguments (argc, argv) == ERROR)
usage4 (_("Could not parse arguments"));
if (strstr(argv[0],"check_ldaps") && ! starttls && ! ssl_on_connect)
starttls = TRUE;
/* initialize alarm signal handling */
signal (SIGALRM, socket_timeout_alarm_handler);
/* set socket timeout */
alarm (timeout_interval);
/* get the start time */
gettimeofday (&tv, NULL);
/* initialize ldap */
if (ld_uri != NULL)
{
#ifdef HAVE_LDAP_INITIALIZE
int result = ldap_initialize(&ld, ld_uri);
if (result != LDAP_SUCCESS)
{
printf ("Failed to connect to LDAP server at %s: %s\n",
ld_uri, ldap_err2string(result));
return STATE_CRITICAL;
}
#else
printf ("Sorry, this version of %s was compiled without URI support!\n",
argv[0]);
return STATE_CRITICAL;
#endif
}
#ifdef HAVE_LDAP_INIT
else if (!(ld = ldap_init (ld_host, ld_port))) {
printf ("Could not connect to the server at port %i\n", ld_port);
return STATE_CRITICAL;
}
#else
else if (!(ld = ldap_open (ld_host, ld_port))) {
if (verbose)
ldap_perror(ld, "ldap_open");
printf (_("Could not connect to the server at port %i\n"), ld_port);
return STATE_CRITICAL;
}
#endif /* HAVE_LDAP_INIT */
#ifdef HAVE_LDAP_SET_OPTION
/* set ldap options */
if (ldap_set_option (ld, LDAP_OPT_PROTOCOL_VERSION, &ld_protocol) !=
LDAP_OPT_SUCCESS ) {
printf(_("Could not set protocol version %d\n"), ld_protocol);
return STATE_CRITICAL;
}
#endif
if (ld_port == LDAPS_PORT || ssl_on_connect) {
xasprintf (&SERVICE, "LDAPS");
#if defined(HAVE_LDAP_SET_OPTION) && defined(LDAP_OPT_X_TLS)
/* ldaps: set option tls */
tls = LDAP_OPT_X_TLS_HARD;
if (ldap_set_option (ld, LDAP_OPT_X_TLS, &tls) != LDAP_SUCCESS)
{
if (verbose)
ldap_perror(ld, "ldaps_option");
printf (_("Could not init TLS at port %i!\n"), ld_port);
return STATE_CRITICAL;
}
#else
printf (_("TLS not supported by the libraries!\n"));
return STATE_CRITICAL;
#endif /* LDAP_OPT_X_TLS */
} else if (starttls) {
xasprintf (&SERVICE, "LDAP-TLS");
#if defined(HAVE_LDAP_SET_OPTION) && defined(HAVE_LDAP_START_TLS_S)
/* ldap with startTLS: set option version */
if (ldap_get_option(ld,LDAP_OPT_PROTOCOL_VERSION, &version) == LDAP_OPT_SUCCESS )
{
if (version < LDAP_VERSION3)
{
version = LDAP_VERSION3;
ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &version);
}
}
/* call start_tls */
if (ldap_start_tls_s(ld, NULL, NULL) != LDAP_SUCCESS)
{
if (verbose)
ldap_perror(ld, "ldap_start_tls");
printf (_("Could not init startTLS at port %i!\n"), ld_port);
return STATE_CRITICAL;
}
#else
printf (_("startTLS not supported by the library, needs LDAPv3!\n"));
return STATE_CRITICAL;
#endif /* HAVE_LDAP_START_TLS_S */
}
/* bind to the ldap server */
if (ldap_bind_s (ld, ld_binddn, ld_passwd, LDAP_AUTH_SIMPLE) !=
LDAP_SUCCESS) {
if (verbose)
ldap_perror(ld, "ldap_bind");
printf (_("Could not bind to the LDAP server\n"));
return STATE_CRITICAL;
}
/* do a search of all objectclasses in the base dn */
if (ldap_search_s (ld, ld_base, (crit_entries!=NULL || warn_entries!=NULL) ? LDAP_SCOPE_SUBTREE : LDAP_SCOPE_BASE, ld_attr, NULL, 0, &result)
!= LDAP_SUCCESS) {
if (verbose)
ldap_perror(ld, "ldap_search");
printf (_("Could not search/find objectclasses in %s\n"), ld_base);
return STATE_CRITICAL;
} else if (crit_entries!=NULL || warn_entries!=NULL) {
num_entries = ldap_count_entries(ld, result);
}
/* unbind from the ldap server */
ldap_unbind (ld);
/* reset the alarm handler */
alarm (0);
/* calcutate the elapsed time and compare to thresholds */
microsec = deltime (tv);
elapsed_time = (double)microsec / 1.0e6;
if (crit_time!=UNDEFINED && elapsed_time>crit_time)
status = STATE_CRITICAL;
else if (warn_time!=UNDEFINED && elapsed_time>warn_time)
status = STATE_WARNING;
else
status = STATE_OK;
if(entries_thresholds != NULL) {
if (verbose) {
printf ("entries found: %d\n", num_entries);
print_thresholds("entry threasholds", entries_thresholds);
}
status_entries = get_status(num_entries, entries_thresholds);
if (status_entries == STATE_CRITICAL) {
status = STATE_CRITICAL;
} else if (status != STATE_CRITICAL) {
status = status_entries;
}
}
/* print out the result */
if (crit_entries!=NULL || warn_entries!=NULL) {
printf (_("LDAP %s - found %d entries in %.3f seconds|%s %s\n"),
state_text (status),
num_entries,
elapsed_time,
fperfdata ("time", elapsed_time, "s",
(int)warn_time, warn_time,
(int)crit_time, crit_time,
TRUE, 0, FALSE, 0),
sperfdata ("entries", (double)num_entries, "",
warn_entries,
crit_entries,
TRUE, 0.0, FALSE, 0.0));
} else {
printf (_("LDAP %s - %.3f seconds response time|%s\n"),
state_text (status),
elapsed_time,
fperfdata ("time", elapsed_time, "s",
(int)warn_time, warn_time,
(int)crit_time, crit_time,
TRUE, 0, FALSE, 0));
}
return status;
}
int main(int argc, char **argv){
char *ptr;
int data_val;
int return_code=STATE_OK;
thresholds *thresholds = NULL;
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)
usage(_("Could not parse arguments"));
/* Initialize the thresholds */
set_thresholds(&thresholds, warn_threshold, crit_threshold);
if(verbose)
print_thresholds("check_cluster", thresholds);
/* check the data values */
for(ptr=strtok(data_vals,",");ptr!=NULL;ptr=strtok(NULL,",")){
data_val=atoi(ptr);
if(check_type==CHECK_SERVICES){
switch(data_val){
case 0:
total_services_ok++;
break;
case 1:
total_services_warning++;
break;
case 2:
total_services_critical++;
break;
case 3:
total_services_unknown++;
break;
default:
break;
}
}
else{
switch(data_val){
case 0:
total_hosts_up++;
break;
case 1:
total_hosts_down++;
break;
case 2:
total_hosts_unreachable++;
break;
default:
break;
}
}
}
/* return the status of the cluster */
if(check_type==CHECK_SERVICES){
return_code=get_status(total_services_warning+total_services_unknown+total_services_critical, thresholds);
printf("CLUSTER %s: %s: %d ok, %d warning, %d unknown, %d critical\n",
state_text(return_code), (label==NULL)?"Service cluster":label,
total_services_ok,total_services_warning,
total_services_unknown,total_services_critical);
}
else{
return_code=get_status(total_hosts_down+total_hosts_unreachable, thresholds);
printf("CLUSTER %s: %s: %d up, %d down, %d unreachable\n",
state_text(return_code), (label==NULL)?"Host cluster":label,
total_hosts_up,total_hosts_down,total_hosts_unreachable);
}
return return_code;
}
int process_arguments (int argc, char **argv) {
int c;
int option = 0;
static struct option longopts[] = {
MP_LONGOPTS_DEFAULT,
MP_LONGOPTS_HOST,
MP_LONGOPTS_PORT,
{"extended-status", no_argument, NULL, (int) 'e'},
SNMP_LONGOPTS,
MP_LONGOPTS_END
};
if (argc < 3) {
print_help();
exit(STATE_UNKNOWN);
}
mp_snmp_version = SNMP_VERSION_1;
while (1) {
c = mp_getopt(&argc, &argv, MP_OPTSTR_DEFAULT"H:P:ew:c:W:Z:"SNMP_OPTSTR,
longopts, &option);
if (c == -1 || c == EOF)
break;
getopt_snmp(c);
switch (c) {
/* Hostname opt */
case 'H':
getopt_host(optarg, &hostname);
break;
/* Port opt */
case 'P':
getopt_port(optarg, &port);
break;
/* Plugin opt */
case 'e':
extended_status = 1;
break;
case 'w':
getopt_wc_at(c, optarg, &threshold_charge);
break;
case 'c':
getopt_wc_at(c, optarg, &threshold_charge);
break;
case 'W':
getopt_wc_at('w', optarg, &threshold_runtime);
break;
case 'Z':
getopt_wc_at('c', optarg, &threshold_runtime);
break;
}
}
if (mp_verbose > 0) {
print_thresholds("charge", threshold_charge);
print_thresholds("runtime", threshold_runtime);
}
/* sanity check: charge threshold */
if ((threshold_charge->warning->end < 0) ||
(threshold_charge->warning->end > 100)) {
usage("Warning charge threshold must be between 0 and 100.");
}
if ((threshold_charge->critical->end < 0) ||
(threshold_charge->critical->end > 100)) {
usage("Critical charge threshold must be between 0 and 100.");
}
if (threshold_charge->critical->end > threshold_charge->warning->end) {
usage("Warning charge threshold (%ld) must be larger than "
"critical charge threshold (%ld).",
(long) threshold_charge->warning->end,
(long) threshold_charge->critical->end);
}
/* sanity check: runtime threshold */
if (threshold_runtime->warning->end < 0) {
usage("Warning runtime threshold must be larher or equal to 0.");
}
if (threshold_runtime->critical->end < 0) {
usage("Critical runtime threshold must be larher or equal to 0.");
}
if (threshold_runtime->critical->end > threshold_runtime->warning->end) {
usage("Warning runtime threshold (%ld) must be larger than "
"runtime charge threshold (%ld).",
(long) threshold_runtime->warning->end,
(long) threshold_runtime->critical->end);
}
return(OK);
}
int main (int argc, char **argv) {
/* Local Vars */
CURL *curl;
char *url;
double size;
double time;
/* Set signal handling and alarm */
if (signal(SIGALRM, timeout_alarm_handler) == SIG_ERR)
critical("Setup SIGALRM trap failed!");
/* Process check arguments */
if (process_arguments(argc, argv) != OK)
unknown("Parsing arguments failed!");
/* Start plugin timeout */
alarm(mp_timeout);
/* Magik */
size_t urllen = strlen(hostname)+strlen(filename) + 9;
url = mp_malloc(urllen);
snprintf(url, urllen, "tftp://%s/%s", hostname, filename);
if (mp_verbose > 0) {
printf("CURL Version: %s\n", curl_version());
printf("Try fetch %s\n", url);
print_thresholds("fetch_thresholds", fetch_thresholds);
}
/* Init libcurl */
curl = mp_curl_init();
/* Setup request */
if (curl_easy_setopt(curl, CURLOPT_PROTOCOLS, CURLPROTO_TFTP) == CURLE_UNSUPPORTED_PROTOCOL)
unknown("libcurl don't support tftp.");
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, mp_curl_recv_blackhole);
if (port != 0)
curl_easy_setopt(curl, CURLOPT_LOCALPORT, port);
/* Perform Request */
mp_curl_perform(curl);
/* Get metric */
curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME, &time);
curl_easy_getinfo(curl, CURLINFO_SIZE_DOWNLOAD , &size);
/* Clenup libcurl */
curl_easy_cleanup(curl);
curl_global_cleanup();
mp_perfdata_float("time", (float)time, "s", fetch_thresholds);
free(url);
switch(get_status(time, fetch_thresholds)) {
case STATE_OK:
free_threshold(fetch_thresholds);
ok("Received %'.0fbyte in %fs.", size, time);
break;
case STATE_WARNING:
free_threshold(fetch_thresholds);
warning("Received %'.0fbyte in %fs.", size, time);
break;
case STATE_CRITICAL:
free_threshold(fetch_thresholds);
critical("Received %'.0fbyte in %fs.", size, time);
break;
}
free_threshold(fetch_thresholds);
critical("You should never reach this point.");
}
int main (int argc, char **argv) {
/* Local Vars */
CURL *curl;
struct mp_curl_data answer;
long int code;
int sb_wait = 0;
int sb_start = 0;
int sb_recv = 0;
int sb_send = 0;
int sb_keep = 0;
int sb_dns = 0;
int sb_close = 0;
int sb_log = 0;
int sb_grace = 0;
int sb_idle = 0;
int sb_open = 0;
char *buf = NULL, *key, *val;
char *server = NULL;
/* Set signal handling and alarm */
if (signal(SIGALRM, timeout_alarm_handler) == SIG_ERR)
critical("Setup SIGALRM trap failed!");
/* Process check arguments */
if (process_arguments(argc, argv) != OK)
unknown("Parsing arguments failed!");
/* Start plugin timeout */
alarm(mp_timeout);
/* Build query */
if (mp_verbose > 0) {
printf("CURL Version: %s\n", curl_version());
printf("Url: %s\n", url);
print_thresholds("open_thresholds", open_thresholds);
}
/* Headers */
struct mp_curl_header headers[] = {
{"Server", &server}, {NULL, NULL}
};
/* Init libcurl */
curl = mp_curl_init();
answer.data = NULL;
answer.size = 0;
/* Setup request */
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, mp_curl_recv_data);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&answer);
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, mp_curl_recv_header);
curl_easy_setopt(curl, CURLOPT_HEADERDATA, (void *)headers);
/* Get url */
code = mp_curl_perform(curl);
/* Cleanup libcurl */
curl_easy_cleanup(curl);
curl_global_cleanup();
if (mp_verbose > 1) {
printf("Code: %ld\n", code);
printf("Server: %s\n", server);
if (mp_verbose > 2) {
printf("Answer: '%s'\n", answer.data);
}
}
/* Parse Answer */
buf = answer.data;
while(*buf) {
val = strsep(&buf, "\n");
key = strsep(&val, ": ");
if (mp_verbose > 1) {
printf("%s => %s\n", key, val);
}
if(strcmp(key, "Scoreboard") == 0) {
for(; *val; val++) {
switch (*val) {
case '.':
sb_open++;
break;
case '_':
sb_wait++;
break;
case 'S':
sb_start++;
break;
case 'R':
sb_recv++;
break;
case 'W':
sb_send++;
break;
case 'K':
sb_keep++;
break;
case 'D':
sb_dns++;
break;
case 'C':
sb_close++;
break;
case 'L':
sb_log++;
break;
case 'G':
sb_grace++;
break;
case 'I':
sb_idle++;
break;
}
}
}
}
mp_perfdata_int("open", (long int)sb_open, "c", open_thresholds);
mp_perfdata_int("start", (long int)sb_start, "c", NULL);
mp_perfdata_int("read", (long int)sb_recv, "c", NULL);
mp_perfdata_int("write", (long int)sb_send, "c", NULL);
mp_perfdata_int("keep", (long int)sb_keep, "c", NULL);
mp_perfdata_int("dns", (long int)sb_dns, "c", NULL);
mp_perfdata_int("close", (long int)sb_close, "c", NULL);
mp_perfdata_int("log", (long int)sb_log, "c", NULL);
mp_perfdata_int("grace", (long int)sb_grace, "c", NULL);
mp_perfdata_int("idle", (long int)sb_idle, "c", NULL);
mp_perfdata_int("open", (long int)sb_open, "c", NULL);
/* free */
free(answer.data);
if (open_thresholds) {
switch(get_status(sb_open, open_thresholds)) {
case STATE_OK:
free_threshold(open_thresholds);
ok("Apache HTTPD status - %s", server);
break;
case STATE_WARNING:
free_threshold(open_thresholds);
warning("Apache HTTPD low on open slots - %s", server);
break;
case STATE_CRITICAL:
free_threshold(open_thresholds);
critical("Apache HTTPD not enough open slots - %s", server);
break;
}
}
ok("Apache HTTPD status - %s", server);
}
