int
parse_timeout_string (char *timeout_str)
{
char *seperated_str;
char *timeout_val = "";
char *timeout_sta = NULL;
if ( strstr(timeout_str, ":" ) == NULL) {
timeout_val = timeout_str;
} else if ( strncmp(timeout_str, ":", 1 ) == 0) {
seperated_str = strtok(timeout_str, ":");
if ( seperated_str != NULL ) {
timeout_sta = seperated_str;
}
} else {
seperated_str = strtok(timeout_str, ":");
timeout_val = seperated_str;
seperated_str = strtok(NULL, ":");
if (seperated_str != NULL) {
timeout_sta = seperated_str;
}
}
if ( timeout_sta != NULL ) {
set_timeout_state(timeout_sta);
}
if (( timeout_val == NULL ) || ( timeout_val[0] == '\0' )) {
return timeout_interval;
} else if (is_intpos(timeout_val)) {
return atoi(timeout_val);
} else {
usage4 (_("Timeout value must be a positive integer"));
exit (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;
int option = 0;
static struct option longopts[] = {
{"hostname", required_argument, 0, 'H'},
{"community", required_argument, 0, 'C'},
/* {"critical", required_argument,0,'c'}, */
/* {"warning", required_argument,0,'w'}, */
{"port", required_argument,0,'p'},
{"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, "+hVH:C:p:", longopts, &option);
if (c == -1 || c == EOF || c == 1)
break;
switch (c) {
case 'H': /* hostname */
if (is_host (optarg)) {
address = strscpy(address, optarg) ;
}
else {
usage2 (_("Invalid hostname/address"), optarg);
}
break;
case 'C': /* community */
community = strscpy (community, optarg);
break;
case 'p':
if (!is_intpos(optarg))
usage2 (_("Port must be a positive short integer"), optarg);
else
port = atoi(optarg);
break;
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_UNKNOWN);
case 'h': /* help */
print_help ();
exit (STATE_UNKNOWN);
case '?': /* help */
usage5 ();
}
}
c = optind;
if (address == NULL) {
if (is_host (argv[c])) {
address = argv[c++];
}
else {
usage2 (_("Invalid hostname/address"), argv[c]);
}
}
if (community == NULL) {
if (argv[c] != NULL )
community = argv[c];
else
community = strdup (DEFAULT_COMMUNITY);
}
if (port == NULL) {
if (argv[c] != NULL )
port = argv[c];
else
port = atoi (DEFAULT_PORT);
}
return validate_arguments ();
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
int option = 0;
static struct option longopts[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"host", required_argument, 0, 'H'}, /* backward compatibility */
{"hostname", required_argument, 0, 'H'},
{"port", required_argument, 0, 'p'},
{"use-ipv4", no_argument, 0, '4'},
{"use-ipv6", no_argument, 0, '6'},
{"timeout", required_argument, 0, 't'},
{"verbose", no_argument, 0, 'v'},
{"remote-version", required_argument, 0, 'r'},
{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, "+Vhv46t:r:H:p:", longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case '?': /* help */
usage5 ();
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'h': /* help */
print_help ();
exit (STATE_OK);
case 'v': /* verbose */
verbose = TRUE;
break;
case 't': /* timeout period */
if (!is_integer (optarg))
usage2 (_("Timeout interval must be a positive integer"), optarg);
else
socket_timeout = atoi (optarg);
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 'r': /* remote version */
remote_version = optarg;
break;
case 'H': /* host */
if (is_host (optarg) == FALSE)
usage2 (_("Invalid hostname/address"), optarg);
server_name = optarg;
break;
case 'p': /* port */
if (is_intpos (optarg)) {
port = atoi (optarg);
}
else {
usage2 (_("Port number must be a positive integer"), optarg);
}
}
}
c = optind;
if (server_name == NULL && c < argc) {
if (is_host (argv[c])) {
server_name = argv[c++];
}
}
if (port == -1 && c < argc) {
if (is_intpos (argv[c])) {
port = atoi (argv[c++]);
}
else {
print_usage ();
exit (STATE_UNKNOWN);
}
}
return validate_arguments ();
}
/* 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;
char *rv[2];
int option = 0;
static struct option longopts[] = {
{"hostname", required_argument, 0, 'H'},
{"sourceip", required_argument, 0, 'S'},
{"sourceif", required_argument, 0, 'I'},
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"bytes", required_argument, 0, 'b'},
{"number", required_argument, 0, 'n'},
{"target-timeout", required_argument, 0, 'T'},
{"interval", required_argument, 0, 'i'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{"use-ipv4", no_argument, 0, '4'},
{"use-ipv6", no_argument, 0, '6'},
{0, 0, 0, 0}
};
rv[PL] = NULL;
rv[RTA] = NULL;
if (argc < 2)
return ERROR;
if (!is_option (argv[1])) {
server_name = argv[1];
argv[1] = argv[0];
argv = &argv[1];
argc--;
}
while (1) {
c = getopt_long (argc, argv, "+hVvH:S:c:w:b:n:T:i:I:46", 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 */
verbose = TRUE;
break;
case 'H': /* hostname */
if (is_host (optarg) == FALSE) {
usage2 (_("Invalid hostname/address"), optarg);
}
server_name = strscpy (server_name, optarg);
break;
case 'S': /* sourceip */
if (is_host (optarg) == FALSE) {
usage2 (_("Invalid hostname/address"), optarg);
}
sourceip = strscpy (sourceip, optarg);
break;
case 'I': /* sourceip */
sourceif = strscpy (sourceif, optarg);
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 'c':
get_threshold (optarg, rv);
if (rv[RTA]) {
crta = strtod (rv[RTA], NULL);
crta_p = TRUE;
rv[RTA] = NULL;
}
if (rv[PL]) {
cpl = atoi (rv[PL]);
cpl_p = TRUE;
rv[PL] = NULL;
}
break;
case 'w':
get_threshold (optarg, rv);
if (rv[RTA]) {
wrta = strtod (rv[RTA], NULL);
wrta_p = TRUE;
rv[RTA] = NULL;
}
if (rv[PL]) {
wpl = atoi (rv[PL]);
wpl_p = TRUE;
rv[PL] = NULL;
}
break;
case 'b': /* bytes per packet */
if (is_intpos (optarg))
packet_size = atoi (optarg);
else
usage (_("Packet size must be a positive integer"));
break;
case 'n': /* number of packets */
if (is_intpos (optarg))
packet_count = atoi (optarg);
else
usage (_("Packet count must be a positive integer"));
break;
case 'T': /* timeout in msec */
if (is_intpos (optarg))
target_timeout = atoi (optarg);
else
usage (_("Target timeout must be a positive integer"));
break;
case 'i': /* interval in msec */
if (is_intpos (optarg))
packet_interval = atoi (optarg);
else
usage (_("Interval must be a positive integer"));
break;
}
}
if (server_name == NULL)
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[] = {
{"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;
static struct option longopts[] = {
{"logfile", required_argument, 0, 'F'},
{"expires", required_argument, 0, 'e'},
{"aggregation", required_argument, 0, 'a'},
{"variable", required_argument, 0, 'v'},
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"label", required_argument, 0, 'l'},
{"units", required_argument, 0, 'u'},
{"variable", required_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, "hVF:e:a:v:c:w:l:u:", longopts,
&option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 'F': /* input file */
log_file = optarg;
break;
case 'e': /* ups name */
expire_minutes = atoi (optarg);
break;
case 'a': /* port */
if (!strcmp (optarg, "MAX"))
use_average = FALSE;
else
use_average = TRUE;
break;
case 'v':
variable_number = atoi (optarg);
if (variable_number < 1 || variable_number > 2)
usage4 (_("Invalid variable number"));
break;
case 'w': /* critical time threshold */
value_warning_threshold = strtoul (optarg, NULL, 10);
break;
case 'c': /* warning time threshold */
value_critical_threshold = strtoul (optarg, NULL, 10);
break;
case 'l': /* label */
label = optarg;
break;
case 'u': /* timeout */
units = optarg;
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 (log_file == NULL && argc > c) {
log_file = argv[c++];
}
if (expire_minutes <= 0 && argc > c) {
if (is_intpos (argv[c]))
expire_minutes = atoi (argv[c++]);
else
die (STATE_UNKNOWN,
_("%s is not a valid expiration time\nUse '%s -h' for additional help\n"),
argv[c], progname);
}
if (argc > c && strcmp (argv[c], "MAX") == 0) {
use_average = FALSE;
c++;
}
else if (argc > c && strcmp (argv[c], "AVG") == 0) {
use_average = TRUE;
c++;
}
if (argc > c && variable_number == -1) {
variable_number = atoi (argv[c++]);
if (variable_number < 1 || variable_number > 2) {
printf ("%s :", argv[c]);
usage (_("Invalid variable number\n"));
}
}
if (argc > c && value_warning_threshold == 0) {
value_warning_threshold = strtoul (argv[c++], NULL, 10);
}
if (argc > c && value_critical_threshold == 0) {
value_critical_threshold = strtoul (argv[c++], NULL, 10);
}
if (argc > c && strlen (label) == 0) {
label = argv[c++];
}
if (argc > c && strlen (units) == 0) {
units = argv[c++];
}
return validate_arguments ();
}