Status NEGEMMLowpAArch64V8P4Kernel::validate(const ITensorInfo *input0, const ITensorInfo *input1, const ITensorInfo *output)
{
ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input0, input1, output));
ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window(input0->clone().get(), input1->clone().get(), output->clone().get()).first);
return Status{};
}
/* process command-line arguments */
int process_arguments(int argc, char **argv){
int arg_index;
if(argc<1)
return ERROR;
arg_index = call_getopt(argc,argv);
return validate_arguments(argc,arg_index);
}
static int process_arguments (int argc, char **argv) {
int c;
int escape = 0;
char *temp;
int option = 0;
static struct option longopts[] = {
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"timeunit", required_argument, 0, 'u'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
while ( 1 ) {
c = getopt_long ( argc, argv, "+hvVu:c:w:", longopts, &option );
if ( c == -1 || c == EOF || c == 1 ) break;
switch ( c ) {
case '?':
usage5 ();
case 'h':
print_help ();
exit ( STATE_OK );
case 'v':
verbose++;
if (verbose >= 3) {
printf("Verbose mode enabled\n");
}
break;
case 'V':
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'u':
timeunit = optarg;
break;
case 'c':
critical = optarg;
break;
case 'w':
warning = optarg;
break;
} // end case
} // end while
c = optind;
set_thresholds(&my_thresholds, warning, critical);
return validate_arguments ();
} // end process_arguments
/* process command-line arguments */
int process_arguments(int argc, char **argv){
int c;
if(argc<1)
return ERROR;
c=0;
while((c+=(call_getopt(argc-c,&argv[c])))<argc){
/*
if(is_option(argv[c]))
continue;
*/
}
return validate_arguments();
}
void settings_controller::get_key(Mongoose::Request &request, boost::smatch &what, Mongoose::StreamResponse &response) {
if (!session->is_loggedin("settings", request, response))
return;
if (!validate_arguments(2, what, response)) {
return;
}
std::string path = what.str(1);
std::string key = what.str(2);
if (!session->can("settings.get", request, response))
return;
Plugin::SettingsRequestMessage rm;
Plugin::SettingsRequestMessage::Request *payload = rm.add_payload();
payload->mutable_query()->mutable_node()->set_path(path);
payload->mutable_query()->mutable_node()->set_key(key);
payload->mutable_query()->set_recursive(false);
payload->set_plugin_id(plugin_id);
std::string str_response;
core->settings_query(rm.SerializeAsString(), str_response);
Plugin::SettingsResponseMessage pb_response;
pb_response.ParseFromString(str_response);
json_spirit::Object node;
BOOST_FOREACH(const Plugin::SettingsResponseMessage::Response r, pb_response.payload()) {
if (!r.has_query()) {
response.setCode(HTTP_NOT_FOUND);
response.append("Key not found: " + path + "/" + key);
return;
}
const Plugin::SettingsResponseMessage::Response::Query &i = r.query();
node["path"] = i.node().path();
node["key"] = i.node().key();
if (i.value().has_string_data()) {
node["value"] = i.value().string_data();
} else if (i.value().has_int_data()) {
node["value"] = i.value().int_data();
} else if (i.value().has_bool_data()) {
node["value"] = i.value().bool_data();
}
}
response.append(json_spirit::write(node));
}
int
main(int argc, char *argv[])
{
directory_t *root;
unsigned int seed = (unsigned int)time(NULL);
process_arguments(argc, argv);
validate_arguments();
if (arg_seed_set) {
seed = arg_seed;
}
srand(seed);
root = create_structure(0, arg_root);
create_source_tree(root);
printf("Random Number Seed: %u\n", seed);
return 0;
}
void NEGEMMLowpAArch64V8P4Kernel::internal_configure(const ITensor *input0, const ITensor *input1, ITensor *output, ITensor *workspace, float alpha, float beta, bool transform_0, bool transform_1)
{
// Perform validate step
ARM_COMPUTE_ERROR_ON_NULLPTR(input0, input1, output);
ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input0->info(), input1->info(), output->info()));
_input0 = input0;
_input1 = input1;
_output = output;
_workspace = workspace;
_alpha = alpha;
_beta = beta;
_transform_0 = transform_0;
_transform_1 = transform_1;
// Configure kernel window
auto win_config = validate_and_configure_window(input0->info(), input1->info(), output->info());
ARM_COMPUTE_ERROR_THROW_ON(win_config.first);
INEKernel::configure(win_config.second);
}
int main(int argc, const char** argv)
{
if(parse_arguments(argc, argv) < 0) {
print_usage(argv[0]);
exit(1);
}
if(validate_arguments() < 0) {
print_usage(argv[0]);
exit(1);
}
printf("Waiting for S2E mode...\n");
while(s2e_version() == 0) /* nothing */;
printf("... S2E mode detected\n");
copy_file(g_target_dir, g_file);
return 0;
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c = 1;
char *user;
struct passwd *pw;
int option = 0;
int err;
int cflags = REG_NOSUB | REG_EXTENDED;
char errbuf[MAX_INPUT_BUFFER];
char *temp_string;
int i=0;
static struct option longopts[] = {
{"warning", required_argument, 0, 'w'},
{"critical", required_argument, 0, 'c'},
{"metric", required_argument, 0, 'm'},
{"timeout", required_argument, 0, 't'},
{"status", required_argument, 0, 's'},
{"ppid", required_argument, 0, 'p'},
{"command", required_argument, 0, 'C'},
{"vsz", required_argument, 0, 'z'},
{"rss", required_argument, 0, 'r'},
{"pcpu", required_argument, 0, 'P'},
{"elapsed", required_argument, 0, 'e'},
{"argument-array", required_argument, 0, 'a'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"verbose", no_argument, 0, 'v'},
{"ereg-argument-array", required_argument, 0, CHAR_MAX+1},
{"input-file", required_argument, 0, CHAR_MAX+2},
{0, 0, 0, 0}
};
for (c = 1; c < argc; c++)
if (strcmp ("-to", argv[c]) == 0)
strcpy (argv[c], "-t");
while (1) {
c = getopt_long (argc, argv, "Vvht:c:w:p:s:u:C:a:z:r:m:P:",
longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case '?': /* help */
usage5 ();
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_integer (optarg))
usage2 (_("Timeout interval must be a positive integer"), optarg);
else
timeout_interval = atoi (optarg);
break;
case 'c': /* critical threshold */
critical_range = optarg;
break;
case 'w': /* warning threshold */
warning_range = optarg;
break;
case 'p': /* process id */
if (sscanf (optarg, "%d%[^0-9]", &ppid, tmp) == 1) {
xasprintf (&fmt, "%s%sPPID = %d", (fmt ? fmt : "") , (options ? ", " : ""), ppid);
options |= PPID;
break;
}
usage4 (_("Parent Process ID must be an integer!"));
case 's': /* status */
if (statopts)
break;
else
statopts = optarg;
xasprintf (&fmt, _("%s%sSTATE = %s"), (fmt ? fmt : ""), (options ? ", " : ""), statopts);
options |= STAT;
break;
case 'u': /* user or user id */
if (is_integer (optarg)) {
uid = atoi (optarg);
pw = getpwuid ((uid_t) uid);
/* check to be sure user exists */
if (pw == NULL)
usage2 (_("UID was not found"), optarg);
}
else {
pw = getpwnam (optarg);
/* check to be sure user exists */
if (pw == NULL)
usage2 (_("User name was not found"), optarg);
/* then get uid */
uid = pw->pw_uid;
}
user = pw->pw_name;
xasprintf (&fmt, "%s%sUID = %d (%s)", (fmt ? fmt : ""), (options ? ", " : ""),
uid, user);
options |= USER;
break;
case 'C': /* command */
/* TODO: allow this to be passed in with --metric */
if (prog)
break;
else
prog = optarg;
xasprintf (&fmt, _("%s%scommand name '%s'"), (fmt ? fmt : ""), (options ? ", " : ""),
prog);
options |= PROG;
break;
case 'a': /* args (full path name with args) */
/* TODO: allow this to be passed in with --metric */
if (args)
break;
else
args = optarg;
xasprintf (&fmt, "%s%sargs '%s'", (fmt ? fmt : ""), (options ? ", " : ""), args);
options |= ARGS;
break;
case CHAR_MAX+1:
err = regcomp(&re_args, optarg, cflags);
if (err != 0) {
regerror (err, &re_args, errbuf, MAX_INPUT_BUFFER);
die (STATE_UNKNOWN, "PROCS %s: %s - %s\n", _("UNKNOWN"), _("Could not compile regular expression"), errbuf);
}
/* Strip off any | within the regex optarg */
temp_string = strdup(optarg);
while(temp_string[i]!='\0'){
if(temp_string[i]=='|')
temp_string[i]=',';
i++;
}
xasprintf (&fmt, "%s%sregex args '%s'", (fmt ? fmt : ""), (options ? ", " : ""), temp_string);
options |= EREG_ARGS;
break;
case 'r': /* RSS */
if (sscanf (optarg, "%d%[^0-9]", &rss, tmp) == 1) {
xasprintf (&fmt, "%s%sRSS >= %d", (fmt ? fmt : ""), (options ? ", " : ""), rss);
options |= RSS;
break;
}
usage4 (_("RSS must be an integer!"));
case 'z': /* VSZ */
if (sscanf (optarg, "%d%[^0-9]", &vsz, tmp) == 1) {
xasprintf (&fmt, "%s%sVSZ >= %d", (fmt ? fmt : ""), (options ? ", " : ""), vsz);
options |= VSZ;
break;
}
usage4 (_("VSZ must be an integer!"));
case 'P': /* PCPU */
/* TODO: -P 1.5.5 is accepted */
if (sscanf (optarg, "%f%[^0-9.]", &pcpu, tmp) == 1) {
xasprintf (&fmt, "%s%sPCPU >= %.2f", (fmt ? fmt : ""), (options ? ", " : ""), pcpu);
options |= PCPU;
break;
}
usage4 (_("PCPU must be a float!"));
case 'm':
xasprintf (&metric_name, "%s", optarg);
if ( strcmp(optarg, "PROCS") == 0) {
metric = METRIC_PROCS;
break;
}
else if ( strcmp(optarg, "VSZ") == 0) {
metric = METRIC_VSZ;
break;
}
else if ( strcmp(optarg, "RSS") == 0 ) {
metric = METRIC_RSS;
break;
}
else if ( strcmp(optarg, "CPU") == 0 ) {
metric = METRIC_CPU;
break;
}
else if ( strcmp(optarg, "ELAPSED") == 0) {
metric = METRIC_ELAPSED;
break;
}
usage4 (_("Metric must be one of PROCS, VSZ, RSS, CPU, ELAPSED!"));
case 'v': /* command */
verbose++;
break;
case CHAR_MAX+2:
input_filename = optarg;
break;
}
}
c = optind;
if ((! warning_range) && argv[c])
warning_range = argv[c++];
if ((! critical_range) && argv[c])
critical_range = argv[c++];
if (statopts == NULL && argv[c]) {
xasprintf (&statopts, "%s", argv[c++]);
xasprintf (&fmt, _("%s%sSTATE = %s"), (fmt ? fmt : ""), (options ? ", " : ""), statopts);
options |= STAT;
}
/* this will abort in case of invalid ranges */
set_thresholds (&procs_thresholds, warning_range, critical_range);
return validate_arguments ();
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
char *warning = NULL;
char *critical = NULL;
int opt_index = 0;
static struct option long_opts[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"verbose", no_argument, 0, 'v'},
{"timeout", required_argument, 0, 't'},
{"hostname", required_argument, 0, 'H'},
{"server", required_argument, 0, 's'},
{"reverse-server", required_argument, 0, 'r'},
{"expected-address", required_argument, 0, 'a'},
{"expect-authority", no_argument, 0, 'A'},
{"warning", required_argument, 0, 'w'},
{"critical", required_argument, 0, 'c'},
{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, "hVvAt:H:s:r:a:w:c:", long_opts, &opt_index);
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 'v': /* version */
verbose = TRUE;
break;
case 't': /* timeout period */
timeout_interval = atoi (optarg);
break;
case 'H': /* hostname */
if (strlen (optarg) >= ADDRESS_LENGTH)
die (STATE_UNKNOWN, _("Input buffer overflow\n"));
strcpy (query_address, optarg);
break;
case 's': /* server name */
/* TODO: this host_or_die check is probably unnecessary.
* Better to confirm nslookup response matches */
host_or_die(optarg);
if (strlen (optarg) >= ADDRESS_LENGTH)
die (STATE_UNKNOWN, _("Input buffer overflow\n"));
strcpy (dns_server, optarg);
break;
case 'r': /* reverse server name */
/* TODO: Is this host_or_die necessary? */
host_or_die(optarg);
if (strlen (optarg) >= ADDRESS_LENGTH)
die (STATE_UNKNOWN, _("Input buffer overflow\n"));
strcpy (ptr_server, optarg);
break;
case 'a': /* expected address */
if (strlen (optarg) >= ADDRESS_LENGTH)
die (STATE_UNKNOWN, _("Input buffer overflow\n"));
expected_address = (char **)realloc(expected_address, (expected_address_cnt+1) * sizeof(char**));
expected_address[expected_address_cnt] = strdup(optarg);
expected_address_cnt++;
break;
case 'A': /* expect authority */
expect_authority = TRUE;
break;
case 'w':
warning = optarg;
break;
case 'c':
critical = optarg;
break;
default: /* args not parsable */
usage5();
}
}
c = optind;
if (strlen(query_address)==0 && c<argc) {
if (strlen(argv[c])>=ADDRESS_LENGTH)
die (STATE_UNKNOWN, _("Input buffer overflow\n"));
strcpy (query_address, argv[c++]);
}
if (strlen(dns_server)==0 && c<argc) {
/* TODO: See -s option */
host_or_die(argv[c]);
if (strlen(argv[c]) >= ADDRESS_LENGTH)
die (STATE_UNKNOWN, _("Input buffer overflow\n"));
strcpy (dns_server, argv[c++]);
}
set_thresholds(&time_thresholds, warning, critical);
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;
int option = 0;
static struct option longopts[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"timeout", required_argument, 0, 't'},
{"critical", required_argument, 0, 'c'},
{"warning", required_argument, 0, 'w'},
{"hostname", required_argument, 0, 'H'},
{"logname", required_argument, 0, 'l'},
{"password", required_argument, 0, 'p'},
{"authorization", required_argument, 0, 'a'},
{"port", required_argument, 0, 'P'},
{"database", required_argument, 0, 'd'},
{"verbose", no_argument, 0, 'v'},
{0, 0, 0, 0}
};
while (1) {
c = getopt_long (argc, argv, "hVt:c:w:H:P:d:l:p:a:v",
longopts, &option);
if (c == EOF)
break;
switch (c) {
case '?': /* usage */
usage5 ();
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_integer (optarg))
usage2 (_("Timeout interval must be a positive integer"), optarg);
else
timeout_interval = atoi (optarg);
break;
case 'c': /* critical time threshold */
if (!is_nonnegative (optarg))
usage2 (_("Critical threshold must be a positive integer"), optarg);
else
tcrit = strtod (optarg, NULL);
break;
case 'w': /* warning time threshold */
if (!is_nonnegative (optarg))
usage2 (_("Warning threshold must be a positive integer"), optarg);
else
twarn = strtod (optarg, NULL);
break;
case 'H': /* host */
if (!is_host (optarg))
usage2 (_("Invalid hostname/address"), optarg);
else
pghost = optarg;
break;
case 'P': /* port */
if (!is_integer (optarg))
usage2 (_("Port must be a positive integer"), optarg);
else
pgport = optarg;
break;
case 'd': /* database name */
if (!is_pg_dbname (optarg)) /* checks length and valid chars */
usage2 (_("Database name is not valid"), optarg);
else /* we know length, and know optarg is terminated, so us strcpy */
strcpy (dbName, optarg);
break;
case 'l': /* login name */
if (!is_pg_logname (optarg))
usage2 (_("User name is not valid"), optarg);
else
pguser = optarg;
break;
case 'p': /* authentication password */
case 'a':
pgpasswd = optarg;
break;
case 'v':
verbose++;
break;
}
}
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;
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;
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 ();
}
void _seq_batch_r(void* exec)
{
EtalisEvent* Event_b = (EtalisEvent*)exec;
if (Event_b == NULL) return;
EtalisExecNode* rule_ = Event_b->RootModel->parentNode;
EtalisEvent* Event_a=NULL;
/* calculate EAT */
float EAT = getHighResStamp(&Event_b->timestamps[1]) - rule_->window_size; /* TODO fix */
if (rule_->leftChild->is_temp)
{
_seq_batch_r(StackPop(rule_->leftChild->childNode->rightChild->eventStack));
}
do
{
/*if (getHighResStamp(&Event_b->timestamps[0]) < EAT ) { free(Event_b); continue;} /* problem : all atomic right side events does not fulfill this condition */
Event_a = StackPop(rule_->leftChild->eventStack);
while( Event_a != NULL && getTimeDiff(&(Event_b->timestamps[0]),&(Event_a->timestamps[1])) >= 0 ) /* problem : recursion */
{
/*if (getHighResStamp(&Event_a->timestamps[0]) < EAT )*/ /* EAT is not compatible with timestamps */
if (Event_b->timestamps[1].time - Event_a->timestamps[0].time > rule_->window_size)
{
free (Event_a);
Event_a = StackPop(rule_->leftChild->eventStack);
continue; /* normally you don't have to continue here, because events are already choronogically ordered in the stack */ /* fix this */
}
if(validate_arguments(Event_b,Event_a) != ETALIS_OK)
{
#ifdef DEBUG
printf("Event arguments could not be validated ! \n");
#endif
free(Event_a); /* check*/
Event_a = StackPop(rule_->leftChild->eventStack);
continue;
}
EtalisEventNode* cplxEvModel=NULL; /* Complex Event Root Model */
/* the rest depends on the CEP policy */
if (_conf.policy==recent) /* recent policy */
{
cplxEvModel = rule_->parentEvent;
/* triggering the complex event */
EtalisEvent* cplxEvent = (EtalisEvent*)malloc(sizeof(EtalisEvent));
cplxEvent->RootModel = rule_->parentEvent;
/* bind the arguments of the complex event */ /* todo validate */
cplxEvent->args = (int*)malloc(sizeof(int)*cplxEvModel->event.arity);
size_t arg_iterator=0;
for(arg_iterator=0; arg_iterator<cplxEvModel->event.arity; arg_iterator++)
{
switch (cplxEvModel->arg_links[arg_iterator].event_)
{
case 1 :
*((int*)cplxEvent->args+arg_iterator)=*((int*)Event_a->args+(cplxEvModel->arg_links[arg_iterator].argument_number));
break;
case 2 :
*((int*)cplxEvent->args+arg_iterator)=*((int*)Event_b->args+(cplxEvModel->arg_links[arg_iterator].argument_number));
break;
}
}
cplxEvent->timestamps[0] = Event_a->timestamps[0]; /* timestamp structure as suggested by the ETALIS paper */
cplxEvent->timestamps[1] = Event_b->timestamps[1];
triggerEvent_intern_no_hash(cplxEvent); /* trigger the complex event (we already know the EventModel, so we don't need to search for it in the _event_hash) */
/* garbage collect : we don't need these events anymore */
free(Event_a);
free(Event_b);
return;
}
else if (_conf.policy==unrestricted)
{
/* TODO */
return ;
}
Event_a = StackPop(rule_->leftChild->eventStack);
}
}
while (Event_b = StackPop(Event_b->RootModel->eventStack));
}
/* 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'},
{"port", required_argument, 0, 'P'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{"query", required_argument, 0, 'q'},
{"warning", required_argument, 0, 'w'},
{"critical", required_argument, 0, 'c'},
{0, 0, 0, 0}
};
if (argc < 1)
return ERROR;
while (1) {
c = getopt_long (argc, argv, "hvVP:p:u:d:H:s:q:w:c:", 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 'P': /* critical time threshold */
db_port = atoi (optarg);
break;
case 'v':
verbose++;
break;
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'h': /* help */
print_help ();
exit (STATE_OK);
case 'q':
xasprintf(&sql_query, "%s", optarg);
break;
case 'w':
warning = optarg;
break;
case 'c':
critical = optarg;
break;
case '?': /* help */
usage5 ();
}
}
c = optind;
set_thresholds(&my_thresholds, warning, critical);
return validate_arguments ();
}
int main(void) {
int result = OK;
/* get the arguments passed in the URL */
process_cgivars();
/* reset internal variables */
reset_cgi_vars();
document_header();
/* validate arguments in URL */
result = validate_arguments();
if(result == ERROR) {
document_footer();
return ERROR;
}
/* read the CGI configuration file */
result = read_cgi_config_file(get_cgi_config_location());
if(result == ERROR) {
printf("<P>Error: Could not open CGI configuration file '%s' for reading!</P>\n", get_cgi_config_location());
document_footer();
return ERROR;
}
/* read the main configuration file */
result = read_main_config_file(main_config_file);
if(result == ERROR) {
printf("<P>Error: Could not open main configuration file '%s' for reading!</P>\n", main_config_file);
document_footer();
return ERROR;
}
/* read all object configuration data */
result = read_all_object_configuration_data(main_config_file, READ_ALL_OBJECT_DATA);
if(result == ERROR) {
printf("<P>Error: Could not read some or all object configuration data!</P>\n");
document_footer();
return ERROR;
}
/* read all status data */
result = read_all_status_data(get_cgi_config_location(), READ_ALL_STATUS_DATA);
if(result == ERROR) {
printf("<P>Error: Could not read host and service status information!</P>\n");
document_footer();
free_memory();
return ERROR;
}
/* get authentication information */
get_authentication_information(¤t_authdata);
/* decide what to display to the user */
if(display_type == DISPLAY_HOST && host_style == DISPLAY_HOST_SERVICES)
display_host_services();
else if(display_type == DISPLAY_HOST)
display_host();
else if(display_type == DISPLAY_SERVICE)
display_service();
else if(display_type == DISPLAY_HOSTGROUP && hostgroup_style == DISPLAY_HOSTGROUP_OVERVIEW)
display_hostgroup_overview();
else if(display_type == DISPLAY_HOSTGROUP && hostgroup_style == DISPLAY_HOSTGROUP_SUMMARY)
display_hostgroup_summary();
else if(display_type == DISPLAY_PING)
display_ping();
else if(display_type == DISPLAY_TRACEROUTE)
display_traceroute();
else if(display_type == DISPLAY_QUICKSTATS)
display_quick_stats();
else if(display_type == DISPLAY_PROCESS)
display_process();
else if(display_type == DISPLAY_ALL_PROBLEMS || display_type == DISPLAY_UNHANDLED_PROBLEMS)
display_problems();
else
display_index();
document_footer();
/* free all allocated memory */
free_memory();
return OK;
}
/* 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'},
{"aggregation", required_argument, 0, 'a'},
{"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)
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:c:w:", longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 'F': /* input file */
log_file = optarg;
break;
case 'e': /* expiration time */
expire_minutes = atoi (optarg);
break;
case 'a': /* aggregation (AVE or MAX) */
if (!strcmp (optarg, "MAX"))
use_average = FALSE;
else
use_average = TRUE;
break;
case 'c': /* warning threshold */
sscanf (optarg, "%lu,%lu", &incoming_critical_threshold,
&outgoing_critical_threshold);
break;
case 'w': /* critical threshold */
sscanf (optarg, "%lu,%lu", &incoming_warning_threshold,
&outgoing_warning_threshold);
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 (argc > c && log_file == NULL) {
log_file = argv[c++];
}
if (argc > c && expire_minutes == -1) {
expire_minutes = atoi (argv[c++]);
}
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 && incoming_warning_threshold == 0) {
incoming_warning_threshold = strtoul (argv[c++], NULL, 10);
}
if (argc > c && incoming_critical_threshold == 0) {
incoming_critical_threshold = strtoul (argv[c++], NULL, 10);
}
if (argc > c && outgoing_warning_threshold == 0) {
outgoing_warning_threshold = strtoul (argv[c++], NULL, 10);
}
if (argc > c && outgoing_critical_threshold == 0) {
outgoing_critical_threshold = strtoul (argv[c++], NULL, 10);
}
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'},
{"port" ,required_argument, 0, 'P'},
{"expire" ,required_argument, 0, 'E'},
{"verbose" ,no_argument, 0, 'v'},
{"version" ,no_argument, 0, 'V'},
{"help" ,no_argument, 0, 'h'},
{"warning" ,required_argument, 0, 'w'},
{"critical" ,required_argument, 0, 'c'},
{0, 0, 0, 0}
};
if (argc < 1)
return ERROR;
while (1) {
c = getopt_long (argc, argv, "H:P:E:vVhw:c:", longopts, &option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 'H':
if (is_host(optarg)) {
mc_host = optarg;
}
else {
usage2(_("Invalid hostname/address"), optarg);
}
break;
case 'P':
mc_port = atoi(optarg);
break;
case 'E':
mc_expire = atoi(optarg);
break;
case 'v':
verbose++;
break;
case 'V':
print_revision(progname, revision);
exit(STATE_OK);
case 'h':
print_help();
exit (STATE_OK);
case 'w':
warning = optarg;
break;
case 'c':
critical = optarg;
break;
case '?':
usage5();
}
}
c = optind;
set_thresholds(&my_thresholds, warning, critical);
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'},
{"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 ();
}
void settings_controller::get_section(Mongoose::Request &request, boost::smatch &what, Mongoose::StreamResponse &response) {
if (!session->is_loggedin("settings.list", request, response))
return;
if (!validate_arguments(1, what, response)) {
return;
}
std::string path = what.str(1);
Plugin::SettingsRequestMessage rm;
Plugin::SettingsRequestMessage::Request *payload = rm.add_payload();
payload->mutable_query()->mutable_node()->set_path(path);
payload->mutable_query()->set_recursive(false);
payload->set_plugin_id(plugin_id);
payload = rm.add_payload();
payload->mutable_query()->mutable_node()->set_path(path);
payload->mutable_query()->set_recursive(true);
payload->set_plugin_id(plugin_id);
std::string str_response;
core->settings_query(rm.SerializeAsString(), str_response);
Plugin::SettingsResponseMessage pb_response;
pb_response.ParseFromString(str_response);
json_spirit::Object node;
node["path"] = path;
if (pb_response.payload_size() != 2) {
response.setCode(HTTP_SERVER_ERROR);
response.append("Failed to fetch keys");
return;
}
const Plugin::SettingsResponseMessage::Response rKeys = pb_response.payload(0);
if (!rKeys.has_query()) {
response.setCode(HTTP_NOT_FOUND);
response.append("Key not found: " + path);
return;
}
json_spirit::Array keys;
BOOST_FOREACH(const std::string &s, rKeys.query().value().list_data()) {
keys.push_back(s);
}
node["keys"] = keys;
const Plugin::SettingsResponseMessage::Response rPath = pb_response.payload(1);
if (!rPath.has_query()) {
response.setCode(HTTP_NOT_FOUND);
response.append("Key not found: " + path);
return;
}
json_spirit::Array paths;
BOOST_FOREACH(const std::string &s, rPath.query().value().list_data()) {
paths.push_back(s);
}
node["paths"] = paths;
response.append(json_spirit::write(node));
}
/* 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 */
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 ();
}
/* 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'},
{"uri", required_argument, 0, 'U'},
{"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'},
{"warn-entries", required_argument, 0, 'W'},
{"crit-entries", 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:U:C:W:", 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 */
timeout_interval = parse_timeout_string(optarg);
break;
case 'U':
ld_uri = 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;
case 'W':
warn_entries = optarg;
break;
case 'C':
crit_entries = optarg;
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 ();
}
int main(int argc, char **argv) {
open_log_files();
assert_valid_setup(argv[0]);
int operation;
int ret = validate_arguments(argc, argv, &operation);
if (ret != 0) {
flush_and_close_log_files();
return ret;
}
int exit_code = 0;
switch (operation) {
case CHECK_SETUP:
//we already did this
exit_code = 0;
break;
case MOUNT_CGROUPS:
exit_code = 0;
while (optind < argc && exit_code == 0) {
exit_code = mount_cgroup(argv[optind++], cmd_input.cgroups_hierarchy);
}
break;
case TRAFFIC_CONTROL_MODIFY_STATE:
exit_code = traffic_control_modify_state(cmd_input.traffic_control_command_file);
break;
case TRAFFIC_CONTROL_READ_STATE:
exit_code = traffic_control_read_state(cmd_input.traffic_control_command_file);
break;
case TRAFFIC_CONTROL_READ_STATS:
exit_code = traffic_control_read_stats(cmd_input.traffic_control_command_file);
break;
case RUN_DOCKER:
exit_code = run_docker(cmd_input.docker_command_file);
break;
case RUN_AS_USER_INITIALIZE_CONTAINER:
exit_code = set_user(cmd_input.run_as_user_name);
if (exit_code != 0) {
break;
}
exit_code = initialize_app(cmd_input.yarn_user_name,
cmd_input.app_id,
cmd_input.cred_file,
extract_values(cmd_input.local_dirs),
extract_values(cmd_input.log_dirs),
argv + optind);
break;
case RUN_AS_USER_LAUNCH_DOCKER_CONTAINER:
if (cmd_input.traffic_control_command_file != NULL) {
//apply tc rules before switching users and launching the container
exit_code = traffic_control_modify_state(cmd_input.traffic_control_command_file);
if( exit_code != 0) {
//failed to apply tc rules - break out before launching the container
break;
}
}
exit_code = set_user(cmd_input.run_as_user_name);
if (exit_code != 0) {
break;
}
exit_code = launch_docker_container_as_user(cmd_input.yarn_user_name,
cmd_input.app_id,
cmd_input.container_id,
cmd_input.current_dir,
cmd_input.script_file,
cmd_input.cred_file,
cmd_input.pid_file,
extract_values(cmd_input.local_dirs),
extract_values(cmd_input.log_dirs),
cmd_input.docker_command_file,
cmd_input.resources_key,
cmd_input.resources_values);
break;
case RUN_AS_USER_LAUNCH_CONTAINER:
if (cmd_input.traffic_control_command_file != NULL) {
//apply tc rules before switching users and launching the container
exit_code = traffic_control_modify_state(cmd_input.traffic_control_command_file);
if( exit_code != 0) {
//failed to apply tc rules - break out before launching the container
break;
}
}
exit_code = set_user(cmd_input.run_as_user_name);
if (exit_code != 0) {
break;
}
exit_code = launch_container_as_user(cmd_input.yarn_user_name,
cmd_input.app_id,
cmd_input.container_id,
cmd_input.current_dir,
cmd_input.script_file,
cmd_input.cred_file,
cmd_input.pid_file,
extract_values(cmd_input.local_dirs),
extract_values(cmd_input.log_dirs),
cmd_input.resources_key,
cmd_input.resources_values);
free(cmd_input.resources_key);
free(cmd_input.resources_value);
free(cmd_input.resources_values);
break;
case RUN_AS_USER_SIGNAL_CONTAINER:
exit_code = set_user(cmd_input.run_as_user_name);
if (exit_code != 0) {
break;
}
exit_code = signal_container_as_user(cmd_input.yarn_user_name,
cmd_input.container_pid,
cmd_input.signal);
break;
case RUN_AS_USER_DELETE:
exit_code = set_user(cmd_input.run_as_user_name);
if (exit_code != 0) {
break;
}
exit_code = delete_as_user(cmd_input.yarn_user_name,
cmd_input.dir_to_be_deleted,
argv + optind);
break;
}
flush_and_close_log_files();
return exit_code;
}
/*
* Zstream implementation for seq (right event)
*/
void _seq_win_cep_r(void* exec)
{
EtalisEvent* Event_b = (EtalisEvent*)exec;
EtalisExecNode* rule_ = Event_b->RootModel->parentNode;
assert(Event_b != NULL && rule_ != NULL);
EtalisEvent* Event_a = StackPop(rule_->leftChild->eventStack);
if(Event_a == NULL) /* stack is empty*/
{
free(Event_b);
return;
}
/* Event a is in the stack */
/* a complex event will be generated if the conditions are met */
/* testing if the conditions could be proven correct */
if(getTimeDiff(&(Event_b->timestamps[0]),&(Event_a->timestamps[0])) > rule_->window_size) /* out of the window*/
{
/* printf(" --- Time difference is %d > window size of %d\n",Event_b->timestamps[0]-Event_a->timestamps[0],rule_->window_size);
*/
free(Event_a); /* check this */
free(Event_b);
return;
}
if (Event_b->RootModel->event.arity != 0 )
{
if(aprio_validation(Event_b) != ETALIS_OK) /* argument a priori conditions must be true*/
{
#ifdef DEBUG
log_err("Event could be validated !");
#endif
free(Event_a); /* check*/
free(Event_b);
return;
}
/* event arguments must be valide - implicite condition */
if(validate_arguments(Event_b,Event_a) != ETALIS_OK)
{
#ifdef DEBUG
printf("Event arguments could not be validated ! \n");
#endif
free(Event_a); /* check*/
free(Event_b);
return;
}
}
EtalisEventNode* cplxEvModel=NULL; /* Complex Event Root Model */
/* the rest depends on the CEP policy */
if (_conf.policy==recent) /* recent policy */
{
cplxEvModel = rule_->parentEvent;
/* triggering the complex event */
EtalisEvent* cplxEvent = (EtalisEvent*)malloc(sizeof(EtalisEvent));
cplxEvent->RootModel = rule_->parentEvent;
/* bind the arguments of the complex event */ /* todo validate */
cplxEvent->args = (int*)malloc(sizeof(int)*cplxEvModel->event.arity);
size_t arg_iterator=0;
for(arg_iterator=0; arg_iterator<cplxEvModel->event.arity; arg_iterator++)
{
switch (cplxEvModel->arg_links[arg_iterator].event_)
{
case 1 :
*((int*)cplxEvent->args+arg_iterator)=*((int*)Event_a->args+(cplxEvModel->arg_links[arg_iterator].argument_number));
break;
case 2 :
*((int*)cplxEvent->args+arg_iterator)=*((int*)Event_b->args+(cplxEvModel->arg_links[arg_iterator].argument_number));
break;
}
}
cplxEvent->timestamps[0] = Event_a->timestamps[0]; /* timestamp structure as suggested by the ETALIS paper */
cplxEvent->timestamps[1] = Event_b->timestamps[1];
triggerEvent_intern_no_hash(cplxEvent); /* trigger the complex event (we already know the EventModel, so we don't need to search for it in the _event_hash) */
/* garbage collect : we don't need these events anymore */
free(Event_a);
free(Event_b);
return;
}
else if (_conf.policy==unrestricted)
{
/* TODO */
return ;
}
}
/* process command-line arguments */
int
process_arguments (int argc, char **argv)
{
int c;
char *p1, *p2;
int option = 0;
static struct option longopts[] = {
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{"verbose", no_argument, 0, 'v'},
{"fork", no_argument, 0, 'f'},
{"timeout", required_argument, 0, 't'},
{"host", required_argument, 0, 'H'},
{"port", required_argument,0,'p'},
{"output", required_argument, 0, 'O'},
{"name", required_argument, 0, 'n'},
{"services", required_argument, 0, 's'},
{"identity", required_argument, 0, 'i'},
{"user", required_argument, 0, 'u'},
{"logname", required_argument, 0, 'l'},
{"command", required_argument, 0, 'C'},
{"skip", optional_argument, 0, 'S'}, /* backwards compatibility */
{"skip-stdout", optional_argument, 0, 'S'},
{"skip-stderr", optional_argument, 0, 'E'},
{"proto1", no_argument, 0, '1'},
{"proto2", no_argument, 0, '2'},
{"use-ipv4", no_argument, 0, '4'},
{"use-ipv6", no_argument, 0, '6'},
{"ssh-option", required_argument, 0, 'o'},
{"quiet", no_argument, 0, 'q'},
{"configfile", optional_argument, 0, 'F'},
{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, "Vvh1246fqt:H:O:p:i:u:l:C:S::E::n:s:o:F:", longopts,
&option);
if (c == -1 || c == EOF)
break;
switch (c) {
case 'V': /* version */
print_revision (progname, NP_VERSION);
exit (STATE_OK);
case 'h': /* help */
print_help ();
exit (STATE_OK);
case 'v': /* help */
verbose = TRUE;
break;
case 't': /* timeout period */
if (!is_integer (optarg))
usage_va(_("Timeout interval must be a positive integer"));
else
timeout_interval = atoi (optarg);
break;
case 'H': /* host */
host_or_die(optarg);
hostname = optarg;
break;
case 'p': /* port number */
if (!is_integer (optarg))
usage_va(_("Port must be a positive integer"));
comm_append("-p");
comm_append(optarg);
break;
case 'O': /* output file */
outputfile = optarg;
passive = TRUE;
break;
case 's': /* description of service to check */
p1 = optarg;
service = realloc (service, (++services) * sizeof(char *));
while ((p2 = index (p1, ':'))) {
*p2 = '\0';
service[services - 1] = p1;
service = realloc (service, (++services) * sizeof(char *));
p1 = p2 + 1;
}
service[services - 1] = p1;
break;
case 'n': /* short name of host in nagios configuration */
host_shortname = optarg;
break;
case 'u':
comm_append("-l");
comm_append(optarg);
break;
case 'l': /* login name */
comm_append("-l");
comm_append(optarg);
break;
case 'i': /* identity */
comm_append("-i");
comm_append(optarg);
break;
case '1': /* Pass these switches directly to ssh */
comm_append("-1");
break;
case '2': /* 1 to force version 1, 2 to force version 2 */
comm_append("-2");
break;
case '4': /* -4 for IPv4 */
comm_append("-4");
break;
case '6': /* -6 for IPv6 */
comm_append("-6");
break;
case 'f': /* fork to background */
comm_append("-f");
break;
case 'C': /* Command for remote machine */
commands++;
if (commands > 1)
xasprintf (&remotecmd, "%s;echo STATUS CODE: $?;", remotecmd);
xasprintf (&remotecmd, "%s%s", remotecmd, optarg);
break;
case 'S': /* skip n (or all) lines on stdout */
if (optarg == NULL)
skip_stdout = -1; /* skip all output on stdout */
else if (!is_integer (optarg))
usage_va(_("skip-stdout argument must be an integer"));
else
skip_stdout = atoi (optarg);
break;
case 'E': /* skip n (or all) lines on stderr */
if (optarg == NULL)
skip_stderr = -1; /* skip all output on stderr */
else if (!is_integer (optarg))
usage_va(_("skip-stderr argument must be an integer"));
else
skip_stderr = atoi (optarg);
break;
case 'o': /* Extra options for the ssh command */
comm_append("-o");
comm_append(optarg);
break;
case 'q': /* Tell the ssh command to be quiet */
comm_append("-q");
break;
case 'F': /* ssh configfile */
comm_append("-F");
comm_append(optarg);
break;
default: /* help */
usage5();
}
}
c = optind;
if (hostname == NULL) {
if (c <= argc) {
die (STATE_UNKNOWN, _("%s: You must provide a host name\n"), progname);
}
host_or_die(argv[c]);
hostname = argv[c++];
}
if (strlen(remotecmd) == 0) {
for (; c < argc; c++)
if (strlen(remotecmd) > 0)
xasprintf (&remotecmd, "%s %s", remotecmd, argv[c]);
else
xasprintf (&remotecmd, "%s", argv[c]);
}
if (commands > 1 || passive)
xasprintf (&remotecmd, "%s;echo STATUS CODE: $?;", remotecmd);
if (remotecmd == NULL || strlen (remotecmd) <= 1)
usage_va(_("No remotecmd"));
comm_append(hostname);
comm_append(remotecmd);
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'},
{"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 ();
}
int
process_arguments (int argc, char **argv)
{
int c;
int opt_index = 0;
static struct option long_opts[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"verbose", no_argument, 0, 'v'},
{"timeout", required_argument, 0, 't'},
{"hostname", required_argument, 0, 'H'},
{"port", required_argument, 0, 'P'},
{"game-type", required_argument, 0, 'G'},
{"map-field", required_argument, 0, 'm'},
{"ping-field", required_argument, 0, 'p'},
{"game-field", required_argument, 0, 'g'},
{"players-field", required_argument, 0, 129},
{"max-players-field", required_argument, 0, 130},
{0, 0, 0, 0}
};
if (argc < 2)
return ERROR;
for (c = 1; c < argc; c++) {
if (strcmp ("-mf", argv[c]) == 0)
strcpy (argv[c], "-m");
else if (strcmp ("-pf", argv[c]) == 0)
strcpy (argv[c], "-p");
else if (strcmp ("-gf", argv[c]) == 0)
strcpy (argv[c], "-g");
}
while (1) {
c = getopt_long (argc, argv, "hVvt:H:P:G:g:p:m:", long_opts, &opt_index);
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 'v': /* version */
verbose = TRUE;
break;
case 't': /* timeout period */
timeout_interval = atoi (optarg);
break;
case 'H': /* hostname */
if (strlen (optarg) >= MAX_HOST_ADDRESS_LENGTH)
die (STATE_UNKNOWN, _("Input buffer overflow\n"));
server_ip = optarg;
break;
case 'P': /* port */
port = atoi (optarg);
break;
case 'G': /* hostname */
if (strlen (optarg) >= MAX_INPUT_BUFFER)
die (STATE_UNKNOWN, _("Input buffer overflow\n"));
game_type = optarg;
break;
case 'p': /* index of ping field */
qstat_ping_field = atoi (optarg);
if (qstat_ping_field < 0 || qstat_ping_field > QSTAT_MAX_RETURN_ARGS)
return ERROR;
break;
case 'm': /* index on map field */
qstat_map_field = atoi (optarg);
if (qstat_map_field < 0 || qstat_map_field > QSTAT_MAX_RETURN_ARGS)
return ERROR;
break;
case 'g': /* index of game field */
qstat_game_field = atoi (optarg);
if (qstat_game_field < 0 || qstat_game_field > QSTAT_MAX_RETURN_ARGS)
return ERROR;
break;
case 129: /* index of player count field */
qstat_game_players = atoi (optarg);
if (qstat_game_players_max == 0)
qstat_game_players_max = qstat_game_players - 1;
if (qstat_game_players < 0 || qstat_game_players > QSTAT_MAX_RETURN_ARGS)
return ERROR;
break;
case 130: /* index of max players field */
qstat_game_players_max = atoi (optarg);
if (qstat_game_players_max < 0 || qstat_game_players_max > QSTAT_MAX_RETURN_ARGS)
return ERROR;
break;
default: /* args not parsable */
usage5();
}
}
c = optind;
/* first option is the game type */
if (!game_type && c<argc)
game_type = strdup (argv[c++]);
/* Second option is the server name */
if (!server_ip && c<argc)
server_ip = strdup (argv[c++]);
return validate_arguments ();
}