int
get_threshold (char *arg, float *trta, int *tpl)
{
if (is_intnonneg (arg) && sscanf (arg, "%f", trta) == 1)
return OK;
else if (strpbrk (arg, ",:") && strstr (arg, "%") && sscanf (arg, "%f%*[:,]%d%%", trta, tpl) == 2)
return OK;
else if (strstr (arg, "%") && sscanf (arg, "%d%%", tpl) == 1)
return OK;
usage2 (_("%s: Warning threshold must be integer or percentage!\n\n"), arg);
return STATE_UNKNOWN;
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
int option = 0;
static struct option longopts[] = {
{"hostname", required_argument, 0, 'H'},
{"query_address", required_argument, 0, 'l'},
{"warning", required_argument, 0, 'w'},
{"critical", required_argument, 0, 'c'},
{"timeout", required_argument, 0, 't'},
{"dig-arguments", required_argument, 0, 'A'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{"record_type", required_argument, 0, 'T'},
{"expected_address", required_argument, 0, 'a'},
{"port", required_argument, 0, 'p'},
{"use-ipv4", no_argument, 0, '4'},
{"use-ipv6", no_argument, 0, '6'},
{0, 0, 0, 0}
};
if (argc < 2)
return ERROR;
while (1) {
c = getopt_long (argc, argv, "hVvt:l:H:w:c:T:p:a:A:46", longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 'h': /* help */
print_help ();
exit (STATE_UNKNOWN);
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_UNKNOWN);
case 'H': /* hostname */
host_or_die(optarg);
dns_server = optarg;
break;
case 'p': /* server port */
if (is_intpos (optarg)) {
server_port = atoi (optarg);
}
else {
usage_va(_("Port must be a positive integer - %s"), optarg);
}
break;
case 'l': /* address to lookup */
query_address = optarg;
break;
case 'w': /* warning */
if (is_nonnegative (optarg)) {
warning_interval = strtod (optarg, NULL);
}
else {
usage_va(_("Warning interval must be a positive integer - %s"), optarg);
}
break;
case 'c': /* critical */
if (is_nonnegative (optarg)) {
critical_interval = strtod (optarg, NULL);
}
else {
usage_va(_("Critical interval must be a positive integer - %s"), optarg);
}
break;
case 't': /* timeout */
if (is_intnonneg (optarg)) {
timeout_interval = atoi (optarg);
}
else {
usage_va(_("Timeout interval must be a positive integer - %s"), optarg);
}
break;
case 'A': /* dig arguments */
dig_args = strdup(optarg);
break;
case 'v': /* verbose */
verbose = TRUE;
break;
case 'T':
record_type = optarg;
break;
case 'a':
expected_address = optarg;
break;
case '4':
query_transport = "-4";
break;
case '6':
query_transport = "-6";
break;
default: /* usage5 */
usage5();
}
}
c = optind;
if (dns_server == NULL) {
if (c < argc) {
host_or_die(argv[c]);
dns_server = argv[c];
}
else {
if (strcmp(query_transport,"-6") == 0)
dns_server = strdup("::1");
else
dns_server = strdup ("127.0.0.1");
}
}
return validate_arguments ();
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
char* temp;
int option = 0;
static struct option longopts[] = {
{"hostname", required_argument, 0, 'H'},
{"expect", required_argument, 0, 'e'},
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"timeout", required_argument, 0, 't'},
{"port", required_argument, 0, 'p'},
{"from", required_argument, 0, 'f'},
{"fqdn", required_argument, 0, 'F'},
{"authtype", required_argument, 0, 'A'},
{"authuser", required_argument, 0, 'U'},
{"authpass", required_argument, 0, 'P'},
{"command", required_argument, 0, 'C'},
{"response", required_argument, 0, 'R'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"use-ipv4", no_argument, 0, '4'},
{"use-ipv6", no_argument, 0, '6'},
{"help", no_argument, 0, 'h'},
{"starttls",no_argument,0,'S'},
{"certificate",required_argument,0,'D'},
{"ignore-quit-failure",no_argument,0,'q'},
{0, 0, 0, 0}
};
if (argc < 2)
return ERROR;
for (c = 1; c < argc; c++) {
if (strcmp ("-to", argv[c]) == 0)
strcpy (argv[c], "-t");
else if (strcmp ("-wt", argv[c]) == 0)
strcpy (argv[c], "-w");
else if (strcmp ("-ct", argv[c]) == 0)
strcpy (argv[c], "-c");
}
while (1) {
c = getopt_long (argc, argv, "+hVv46t:p:f:e:c:w:H:C:R:SD:F:A:U:P:q",
longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 'H': /* hostname */
if (is_host (optarg)) {
server_address = optarg;
}
else {
usage2 (_("Invalid hostname/address"), optarg);
}
break;
case 'p': /* port */
if (is_intpos (optarg))
server_port = atoi (optarg);
else
usage4 (_("Port must be a positive integer"));
break;
case 'F':
/* localhostname */
localhostname = strdup(optarg);
break;
case 'f': /* from argument */
from_arg = optarg + strspn(optarg, "<");
from_arg = strndup(from_arg, strcspn(from_arg, ">"));
send_mail_from = 1;
break;
case 'A':
authtype = optarg;
use_ehlo = TRUE;
break;
case 'U':
authuser = optarg;
break;
case 'P':
authpass = optarg;
break;
case 'e': /* server expect string on 220 */
server_expect = optarg;
break;
case 'C': /* commands */
if (ncommands >= command_size) {
command_size+=8;
commands = realloc (commands, sizeof(char *) * command_size);
if (commands == NULL)
die (STATE_UNKNOWN,
_("Could not realloc() units [%d]\n"), ncommands);
}
commands[ncommands] = (char *) malloc (sizeof(char) * 255);
strncpy (commands[ncommands], optarg, 255);
ncommands++;
break;
case 'R': /* server responses */
if (nresponses >= response_size) {
response_size += 8;
responses = realloc (responses, sizeof(char *) * response_size);
if (responses == NULL)
die (STATE_UNKNOWN,
_("Could not realloc() units [%d]\n"), nresponses);
}
responses[nresponses] = (char *) malloc (sizeof(char) * 255);
strncpy (responses[nresponses], optarg, 255);
nresponses++;
break;
case 'c': /* critical time threshold */
if (!is_nonnegative (optarg))
usage4 (_("Critical time must be a positive"));
else {
critical_time = strtod (optarg, NULL);
check_critical_time = TRUE;
}
break;
case 'w': /* warning time threshold */
if (!is_nonnegative (optarg))
usage4 (_("Warning time must be a positive"));
else {
warning_time = strtod (optarg, NULL);
check_warning_time = TRUE;
}
break;
case 'v': /* verbose */
verbose++;
break;
case 'q':
ignore_send_quit_failure++; /* ignore problem sending QUIT */
break;
case 't': /* timeout */
if (is_intnonneg (optarg)) {
socket_timeout = atoi (optarg);
}
else {
usage4 (_("Timeout interval must be a positive integer"));
}
break;
case 'S':
/* starttls */
use_ssl = TRUE;
use_ehlo = TRUE;
break;
case 'D':
/* Check SSL cert validity */
#ifdef USE_OPENSSL
if ((temp=strchr(optarg,','))!=NULL) {
*temp='\0';
if (!is_intnonneg (optarg))
usage2 ("Invalid certificate expiration period", optarg);
days_till_exp_warn = atoi(optarg);
*temp=',';
temp++;
if (!is_intnonneg (temp))
usage2 (_("Invalid certificate expiration period"), temp);
days_till_exp_crit = atoi (temp);
}
else {
days_till_exp_crit=0;
if (!is_intnonneg (optarg))
usage2 ("Invalid certificate expiration period", optarg);
days_till_exp_warn = atoi (optarg);
}
check_cert = TRUE;
#else
usage (_("SSL support not available - install OpenSSL and recompile"));
#endif
break;
case '4':
address_family = AF_INET;
break;
case '6':
#ifdef USE_IPV6
address_family = AF_INET6;
#else
usage4 (_("IPv6 support not available"));
#endif
break;
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'h': /* help */
print_help ();
exit (STATE_OK);
case '?': /* help */
usage5 ();
}
}
c = optind;
if (server_address == NULL) {
if (argv[c]) {
if (is_host (argv[c]))
server_address = argv[c];
else
usage2 (_("Invalid hostname/address"), argv[c]);
}
else {
xasprintf (&server_address, "127.0.0.1");
}
}
if (server_expect == NULL)
server_expect = strdup (SMTP_EXPECT);
if (mail_command == NULL)
mail_command = strdup("MAIL ");
if (from_arg==NULL)
from_arg = strdup(" ");
return validate_arguments ();
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c, err;
struct parameter_list *se;
struct parameter_list *temp_list = NULL, *previous = NULL;
struct parameter_list *temp_path_select_list = NULL;
struct mount_entry *me, *temp_me;
int result = OK;
regex_t re;
int cflags = REG_NOSUB | REG_EXTENDED;
int default_cflags = cflags;
char errbuf[MAX_INPUT_BUFFER];
int fnd = 0;
int option = 0;
static struct option longopts[] = {
{"timeout", required_argument, 0, 't'},
{"warning", required_argument, 0, 'w'},
{"critical", required_argument, 0, 'c'},
{"iwarning", required_argument, 0, 'W'},
/* Dang, -C is taken. We might want to reshuffle this. */
{"icritical", required_argument, 0, 'K'},
{"kilobytes", no_argument, 0, 'k'},
{"megabytes", no_argument, 0, 'm'},
{"units", required_argument, 0, 'u'},
{"path", required_argument, 0, 'p'},
{"partition", required_argument, 0, 'p'},
{"exclude_device", required_argument, 0, 'x'},
{"exclude-type", required_argument, 0, 'X'},
{"include-type", required_argument, 0, 'N'},
{"newlines", no_argument, 0, 'n'},
{"group", required_argument, 0, 'g'},
{"eregi-path", required_argument, 0, 'R'},
{"eregi-partition", required_argument, 0, 'R'},
{"ereg-path", required_argument, 0, 'r'},
{"ereg-partition", required_argument, 0, 'r'},
{"freespace-ignore-reserved", no_argument, 0, 'f'},
{"ignore-ereg-path", required_argument, 0, 'i'},
{"ignore-ereg-partition", required_argument, 0, 'i'},
{"ignore-eregi-path", required_argument, 0, 'I'},
{"ignore-eregi-partition", required_argument, 0, 'I'},
{"local", no_argument, 0, 'l'},
{"stat-remote-fs", no_argument, 0, 'L'},
{"mountpoint", no_argument, 0, 'M'},
{"errors-only", no_argument, 0, 'e'},
{"exact-match", no_argument, 0, 'E'},
{"all", no_argument, 0, 'A'},
{"verbose", no_argument, 0, 'v'},
{"quiet", no_argument, 0, 'q'},
{"clear", no_argument, 0, 'C'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
if (argc < 2)
return ERROR;
np_add_name(&fs_exclude_list, "iso9660");
for (c = 1; c < argc; c++)
if (strcmp ("-to", argv[c]) == 0)
strcpy (argv[c], "-t");
while (1) {
c = getopt_long (argc, argv, "+?VqhvefCt:c:w:K:W:u:p:x:X:N:mklLg:R:r:i:I:MEAn", longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 't': /* timeout period */
if (is_integer (optarg)) {
timeout_interval = atoi (optarg);
break;
}
else {
usage2 (_("Timeout interval must be a positive integer"), optarg);
}
/* See comments for 'c' */
case 'w': /* warning threshold */
if (strstr(optarg, "%")) {
if (*optarg == '@') {
warn_freespace_percent = optarg;
} else {
xasprintf(&warn_freespace_percent, "@%s", optarg);
}
} else {
if (*optarg == '@') {
warn_freespace_units = optarg;
} else {
xasprintf(&warn_freespace_units, "@%s", optarg);
}
}
break;
/* Awful mistake where the range values do not make sense. Normally,
you alert if the value is within the range, but since we are using
freespace, we have to alert if outside the range. Thus we artifically
force @ at the beginning of the range, so that it is backwards compatible
*/
case 'c': /* critical threshold */
if (strstr(optarg, "%")) {
if (*optarg == '@') {
crit_freespace_percent = optarg;
} else {
xasprintf(&crit_freespace_percent, "@%s", optarg);
}
} else {
if (*optarg == '@') {
crit_freespace_units = optarg;
} else {
xasprintf(&crit_freespace_units, "@%s", optarg);
}
}
break;
case 'W': /* warning inode threshold */
if (*optarg == '@') {
warn_freeinodes_percent = optarg;
} else {
xasprintf(&warn_freeinodes_percent, "@%s", optarg);
}
break;
case 'K': /* critical inode threshold */
if (*optarg == '@') {
crit_freeinodes_percent = optarg;
} else {
xasprintf(&crit_freeinodes_percent, "@%s", optarg);
}
break;
case 'u':
if (units)
free(units);
if (! strcmp (optarg, "bytes")) {
mult = (uintmax_t)1;
units = strdup ("B");
} else if (! strcmp (optarg, "kB")) {
mult = (uintmax_t)1024;
units = strdup ("kB");
} else if (! strcmp (optarg, "MB")) {
mult = (uintmax_t)1024 * 1024;
units = strdup ("MB");
} else if (! strcmp (optarg, "GB")) {
mult = (uintmax_t)1024 * 1024 * 1024;
units = strdup ("GB");
} else if (! strcmp (optarg, "TB")) {
mult = (uintmax_t)1024 * 1024 * 1024 * 1024;
units = strdup ("TB");
} else {
die (STATE_UNKNOWN, _("unit type %s not known\n"), optarg);
}
if (units == NULL)
die (STATE_UNKNOWN, _("failed allocating storage for '%s'\n"), "units");
break;
case 'k': /* display mountpoint */
mult = 1024;
if (units)
free(units);
units = strdup ("kB");
break;
case 'm': /* display mountpoint */
mult = 1024 * 1024;
if (units)
free(units);
units = strdup ("MB");
break;
case 'L':
stat_remote_fs = 1;
case 'l':
show_local_fs = 1;
break;
case 'p': /* select path */
if (! (warn_freespace_units || crit_freespace_units || warn_freespace_percent ||
crit_freespace_percent || warn_usedspace_units || crit_usedspace_units ||
warn_usedspace_percent || crit_usedspace_percent || warn_usedinodes_percent ||
crit_usedinodes_percent || warn_freeinodes_percent || crit_freeinodes_percent )) {
die (STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set a threshold value before using -p\n"));
}
/* add parameter if not found. overwrite thresholds if path has already been added */
if (! (se = np_find_parameter(path_select_list, optarg))) {
se = np_add_parameter(&path_select_list, optarg);
}
se->group = group;
set_all_thresholds(se);
/* With autofs, it is required to stat() the path before re-populating the mount_list */
stat_path(se);
/* NB: We can't free the old mount_list "just like that": both list pointers and struct
* pointers are copied around. One of the reason it wasn't done yet is that other parts
* of check_disk need the same kind of cleanup so it'd better be done as a whole */
mount_list = read_file_system_list (0);
np_set_best_match(se, mount_list, exact_match);
path_selected = TRUE;
break;
case 'x': /* exclude path or partition */
np_add_name(&dp_exclude_list, optarg);
break;
case 'X': /* exclude file system type */
np_add_name(&fs_exclude_list, optarg);
break;
case 'N': /* include file system type */
np_add_name(&fs_include_list, optarg);
break;
case 'n': /* show each disk on a new line */
newlines = TRUE;
break;
case 'v': /* verbose */
verbose++;
break;
case 'q': /* TODO: this function should eventually go away (removed 2007-09-20) */
/* verbose--; **replaced by line below**. -q was only a broken way of implementing -e */
erronly = TRUE;
break;
case 'e':
erronly = TRUE;
break;
case 'E':
if (path_selected)
die (STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set -E before selecting paths\n"));
exact_match = TRUE;
break;
case 'f':
freespace_ignore_reserved = TRUE;
break;
case 'g':
if (path_selected)
die (STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set group value before selecting paths\n"));
group = optarg;
break;
case 'I':
cflags |= REG_ICASE;
case 'i':
if (!path_selected)
die (STATE_UNKNOWN, "DISK %s: %s\n", _("UNKNOWN"), _("Paths need to be selected before using -i/-I. Use -A to select all paths explicitly"));
err = regcomp(&re, optarg, cflags);
if (err != 0) {
regerror (err, &re, errbuf, MAX_INPUT_BUFFER);
die (STATE_UNKNOWN, "DISK %s: %s - %s\n",_("UNKNOWN"), _("Could not compile regular expression"), errbuf);
}
temp_list = path_select_list;
previous = NULL;
while (temp_list) {
if (temp_list->best_match) {
if (np_regex_match_mount_entry(temp_list->best_match, &re)) {
if (verbose >=3)
printf("ignoring %s matching regex\n", temp_list->name);
temp_list = np_del_parameter(temp_list, previous);
/* pointer to first element needs to be updated if first item gets deleted */
if (previous == NULL)
path_select_list = temp_list;
} else {
previous = temp_list;
temp_list = temp_list->name_next;
}
} else {
previous = temp_list;
temp_list = temp_list->name_next;
}
}
cflags = default_cflags;
break;
case 'A':
optarg = strdup(".*");
case 'R':
cflags |= REG_ICASE;
case 'r':
if (! (warn_freespace_units || crit_freespace_units || warn_freespace_percent ||
crit_freespace_percent || warn_usedspace_units || crit_usedspace_units ||
warn_usedspace_percent || crit_usedspace_percent || warn_usedinodes_percent ||
crit_usedinodes_percent || warn_freeinodes_percent || crit_freeinodes_percent )) {
die (STATE_UNKNOWN, "DISK %s: %s", _("UNKNOWN"), _("Must set a threshold value before using -r/-R\n"));
}
err = regcomp(&re, optarg, cflags);
if (err != 0) {
regerror (err, &re, errbuf, MAX_INPUT_BUFFER);
die (STATE_UNKNOWN, "DISK %s: %s - %s\n",_("UNKNOWN"), _("Could not compile regular expression"), errbuf);
}
for (me = mount_list; me; me = me->me_next) {
if (np_regex_match_mount_entry(me, &re)) {
fnd = TRUE;
if (verbose >= 3)
printf("%s %s matching expression %s\n", me->me_devname, me->me_mountdir, optarg);
/* add parameter if not found. overwrite thresholds if path has already been added */
if (! (se = np_find_parameter(path_select_list, me->me_mountdir))) {
se = np_add_parameter(&path_select_list, me->me_mountdir);
}
se->group = group;
set_all_thresholds(se);
}
}
if (!fnd)
die (STATE_UNKNOWN, "DISK %s: %s - %s\n",_("UNKNOWN"),
_("Regular expression did not match any path or disk"), optarg);
fnd = FALSE;
path_selected = TRUE;
np_set_best_match(path_select_list, mount_list, exact_match);
cflags = default_cflags;
break;
case 'M': /* display mountpoint */
display_mntp = TRUE;
break;
case 'C':
/* add all mount entries to path_select list if no partitions have been explicitly defined using -p */
if (path_selected == FALSE) {
struct parameter_list *path;
for (me = mount_list; me; me = me->me_next) {
if (! (path = np_find_parameter(path_select_list, me->me_mountdir)))
path = np_add_parameter(&path_select_list, me->me_mountdir);
path->best_match = me;
path->group = group;
set_all_thresholds(path);
}
}
warn_freespace_units = NULL;
crit_freespace_units = NULL;
warn_usedspace_units = NULL;
crit_usedspace_units = NULL;
warn_freespace_percent = NULL;
crit_freespace_percent = NULL;
warn_usedspace_percent = NULL;
crit_usedspace_percent = NULL;
warn_usedinodes_percent = NULL;
crit_usedinodes_percent = NULL;
warn_freeinodes_percent = NULL;
crit_freeinodes_percent = NULL;
path_selected = FALSE;
group = NULL;
break;
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'h': /* help */
print_help ();
exit (STATE_OK);
case '?': /* help */
usage (_("Unknown argument"));
}
}
/* Support for "check_disk warn crit [fs]" with thresholds at used% level */
c = optind;
if (warn_usedspace_percent == NULL && argc > c && is_intnonneg (argv[c]))
warn_usedspace_percent = argv[c++];
if (crit_usedspace_percent == NULL && argc > c && is_intnonneg (argv[c]))
crit_usedspace_percent = argv[c++];
if (argc > c && path == NULL) {
se = np_add_parameter(&path_select_list, strdup(argv[c++]));
path_selected = TRUE;
set_all_thresholds(se);
}
if (units == NULL) {
units = strdup ("MB");
mult = (uintmax_t)1024 * 1024;
}
return TRUE;
}
/* process command-line arguments */
static int
process_arguments (int argc, char **argv)
{
int c;
int escape = 0;
int option = 0;
static struct option longopts[] = {
{"hostname", required_argument, 0, 'H'},
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"critical-codes", required_argument, 0, 'C'},
{"warning-codes", required_argument, 0, 'W'},
{"timeout", required_argument, 0, 't'},
{"protocol", required_argument, 0, 'P'}, /* FIXME: Unhandled */
{"port", required_argument, 0, 'p'},
{"escape", no_argument, 0, 'E'},
{"all", no_argument, 0, 'A'},
{"send", required_argument, 0, 's'},
{"expect", required_argument, 0, 'e'},
{"maxbytes", required_argument, 0, 'm'},
{"quit", required_argument, 0, 'q'},
{"jail", no_argument, 0, 'j'},
{"delay", required_argument, 0, 'd'},
{"refuse", required_argument, 0, 'r'},
{"mismatch", required_argument, 0, 'M'},
{"use-ipv4", no_argument, 0, '4'},
{"use-ipv6", no_argument, 0, '6'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{"ssl", no_argument, 0, 'S'},
{"certificate", required_argument, 0, 'D'},
{0, 0, 0, 0}
};
if (argc < 2)
usage4 (_("No arguments found"));
/* backwards compatibility */
for (c = 1; c < argc; c++) {
if (strcmp ("-to", argv[c]) == 0)
strcpy (argv[c], "-t");
else if (strcmp ("-wt", argv[c]) == 0)
strcpy (argv[c], "-w");
else if (strcmp ("-ct", argv[c]) == 0)
strcpy (argv[c], "-c");
}
if (!is_option (argv[1])) {
server_address = argv[1];
argv[1] = argv[0];
argv = &argv[1];
argc--;
}
while (1) {
c = getopt_long (argc, argv, "+hVv46EAH:s:e:q:m:c:w:t:p:C:W:d:Sr:jD:M:",
longopts, &option);
if (c == -1 || c == EOF || c == 1)
break;
switch (c) {
case '?': /* print short usage statement if args not parsable */
usage5 ();
case 'h': /* help */
print_help ();
exit (STATE_OK);
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'v': /* verbose mode */
flags |= FLAG_VERBOSE;
break;
case '4':
address_family = AF_INET;
break;
case '6':
#ifdef USE_IPV6
address_family = AF_INET6;
#else
usage4 (_("IPv6 support not available"));
#endif
break;
case 'H': /* hostname */
server_address = optarg;
break;
case 'c': /* critical */
critical_time = strtod (optarg, NULL);
flags |= FLAG_TIME_CRIT;
break;
case 'j': /* hide output */
flags |= FLAG_HIDE_OUTPUT;
break;
case 'w': /* warning */
warning_time = strtod (optarg, NULL);
flags |= FLAG_TIME_WARN;
break;
case 'C':
crit_codes = realloc (crit_codes, ++crit_codes_count);
crit_codes[crit_codes_count - 1] = optarg;
break;
case 'W':
warn_codes = realloc (warn_codes, ++warn_codes_count);
warn_codes[warn_codes_count - 1] = optarg;
break;
case 't': /* timeout */
if (!is_intpos (optarg))
usage4 (_("Timeout interval must be a positive integer"));
else
socket_timeout = atoi (optarg);
break;
case 'p': /* port */
if (!is_intpos (optarg))
usage4 (_("Port must be a positive integer"));
else
server_port = atoi (optarg);
break;
case 'E':
escape = 1;
break;
case 's':
if (escape)
server_send = np_escaped_string(optarg);
else
asprintf(&server_send, "%s", optarg);
break;
case 'e': /* expect string (may be repeated) */
flags &= ~FLAG_EXACT_MATCH;
if (server_expect_count == 0)
server_expect = malloc (sizeof (char *) * (++server_expect_count));
else
server_expect = realloc (server_expect, sizeof (char *) * (++server_expect_count));
server_expect[server_expect_count - 1] = optarg;
break;
case 'm':
if (!is_intpos (optarg))
usage4 (_("Maxbytes must be a positive integer"));
else
maxbytes = strtol (optarg, NULL, 0);
break;
case 'q':
if (escape)
server_quit = np_escaped_string(optarg);
else
asprintf(&server_quit, "%s\r\n", optarg);
break;
case 'r':
if (!strncmp(optarg,"ok",2))
econn_refuse_state = STATE_OK;
else if (!strncmp(optarg,"warn",4))
econn_refuse_state = STATE_WARNING;
else if (!strncmp(optarg,"crit",4))
econn_refuse_state = STATE_CRITICAL;
else
usage4 (_("Refuse must be one of ok, warn, crit"));
break;
case 'M':
if (!strncmp(optarg,"ok",2))
expect_mismatch_state = STATE_OK;
else if (!strncmp(optarg,"warn",4))
expect_mismatch_state = STATE_WARNING;
else if (!strncmp(optarg,"crit",4))
expect_mismatch_state = STATE_CRITICAL;
else
usage4 (_("Mismatch must be one of ok, warn, crit"));
break;
case 'd':
if (is_intpos (optarg))
delay = atoi (optarg);
else
usage4 (_("Delay must be a positive integer"));
break;
case 'D': /* Check SSL cert validity - days 'til certificate expiration */
#ifdef HAVE_SSL
# ifdef USE_OPENSSL /* XXX */
if (!is_intnonneg (optarg))
usage2 (_("Invalid certificate expiration period"), optarg);
days_till_exp = atoi (optarg);
check_cert = TRUE;
flags |= FLAG_SSL;
break;
# endif /* USE_OPENSSL */
#endif
/* fallthrough if we don't have ssl */
case 'S':
#ifdef HAVE_SSL
flags |= FLAG_SSL;
#else
die (STATE_UNKNOWN, _("Invalid option - SSL is not available"));
#endif
break;
case 'A':
flags |= FLAG_MATCH_ALL;
break;
}
}
if (server_address == NULL)
usage4 (_("You must provide a server address"));
else if (server_address[0] != '/' && is_host (server_address) == FALSE)
die (STATE_CRITICAL, "%s %s - %s: %s\n", SERVICE, state_text(STATE_CRITICAL), _("Invalid hostname, address or socket"), server_address);
return TRUE;
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
int option = 0;
static struct option longopts[] = {
{"filename", required_argument, 0, 'F'},
{"expires", required_argument, 0, 'e'},
{"command", required_argument, 0, 'C'},
{"timeout", optional_argument, 0, 't'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{"verbose", no_argument, 0, 'v'},
{0, 0, 0, 0}
};
if (argc < 2)
return ERROR;
if (!is_option (argv[1])) {
status_log = argv[1];
if (is_intnonneg (argv[2]))
expire_minutes = atoi (argv[2]);
else
die (STATE_UNKNOWN,
_("Expiration time must be an integer (seconds)\n"));
process_string = argv[3];
return OK;
}
while (1) {
c = getopt_long (argc, argv, "+hVvF:C:e:t:", longopts, &option);
if (c == -1 || c == EOF || c == 1)
break;
switch (c) {
case 'h': /* help */
print_help ();
exit (STATE_OK);
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'F': /* status log */
status_log = optarg;
break;
case 'C': /* command */
process_string = optarg;
break;
case 'e': /* expiry time */
if (is_intnonneg (optarg))
expire_minutes = atoi (optarg);
else
die (STATE_UNKNOWN,
_("Expiration time must be an integer (seconds)\n"));
break;
case 't': /* timeout */
if (is_intnonneg (optarg))
timeout_interval = atoi (optarg);
else
die (STATE_UNKNOWN,
_("Timeout must be an integer (seconds)\n"));
break;
case 'v':
verbose++;
break;
default: /* print short usage_va statement if args not parsable */
usage5();
}
}
if (status_log == NULL)
die (STATE_UNKNOWN, _("You must provide the status_log\n"));
if (process_string == NULL)
die (STATE_UNKNOWN, _("You must provide a process string\n"));
return OK;
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
int option = 0;
static struct option longopts[] = {
{"hostname", required_argument, 0, 'H'},
{"warning-variance", required_argument, 0, 'w'},
{"critical-variance", required_argument, 0, 'c'},
{"warning-connect", required_argument, 0, 'W'},
{"critical-connect", required_argument, 0, 'C'},
{"port", required_argument, 0, 'p'},
{"udp", no_argument, 0, 'u'},
{"timeout", required_argument, 0, 't'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
if (argc < 2)
usage ("\n");
for (c = 1; c < argc; c++) {
if (strcmp ("-to", argv[c]) == 0)
strcpy (argv[c], "-t");
else if (strcmp ("-wd", argv[c]) == 0)
strcpy (argv[c], "-w");
else if (strcmp ("-cd", argv[c]) == 0)
strcpy (argv[c], "-c");
else if (strcmp ("-wt", argv[c]) == 0)
strcpy (argv[c], "-W");
else if (strcmp ("-ct", argv[c]) == 0)
strcpy (argv[c], "-C");
}
while (1) {
c = getopt_long (argc, argv, "hVH:w:c:W:C:p:t:u", longopts,
&option);
if (c == -1 || c == EOF)
break;
switch (c) {
case '?': /* print short usage statement if args not parsable */
usage5 ();
case 'h': /* help */
print_help ();
exit (STATE_OK);
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'H': /* hostname */
if (is_host (optarg) == FALSE)
usage2 (_("Invalid hostname/address"), optarg);
server_address = optarg;
break;
case 'w': /* warning-variance */
if (is_intnonneg (optarg)) {
warning_diff = strtoul (optarg, NULL, 10);
check_warning_diff = TRUE;
}
else if (strspn (optarg, "0123456789:,") > 0) {
if (sscanf (optarg, "%lu%*[:,]%d", &warning_diff, &warning_time) == 2) {
check_warning_diff = TRUE;
check_warning_time = TRUE;
}
else {
usage4 (_("Warning thresholds must be a positive integer"));
}
}
else {
usage4 (_("Warning threshold must be a positive integer"));
}
break;
case 'c': /* critical-variance */
if (is_intnonneg (optarg)) {
critical_diff = strtoul (optarg, NULL, 10);
check_critical_diff = TRUE;
}
else if (strspn (optarg, "0123456789:,") > 0) {
if (sscanf (optarg, "%lu%*[:,]%d", &critical_diff, &critical_time) ==
2) {
check_critical_diff = TRUE;
check_critical_time = TRUE;
}
else {
usage4 (_("Critical thresholds must be a positive integer"));
}
}
else {
usage4 (_("Critical threshold must be a positive integer"));
}
break;
case 'W': /* warning-connect */
if (!is_intnonneg (optarg))
usage4 (_("Warning threshold must be a positive integer"));
else
warning_time = atoi (optarg);
check_warning_time = TRUE;
break;
case 'C': /* critical-connect */
if (!is_intnonneg (optarg))
usage4 (_("Critical threshold must be a positive integer"));
else
critical_time = atoi (optarg);
check_critical_time = TRUE;
break;
case 'p': /* port */
if (!is_intnonneg (optarg))
usage4 (_("Port must be a positive integer"));
else
server_port = atoi (optarg);
break;
case 't': /* timeout */
if (!is_intnonneg (optarg))
usage2 (_("Timeout interval must be a positive integer"), optarg);
else
socket_timeout = atoi (optarg);
break;
case 'u': /* udp */
use_udp = TRUE;
}
}
c = optind;
if (server_address == NULL) {
if (argc > c) {
if (is_host (argv[c]) == FALSE)
usage2 (_("Invalid hostname/address"), optarg);
server_address = argv[c];
}
else {
usage4 (_("Hostname was not supplied"));
}
}
return OK;
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
int option = 0;
static struct option longopts[] = {
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
if (argc < 2)
usage ("\n");
while (1) {
c = getopt_long (argc, argv, "+hVvc:w:", longopts, &option);
if (c == -1 || c == EOF || c == 1)
break;
switch (c) {
case '?': /* print short usage statement if args not parsable */
usage5 ();
case 'h': /* help */
print_help ();
exit (STATE_OK);
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'c': /* critical */
if (!is_intnonneg (optarg))
usage4 (_("Critical threshold must be a positive integer"));
else
cusers = atoi (optarg);
break;
case 'w': /* warning */
if (!is_intnonneg (optarg))
usage4 (_("Warning threshold must be a positive integer"));
else
wusers = atoi (optarg);
break;
}
}
c = optind;
if (wusers == -1 && argc > c) {
if (is_intnonneg (argv[c]) == FALSE)
usage4 (_("Warning threshold must be a positive integer"));
else
wusers = atoi (argv[c++]);
}
if (cusers == -1 && argc > c) {
if (is_intnonneg (argv[c]) == FALSE)
usage4 (_("Warning threshold must be a positive integer"));
else
cusers = atoi (argv[c]);
}
return OK;
}
/* process command-line arguments */
int process_arguments(int argc, char **argv){
int c;
int option = 0;
static struct option longopts[] =
{
{"port", required_argument,0,'p'},
{"timeout", required_argument,0,'t'},
{"critical", required_argument,0,'c'},
{"warning", required_argument,0,'w'},
{"variable", required_argument,0,'v'},
{"hostname", required_argument,0,'H'},
{"params", required_argument,0,'l'},
{"secret", required_argument,0,'s'},
{"display", required_argument,0,'d'},
{"unknown-timeout", no_argument, 0, 'u'},
{"version", no_argument, 0,'V'},
{"help", no_argument, 0,'h'},
{0,0,0,0}
};
/* no options were supplied */
if(argc<2) return ERROR;
/* backwards compatibility */
if (! is_option(argv[1])) {
server_address = strdup(argv[1]);
argv[1]=argv[0];
argv=&argv[1];
argc--;
}
for (c=1;c<argc;c++) {
if(strcmp("-to",argv[c])==0)
strcpy(argv[c],"-t");
else if (strcmp("-wv",argv[c])==0)
strcpy(argv[c],"-w");
else if (strcmp("-cv",argv[c])==0)
strcpy(argv[c],"-c");
}
while (1) {
c = getopt_long(argc,argv,"+hVH:t:c:w:p:v:l:s:d:u",longopts,&option);
if (c==-1||c==EOF||c==1)
break;
switch (c) {
case '?': /* print short usage statement if args not parsable */
usage5 ();
case 'h': /* help */
print_help();
exit(STATE_OK);
case 'V': /* version */
print_revision(progname, NP_VERSION);
exit(STATE_OK);
case 'H': /* hostname */
server_address = optarg;
break;
case 's': /* password */
req_password = optarg;
break;
case 'p': /* port */
if (is_intnonneg(optarg))
server_port=atoi(optarg);
else
die(STATE_UNKNOWN,_("Server port must be an integer\n"));
break;
case 'v':
if(strlen(optarg)<4)
return ERROR;
if(!strcmp(optarg,"CLIENTVERSION"))
vars_to_check=CHECK_CLIENTVERSION;
else if(!strcmp(optarg,"CPULOAD"))
vars_to_check=CHECK_CPULOAD;
else if(!strcmp(optarg,"UPTIME"))
vars_to_check=CHECK_UPTIME;
else if(!strcmp(optarg,"USEDDISKSPACE"))
vars_to_check=CHECK_USEDDISKSPACE;
else if(!strcmp(optarg,"SERVICESTATE"))
vars_to_check=CHECK_SERVICESTATE;
else if(!strcmp(optarg,"PROCSTATE"))
vars_to_check=CHECK_PROCSTATE;
else if(!strcmp(optarg,"MEMUSE"))
vars_to_check=CHECK_MEMUSE;
else if(!strcmp(optarg,"COUNTER"))
vars_to_check=CHECK_COUNTER;
else if(!strcmp(optarg,"FILEAGE"))
vars_to_check=CHECK_FILEAGE;
else if(!strcmp(optarg,"INSTANCES"))
vars_to_check=CHECK_INSTANCES;
else
return ERROR;
break;
case 'l': /* value list */
value_list = optarg;
break;
case 'w': /* warning threshold */
warning_value=strtoul(optarg,NULL,10);
check_warning_value=TRUE;
break;
case 'c': /* critical threshold */
critical_value=strtoul(optarg,NULL,10);
check_critical_value=TRUE;
break;
case 'd': /* Display select for services */
if (!strcmp(optarg,"SHOWALL"))
show_all = TRUE;
break;
case 'u':
socket_timeout_state=STATE_UNKNOWN;
break;
case 't': /* timeout */
socket_timeout=atoi(optarg);
if(socket_timeout<=0)
return ERROR;
}
}
if (server_address == NULL)
usage4 (_("You must provide a server address or host name"));
if (vars_to_check==CHECK_NONE)
return ERROR;
if (req_password == NULL)
req_password = strdup (_("None"));
return OK;
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
int option = 0;
static struct option longopts[] = {
{"hostname", required_argument, 0, 'H'},
{"IPaddress", required_argument, 0, 'I'},
{"expect", required_argument, 0, 'e'},
{"url", required_argument, 0, 'u'},
{"port", required_argument, 0, 'p'},
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"timeout", required_argument, 0, 't'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
if (argc < 2)
return ERROR;
for (c = 1; c < argc; c++) {
if (strcmp ("-to", argv[c]) == 0)
strcpy (argv[c], "-t");
else if (strcmp ("-wt", argv[c]) == 0)
strcpy (argv[c], "-w");
else if (strcmp ("-ct", argv[c]) == 0)
strcpy (argv[c], "-c");
}
while (1) {
c = getopt_long (argc, argv, "+hvVI:H:e:u:p:w:c:t:", longopts,
&option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 'I': /* hostname */
case 'H': /* hostname */
if (server_address)
break;
else if (is_host (optarg))
server_address = optarg;
else
usage2 (_("Invalid hostname/address"), optarg);
break;
case 'e': /* string to expect in response header */
server_expect = optarg;
break;
case 'u': /* server URL */
server_url = optarg;
break;
case 'p': /* port */
if (is_intpos (optarg)) {
server_port = atoi (optarg);
}
else {
usage4 (_("Port must be a positive integer"));
}
break;
case 'w': /* warning time threshold */
if (is_intnonneg (optarg)) {
warning_time = atoi (optarg);
check_warning_time = TRUE;
}
else {
usage4 (_("Warning time must be a positive integer"));
}
break;
case 'c': /* critical time threshold */
if (is_intnonneg (optarg)) {
critical_time = atoi (optarg);
check_critical_time = TRUE;
}
else {
usage4 (_("Critical time must be a positive integer"));
}
break;
case 'v': /* verbose */
verbose = TRUE;
break;
case 't': /* timeout */
if (is_intnonneg (optarg)) {
socket_timeout = atoi (optarg);
}
else {
usage4 (_("Timeout interval must be a positive integer"));
}
break;
case 'V': /* version */
print_revision (progname, revision);
exit (STATE_OK);
case 'h': /* help */
print_help ();
exit (STATE_OK);
case '?': /* usage */
usage5 ();
}
}
c = optind;
if (server_address==NULL && argc>c) {
if (is_host (argv[c])) {
server_address = argv[c++];
}
else {
usage2 (_("Invalid hostname/address"), argv[c]);
}
}
if (server_address==NULL)
usage4 (_("You must provide a server to check"));
if (host_name==NULL)
host_name = strdup (server_address);
if (server_expect == NULL)
server_expect = strdup(EXPECT);
return validate_arguments ();
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
int option = 0;
/* initialize the long option struct */
static struct option longopts[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"timeout", required_argument, 0, 't'},
{"hostname", required_argument, 0, 'H'},
{"base", required_argument, 0, 'b'},
{"attr", required_argument, 0, 'a'},
{"bind", required_argument, 0, 'D'},
{"pass", required_argument, 0, 'P'},
#ifdef HAVE_LDAP_SET_OPTION
{"ver2", no_argument, 0, '2'},
{"ver3", no_argument, 0, '3'},
#endif
{"starttls", no_argument, 0, 'T'},
{"ssl", no_argument, 0, 'S'},
{"use-ipv4", no_argument, 0, '4'},
{"use-ipv6", no_argument, 0, '6'},
{"port", required_argument, 0, 'p'},
{"warn", required_argument, 0, 'w'},
{"crit", required_argument, 0, 'c'},
{"verbose", no_argument, 0, 'v'},
{0, 0, 0, 0}
};
if (argc < 2)
return ERROR;
for (c = 1; c < argc; c++) {
if (strcmp ("-to", argv[c]) == 0)
strcpy (argv[c], "-t");
}
while (1) {
c = getopt_long (argc, argv, "hvV234TS6t:c:w:H:b:p:a:D:P:", longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 'h': /* help */
print_help ();
exit (STATE_OK);
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 't': /* timeout period */
if (!is_intnonneg (optarg))
usage2 (_("Timeout interval must be a positive integer"), optarg);
else
socket_timeout = atoi (optarg);
break;
case 'H':
ld_host = optarg;
break;
case 'b':
ld_base = optarg;
break;
case 'p':
ld_port = atoi (optarg);
break;
case 'a':
ld_attr = optarg;
break;
case 'D':
ld_binddn = optarg;
break;
case 'P':
ld_passwd = optarg;
break;
case 'w':
warn_time = strtod (optarg, NULL);
break;
case 'c':
crit_time = strtod (optarg, NULL);
break;
#ifdef HAVE_LDAP_SET_OPTION
case '2':
ld_protocol = 2;
break;
case '3':
ld_protocol = 3;
break;
#endif
case '4':
address_family = AF_INET;
break;
case 'v':
verbose++;
break;
case 'T':
if (! ssl_on_connect)
starttls = TRUE;
else
usage_va(_("%s cannot be combined with %s"), "-T/--starttls", "-S/--ssl");
break;
case 'S':
if (! starttls) {
ssl_on_connect = TRUE;
if (ld_port == -1)
ld_port = LDAPS_PORT;
} else
usage_va(_("%s cannot be combined with %s"), "-S/--ssl", "-T/--starttls");
break;
case '6':
#ifdef USE_IPV6
address_family = AF_INET6;
#else
usage (_("IPv6 support not available\n"));
#endif
break;
default:
usage5 ();
}
}
c = optind;
if (ld_host == NULL && is_host(argv[c]))
ld_host = strdup (argv[c++]);
if (ld_base == NULL && argv[c])
ld_base = strdup (argv[c++]);
if (ld_port == -1)
ld_port = DEFAULT_PORT;
return validate_arguments ();
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
char *warning = NULL;
char *critical = NULL;
int option = 0;
static struct option longopts[] = {
{"hostname", required_argument, 0, 'H'},
{"socket", required_argument, 0, 's'},
{"database", required_argument, 0, 'd'},
{"username", required_argument, 0, 'u'},
{"password", required_argument, 0, 'p'},
{"file", required_argument, 0, 'f'},
{"group", required_argument, 0, 'g'},
{"port", required_argument, 0, 'P'},
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"check-slave", no_argument, 0, 'S'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
if (argc < 1)
return ERROR;
while (1) {
c = getopt_long (argc, argv, "hvVSP:p:u:d:f:g:H:s:c:w:", longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 'H': /* hostname */
if (is_host (optarg)) {
db_host = optarg;
}
else {
usage2 (_("Invalid hostname/address"), optarg);
}
break;
case 's': /* socket */
db_socket = optarg;
break;
case 'd': /* database */
db = optarg;
break;
case 'u': /* username */
db_user = optarg;
break;
case 'p': /* authentication information: password */
db_pass = strdup(optarg);
/* Delete the password from process list */
while (*optarg != '\0') {
*optarg = 'X';
optarg++;
}
break;
case 'f': /* username */
opt_file = optarg;
break;
case 'g': /* username */
opt_group = optarg;
break;
case 'P': /* critical time threshold */
db_port = atoi (optarg);
break;
case 'S':
check_slave = 1; /* check-slave */
break;
case 'w':
warning = optarg;
break;
case 'c':
critical = optarg;
break;
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'h': /* help */
print_help ();
exit (STATE_OK);
case 'v':
verbose++;
break;
case '?': /* help */
usage5 ();
}
}
c = optind;
set_thresholds(&my_threshold, warning, critical);
while ( argc > c ) {
if (db_host == NULL)
if (is_host (argv[c])) {
db_host = argv[c++];
}
else {
usage2 (_("Invalid hostname/address"), argv[c]);
}
else if (db_user == NULL)
db_user = argv[c++];
else if (opt_file == NULL)
opt_file = argv[c++];
else if (opt_group == NULL)
opt_group = argv[c++];
else if (db_pass == NULL)
db_pass = argv[c++];
else if (db == NULL)
db = argv[c++];
else if (is_intnonneg (argv[c]))
db_port = atoi (argv[c++]);
else
break;
}
return validate_arguments ();
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c = 1;
char *ptr;
int option = 0;
static struct option longopts[] = {
STD_LONG_OPTS,
{"packets", required_argument, 0, 'p'},
{"nohtml", no_argument, 0, 'n'},
{"link", no_argument, 0, 'L'},
{"use-ipv4", no_argument, 0, '4'},
{"use-ipv6", no_argument, 0, '6'},
{0, 0, 0, 0}
};
if (argc < 2)
return ERROR;
for (c = 1; c < argc; c++) {
if (strcmp ("-to", argv[c]) == 0)
strcpy (argv[c], "-t");
if (strcmp ("-nohtml", argv[c]) == 0)
strcpy (argv[c], "-n");
}
while (1) {
c = getopt_long (argc, argv, "VvhnL46t:c:w:H:p:", longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case '?': /* usage */
usage5 ();
case 'h': /* help */
print_help ();
exit (STATE_UNKNOWN);
break;
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_UNKNOWN);
break;
case 't': /* timeout period */
timeout_interval = atoi (optarg);
break;
case 'v': /* verbose mode */
verbose++;
break;
case '4': /* IPv4 only */
address_family = AF_INET;
break;
case '6': /* IPv6 only */
#ifdef USE_IPV6
address_family = AF_INET6;
#else
usage (_("IPv6 support not available\n"));
#endif
break;
case 'H': /* hostname */
ptr=optarg;
while (1) {
n_addresses++;
if (n_addresses > max_addr) {
max_addr *= 2;
addresses = realloc (addresses, sizeof(char*) * max_addr);
if (addresses == NULL)
die (STATE_UNKNOWN, _("Could not realloc() addresses\n"));
}
addresses[n_addresses-1] = ptr;
if ((ptr = index (ptr, ','))) {
strcpy (ptr, "");
ptr += sizeof(char);
} else {
break;
}
}
break;
case 'p': /* number of packets to send */
if (is_intnonneg (optarg))
max_packets = atoi (optarg);
else
usage2 (_("<max_packets> (%s) must be a non-negative number\n"), optarg);
break;
case 'n': /* no HTML */
display_html = FALSE;
break;
case 'L': /* show HTML */
display_html = TRUE;
break;
case 'c':
get_threshold (optarg, &crta, &cpl);
break;
case 'w':
get_threshold (optarg, &wrta, &wpl);
break;
}
}
c = optind;
if (c == argc)
return validate_arguments ();
if (addresses[0] == NULL) {
if (is_host (argv[c]) == FALSE) {
usage2 (_("Invalid hostname/address"), argv[c]);
} else {
addresses[0] = argv[c++];
n_addresses++;
if (c == argc)
return validate_arguments ();
}
}
if (wpl == UNKNOWN_PACKET_LOSS) {
if (is_intpercent (argv[c]) == FALSE) {
printf (_("<wpl> (%s) must be an integer percentage\n"), argv[c]);
return ERROR;
} else {
wpl = atoi (argv[c++]);
if (c == argc)
return validate_arguments ();
}
}
if (cpl == UNKNOWN_PACKET_LOSS) {
if (is_intpercent (argv[c]) == FALSE) {
printf (_("<cpl> (%s) must be an integer percentage\n"), argv[c]);
return ERROR;
} else {
cpl = atoi (argv[c++]);
if (c == argc)
return validate_arguments ();
}
}
if (wrta < 0.0) {
if (is_negative (argv[c])) {
printf (_("<wrta> (%s) must be a non-negative number\n"), argv[c]);
return ERROR;
} else {
wrta = atof (argv[c++]);
if (c == argc)
return validate_arguments ();
}
}
if (crta < 0.0) {
if (is_negative (argv[c])) {
printf (_("<crta> (%s) must be a non-negative number\n"), argv[c]);
return ERROR;
} else {
crta = atof (argv[c++]);
if (c == argc)
return validate_arguments ();
}
}
if (max_packets == -1) {
if (is_intnonneg (argv[c])) {
max_packets = atoi (argv[c++]);
} else {
printf (_("<max_packets> (%s) must be a non-negative number\n"), argv[c]);
return ERROR;
}
}
return validate_arguments ();
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c = 0; /* option character */
int option = 0;
static struct option longopts[] = {
{"warning", required_argument, 0, 'w'},
{"critical", required_argument, 0, 'c'},
{"allswaps", no_argument, 0, 'a'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
if (argc < 2)
return ERROR;
while (1) {
c = getopt_long (argc, argv, "+?Vvhac:w:", longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 'w': /* warning size threshold */
if (is_intnonneg (optarg)) {
warn_size_bytes = (float) atoi (optarg);
break;
}
else if (strstr (optarg, ",") &&
strstr (optarg, "%") &&
sscanf (optarg, "%f,%d%%", &warn_size_bytes, &warn_percent) == 2) {
warn_size_bytes = floorf(warn_size_bytes);
break;
}
else if (strstr (optarg, "%") &&
sscanf (optarg, "%d%%", &warn_percent) == 1) {
break;
}
else {
usage4 (_("Warning threshold must be integer or percentage!"));
}
case 'c': /* critical size threshold */
if (is_intnonneg (optarg)) {
crit_size_bytes = (float) atoi (optarg);
break;
}
else if (strstr (optarg, ",") &&
strstr (optarg, "%") &&
sscanf (optarg, "%f,%d%%", &crit_size_bytes, &crit_percent) == 2) {
crit_size_bytes = floorf(crit_size_bytes);
break;
}
else if (strstr (optarg, "%") &&
sscanf (optarg, "%d%%", &crit_percent) == 1) {
break;
}
else {
usage4 (_("Critical threshold must be integer or percentage!"));
}
case 'a': /* all swap */
allswaps = TRUE;
break;
case 'v': /* verbose */
verbose++;
break;
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'h': /* help */
print_help ();
exit (STATE_OK);
case '?': /* error */
usage5 ();
}
}
c = optind;
if (c == argc)
return validate_arguments ();
if (warn_percent == 0 && is_intnonneg (argv[c]))
warn_percent = atoi (argv[c++]);
if (c == argc)
return validate_arguments ();
if (crit_percent == 0 && is_intnonneg (argv[c]))
crit_percent = atoi (argv[c++]);
if (c == argc)
return validate_arguments ();
if (warn_size_bytes == 0 && is_intnonneg (argv[c]))
warn_size_bytes = (float) atoi (argv[c++]);
if (c == argc)
return validate_arguments ();
if (crit_size_bytes == 0 && is_intnonneg (argv[c]))
crit_size_bytes = (float) atoi (argv[c++]);
return validate_arguments ();
}
