/* Parse a single option. */
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
/* Get the input argument from argp_parse, which we
know is a pointer to our arguments structure. */
struct arguments *arguments = state->input;
switch (key)
{
case 'v':
arguments->verbose = 1;
break;
case ARGP_KEY_ARG:
if (state->arg_num >= 1) {
/* Too many arguments. */
argp_usage (state);
}
else if (arguments->region == NULL) {
arguments->region = arg;
}
break;
case ARGP_KEY_END:
if (state->arg_num < 1) {
/* Not enough arguments. */
argp_usage (state);
}
else if (arguments->region == NULL) {
argp_failure(state, 1, 0, "ERROR, region not defined!");
}
else if (
strcmp(arguments->region,"Ama") != 0 &&
strcmp(arguments->region,"Aus") != 0 &&
strcmp(arguments->region,"Ber") != 0 &&
strcmp(arguments->region,"CAm") != 0 &&
strcmp(arguments->region,"ChJ") != 0 &&
strcmp(arguments->region,"Eur") != 0 &&
strcmp(arguments->region,"Ind") != 0 &&
strcmp(arguments->region,"NAf") != 0 &&
strcmp(arguments->region,"NAm") != 0 &&
strcmp(arguments->region,"SAf") != 0 &&
strcmp(arguments->region,"SAm") != 0 &&
strcmp(arguments->region,"SAs") != 0) {
argp_failure(state, 1, 0, "ERROR, inputted region not defined!");
}
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
static error_t
main_argp_parser(int key, char *arg, struct argp_state *state)
{
CAST(lsh_decode_key_options, self, state->input);
switch(key)
{
default:
return ARGP_ERR_UNKNOWN;
case ARGP_KEY_INIT:
state->child_inputs[0] = &self->super;
break;
case ARGP_KEY_END:
if (!werror_init(&self->super))
argp_failure(state, EXIT_FAILURE, errno, "Failed to open log file");
break;
case 'b':
self->base64 = 1;
break;
case 'o':
self->file = make_string(arg);
break;
}
return 0;
}
static void
parse_exec_spec(int argc, char *argv[], struct argp_state *state)
{
bench_process_t *p = processes;
while (argc) {
if (num_processes >= MAX_CPUS)
argp_error(state, "Unsupported number of processes, only "
"%i processes supported", MAX_CPUS);
memset(p, '\0', sizeof(bench_process_t));
p->cpu = parse_exec_spec_get_cpu(p - processes, state);
p->pid = 0;
p->argc = 0;
if (*argv[0] == '@') {
p->wd = argv[0] + 1;
--argc;
++argv;
}
if (!argc)
argp_error(state, "Target specification lacks binary name");
p->argv = argv;
while (argc) {
if (!strcmp("--", *argv)) {
*argv = NULL;
++argv;
--argc;
break;
} else if (!strcmp("<", *argv)) {
if (argc <= 1)
argp_error(state, "No input file specified for STDIN "
"redirection.");
if (argc > 2 && strcmp("--", argv[2]))
argp_error(state, "Illegal token after STDIN redirection");
p->stdin = fopen(argv[1], "r");
if (!p->stdin)
argp_failure(state, EXIT_FAILURE, errno,
"Failed to open input file");
argv += 2;
argc -= 2;
} else {
++p->argc;
++argv;
--argc;
}
}
++p;
++num_processes;
}
}
/* Parse a command line option. */
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
/* We save our parsed values in this structure, hung off STATE->hook.
Only after parsing all options successfully will we use these values. */
struct
{
int debug_flag;
unsigned int sb_block;
} *values = state->hook;
switch (key)
{
case 'D':
values->debug_flag = 1;
break;
case 'S':
values->sb_block = strtoul (arg, &arg, 0);
if (!arg || *arg != '\0')
{
argp_error (state, "invalid number for --sblock");
return EINVAL;
}
break;
case ARGP_KEY_INIT:
state->child_inputs[0] = state->input;
values = malloc (sizeof *values);
if (values == 0)
return ENOMEM;
state->hook = values;
memset (values, 0, sizeof *values);
values->sb_block = SBLOCK_BLOCK;
break;
case ARGP_KEY_SUCCESS:
/* All options parse successfully, so implement ours if possible. */
if (values->debug_flag)
{
#ifdef EXT2FS_DEBUG
ext2_debug_flag = !ext2_debug_flag;
#else
argp_failure (state, 2, 0, "debugging support not compiled in");
return EINVAL;
#endif
}
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
error_t init_parsers(int key, char* arg, argp_state* state) {
State& args = *reinterpret_cast<State*>(state->input);
switch (key) {
case 'b':
args.blocks = std::max<std::int64_t>(from_string<std::int64_t>(arg), 0);
if (args.blocks == 0)
argp_failure(state, 1, 0, "Number of blocks must be positive");
break;
case 's': {
auto size = from_string<std::int64_t>(arg);
args.partition_size = size;
if (size <= 0)
argp_failure(state, 1, 0, "Partition size must be positive");
break;
}
case ARGP_KEY_INIT:
state->child_inputs[0] = &args.device;
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
long
perf_argp_parse_long(const char *name, const char *arg, struct argp_state *state)
{
char *endptr;
long value;
errno = 0;
value = strtol(arg, &endptr, 0);
if (errno)
argp_failure(state, EXIT_FAILURE, errno,
"Invalid %s", name);
else if (*arg == '\0' || *endptr != '\0')
argp_error(state, "Invalid %s: '%s' is not a number.\n", name, arg);
return value;
}
static void cmd_prepare(struct argp_state *state, struct arguments *args,
char *cmd, struct argp *argp_cmd)
{
int argc = state->argc - state->next + 1;
char** argv = &state->argv[state->next - 1];
char* argv0 = argv[0];
argv[0] = malloc(strlen(state->name) + strlen(cmd) + 2);
if(!argv[0])
argp_failure(state, 1, ENOMEM, 0);
sprintf(argv[0], "%s %s", state->name, cmd);
argp_parse(argp_cmd, argc, argv, ARGP_IN_ORDER, &argc, args);
free(argv[0]);
argv[0] = argv0;
state->next += argc - 1;
}
static error_t
parse_opts (int key, char *arg, struct argp_state *state)
{
cmd_args_t *cmd_args = NULL;
uint32_t n = 0;
double d = 0.0;
gf_boolean_t b = _gf_false;
char *pwd = NULL;
char tmp_buf[2048] = {0,};
cmd_args = state->input;
switch (key) {
case ARGP_VOLFILE_SERVER_KEY:
cmd_args->volfile_server = gf_strdup (arg);
break;
case ARGP_VOLFILE_MAX_FETCH_ATTEMPTS:
n = 0;
if (gf_string2uint_base10 (arg, &n) == 0) {
cmd_args->max_connect_attempts = n;
break;
}
argp_failure (state, -1, 0,
"Invalid limit on connect attempts %s", arg);
break;
case ARGP_READ_ONLY_KEY:
cmd_args->read_only = 1;
break;
case ARGP_MAC_COMPAT_KEY:
if (!arg)
arg = "on";
if (gf_string2boolean (arg, &b) == 0) {
cmd_args->mac_compat = b;
break;
}
argp_failure (state, -1, 0,
"invalid value \"%s\" for mac-compat", arg);
break;
case ARGP_VOLUME_FILE_KEY:
if (cmd_args->volfile)
GF_FREE (cmd_args->volfile);
if (arg[0] != '/') {
pwd = getcwd (NULL, PATH_MAX);
if (!pwd) {
argp_failure (state, -1, errno,
"getcwd failed with error no %d",
errno);
break;
}
snprintf (tmp_buf, 1024, "%s/%s", pwd, arg);
cmd_args->volfile = gf_strdup (tmp_buf);
free (pwd);
} else {
cmd_args->volfile = gf_strdup (arg);
}
break;
case ARGP_LOG_SERVER_KEY:
if (cmd_args->log_server)
GF_FREE (cmd_args->log_server);
cmd_args->log_server = gf_strdup (arg);
break;
case ARGP_LOG_LEVEL_KEY:
if (strcasecmp (arg, ARGP_LOG_LEVEL_NONE_OPTION) == 0) {
cmd_args->log_level = GF_LOG_NONE;
break;
}
if (strcasecmp (arg, ARGP_LOG_LEVEL_CRITICAL_OPTION) == 0) {
cmd_args->log_level = GF_LOG_CRITICAL;
break;
}
if (strcasecmp (arg, ARGP_LOG_LEVEL_ERROR_OPTION) == 0) {
cmd_args->log_level = GF_LOG_ERROR;
break;
}
if (strcasecmp (arg, ARGP_LOG_LEVEL_WARNING_OPTION) == 0) {
cmd_args->log_level = GF_LOG_WARNING;
break;
}
if (strcasecmp (arg, ARGP_LOG_LEVEL_NORMAL_OPTION) == 0) {
cmd_args->log_level = GF_LOG_NORMAL;
break;
}
if (strcasecmp (arg, ARGP_LOG_LEVEL_DEBUG_OPTION) == 0) {
cmd_args->log_level = GF_LOG_DEBUG;
break;
}
if (strcasecmp (arg, ARGP_LOG_LEVEL_TRACE_OPTION) == 0) {
cmd_args->log_level = GF_LOG_TRACE;
break;
}
argp_failure (state, -1, 0, "unknown log level %s", arg);
break;
case ARGP_LOG_FILE_KEY:
cmd_args->log_file = gf_strdup (arg);
break;
case ARGP_VOLFILE_SERVER_PORT_KEY:
n = 0;
if (gf_string2uint_base10 (arg, &n) == 0) {
cmd_args->volfile_server_port = n;
break;
}
argp_failure (state, -1, 0,
"unknown volfile server port %s", arg);
break;
case ARGP_LOG_SERVER_PORT_KEY:
n = 0;
if (gf_string2uint_base10 (arg, &n) == 0) {
cmd_args->log_server_port = n;
break;
}
argp_failure (state, -1, 0,
"unknown log server port %s", arg);
break;
case ARGP_VOLFILE_SERVER_TRANSPORT_KEY:
cmd_args->volfile_server_transport = gf_strdup (arg);
break;
case ARGP_VOLFILE_ID_KEY:
cmd_args->volfile_id = gf_strdup (arg);
break;
case ARGP_PID_FILE_KEY:
cmd_args->pid_file = gf_strdup (arg);
break;
case ARGP_NO_DAEMON_KEY:
cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
break;
case ARGP_RUN_ID_KEY:
cmd_args->run_id = gf_strdup (arg);
break;
case ARGP_DEBUG_KEY:
cmd_args->debug_mode = ENABLE_DEBUG_MODE;
break;
case ARGP_DIRECT_IO_MODE_KEY:
if (!arg)
arg = "on";
if (gf_string2boolean (arg, &b) == 0) {
cmd_args->fuse_direct_io_mode = b;
break;
}
argp_failure (state, -1, 0,
"unknown direct I/O mode setting \"%s\"", arg);
break;
case ARGP_ENTRY_TIMEOUT_KEY:
d = 0.0;
gf_string2double (arg, &d);
if (!(d < 0.0)) {
cmd_args->fuse_entry_timeout = d;
break;
}
argp_failure (state, -1, 0, "unknown entry timeout %s", arg);
break;
case ARGP_ATTRIBUTE_TIMEOUT_KEY:
d = 0.0;
gf_string2double (arg, &d);
if (!(d < 0.0)) {
cmd_args->fuse_attribute_timeout = d;
break;
}
argp_failure (state, -1, 0,
"unknown attribute timeout %s", arg);
break;
case ARGP_CLIENT_PID_KEY:
if (gf_string2int (arg, &cmd_args->client_pid) == 0) {
cmd_args->client_pid_set = 1;
break;
}
argp_failure (state, -1, 0,
"unknown client pid %s", arg);
break;
case ARGP_VOLFILE_CHECK_KEY:
cmd_args->volfile_check = 1;
break;
case ARGP_VOLUME_NAME_KEY:
cmd_args->volume_name = gf_strdup (arg);
break;
case ARGP_XLATOR_OPTION_KEY:
gf_remember_xlator_option (&cmd_args->xlator_options, arg);
break;
case ARGP_KEY_NO_ARGS:
break;
case ARGP_KEY_ARG:
if (state->arg_num >= 1)
argp_usage (state);
cmd_args->mount_point = gf_strdup (arg);
break;
case ARGP_DUMP_FUSE_KEY:
cmd_args->dump_fuse = gf_strdup (arg);
break;
case ARGP_BRICK_NAME_KEY:
cmd_args->brick_name = gf_strdup (arg);
break;
case ARGP_BRICK_PORT_KEY:
n = 0;
if (gf_string2uint_base10 (arg, &n) == 0) {
cmd_args->brick_port = n;
break;
}
argp_failure (state, -1, 0,
"unknown brick (listen) port %s", arg);
break;
}
return 0;
}
static error_t
main_argp_parser(int key, char *arg, struct argp_state *state)
{
CAST(lsh_writekey_options, self, state->input);
switch(key)
{
default:
return ARGP_ERR_UNKNOWN;
case ARGP_KEY_INIT:
state->child_inputs[0] = &self->style;
state->child_inputs[1] = NULL;
break;
case ARGP_KEY_END:
if (!self->file)
{
char *home = getenv("HOME");
struct lsh_string *s;
if (!home)
{
argp_failure(state, EXIT_FAILURE, 0, "$HOME not set.");
return EINVAL;
}
else
{
#ifndef MACOS
s = ssh_format("%lz/.lsh", home);
if (mkdir(lsh_get_cstring(s), 0755) < 0)
{
if (errno != EEXIST)
argp_failure(state, EXIT_FAILURE, errno, "Creating directory %s failed.", s->data);
}
lsh_string_free(s);
self->file = ssh_format("%lz/.lsh/identity", home);
#else
self->file = ssh_format("%lzidentity", home);
#endif
}
}
if (self->crypto)
{
if (!self->label)
{
const char *name = getenv("LOGNAME");
#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN 300
#endif
char host[MAXHOSTNAMELEN];
if (!name)
{
argp_failure(state, EXIT_FAILURE, 0,
"LOGNAME not set. Please use the -l option.");
return EINVAL;
}
if ( (gethostname(host, sizeof(host)) < 0)
&& (errno != ENAMETOOLONG) )
argp_failure(state, EXIT_FAILURE, errno,
"Can't get the host name. Please use the -l option.");
self->label = ssh_format("%lz@%lz", name, host);
}
while (!self->passphrase)
{
struct lsh_string *pw;
struct lsh_string *again;
pw = INTERACT_READ_PASSWORD(self->tty, 500,
ssh_format("Enter new passphrase: "), 1);
if (!pw)
argp_failure(state, EXIT_FAILURE, 0, "Aborted.");
again = INTERACT_READ_PASSWORD(self->tty, 500,
ssh_format("Again: "), 1);
if (!again)
argp_failure(state, EXIT_FAILURE, 0, "Aborted.");
if (lsh_string_eq(pw, again))
self->passphrase = pw;
else
lsh_string_free(pw);
lsh_string_free(again);
}
}
break;
case 'o':
self->file = make_string(arg);
break;
case 'i':
{
long i;
char *end;
i = strtol(arg, &end, 0);
if ((end == arg) || *end || (i < 1))
{
argp_failure(state, EXIT_FAILURE, 0, "Invalid iteration count.");
return EINVAL;
}
else if (i > PKCS5_MAX_ITERATIONS)
{
argp_error(state, "Iteration count ridiculously large (> %d).",
PKCS5_MAX_ITERATIONS);
return EINVAL;
}
else
self->iterations = i;
break;
}
case 'c':
{
int name = lookup_crypto(self->crypto_algorithms, arg, &self->crypto);
if (name)
self->crypto_name = name;
else
{
list_crypto_algorithms(state, self->crypto_algorithms);
argp_error(state, "Unknown crypto algorithm '%s'.", arg);
}
break;
}
case 'l':
self->label = ssh_format("%lz", arg);
break;
case 'p':
self->passphrase = ssh_format("%lz", arg);
break;
}
return 0;
}
// Process command line options and arguments
static int
parse_opt (int key, char *arg, struct argp_state *state)
{
int *arg_count = state->input;
switch (key)
{
case 't': //Run the self test suite
{
self_test();
exit(0);
}
case 'p': //Print the generated tree
{
opt_print_tree = 1;
break;
}
case 'l': //Find Longest Common Substring (LCS)
{
opt_lcs = 1;
break;
}
case 'a': //Find Longest Common Substring (LCS)
{
opt_acs = 1;
break;
}
case ARGP_KEY_ARG: //Process the command line arguments
{
(*arg_count)--;
if (*arg_count == 3){
input_text = (unsigned char*)arg;
}
else if (*arg_count == 2){
input_text2 = (unsigned char*)arg;
}
}
break;
case ARGP_KEY_END:
{
printf ("\n");
if (*arg_count >= 4){
argp_failure (state, 1, 0, "too few arguments");
}
else if (*arg_count < 0){
argp_failure (state, 1, 0, "too many arguments");
}
else {
if (opt_print_tree){
// Construct the tree and process based on supplied options
buildSuffixTree(input_text, input_text2, opt_print_tree);
freeSuffixTreeByPostOrder(root);
printf(tree_string, 's');
}
if (opt_lcs){
char *lcs;
if(!input_text2){
argp_failure (state, 1, 0, "missing comparison string");
}
printf("Longest Common Substring in %s and %s is: ",
input_text,
input_text2);
lcs = getLongestCommonSubstring(input_text,
input_text2,
opt_print_tree);
printf(lcs, 's');
}
if (opt_acs){
char *acs;
if(!input_text2){
argp_failure (state, 1, 0, "missing comparison string");
}
printf("All Common Substrings in %s and %s are: ",
input_text,
input_text2);
acs = getAllCommonSubstrings(input_text,
input_text2,
opt_print_tree);
printf(acs, 's');
}
}
}
break;
}
return 0;
}
/* Parse our options... */
error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
error_t err;
switch (key)
{
case 'v':
verbose = 1;
break;
case 'n':
numeric = 1;
break;
case 's':
subsystem = 1;
break;
#define SELECT_TARGET(target) \
if (setup_target) \
argp_error (state, "Multiple targets specified."); \
setup_target = target;
case OPT_TARGET_TASK:
SELECT_TARGET (setup_task_target);
break;
case OPT_TARGET_THREAD:
SELECT_TARGET (setup_thread_target);
break;
case OPT_TARGET_PROC:
SELECT_TARGET (setup_proc_target);
break;
case OPT_TARGET_AUTH:
SELECT_TARGET (setup_auth_target);
break;
case OPT_TARGET_EXTRACT:;
process_t proc;
pid_t pid;
char *end;
pid = strtol (arg, &end, 10);
if (arg == end || *end != '.')
argp_error (state, "Expected format PID.PORT, got `%s'.", arg);
arg = end + 1;
extract_target_port = strtol (arg, &end, 10);
if (arg == end || *end != '\0')
argp_error (state, "Expected format PORT, got `%s'.", arg);
proc = getproc ();
err = proc_pid2task (proc, pid, &extract_target_task);
if (err)
argp_failure (state, 1, err,
"Could not get task of process %d", pid);
extract_target_type = MACH_MSG_TYPE_COPY_SEND; /* XXX */
SELECT_TARGET (setup_extract_target);
break;
case ARGP_KEY_ARG:
SELECT_TARGET (setup_hurd_target);
setup_argument = arg;
break;
#undef SELECT_TARGET
case ARGP_KEY_NO_ARGS:
if (setup_target == NULL)
argp_usage (state);
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
static int parse_opt (int key, char *arg, struct argp_state *state) {
int *arg_lb_count = state->input;
switch (key) {
case 'd': {
char *endptr;
program_duration = strtoul(arg, &endptr, 10);
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "Cannot convert string to number\n");
fprintf (stderr, "OPT[ERROR]: 'd' Cannot convert string to number\n");
exit(-1);
}
printf("OPT: Program duration set to %s\n", arg);
break;
}
case 'q': {
char *endptr;
queue_count_arg = strtoul(arg, &endptr, 10);
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "Cannot convert string to number\n");
fprintf (stderr, "OPT[ERROR]: 'q' Cannot convert string to number\n");
exit(-1);
}
if (queue_count_arg > 8) {
free(q_ins_ratios);
free(q_rm_ratios);
q_ins_ratios = (unsigned int*) malloc(queue_count_arg * sizeof(unsigned int));
q_rm_ratios = (unsigned int*) malloc(queue_count_arg * sizeof(unsigned int));
for (int i = 0; i < queue_count_arg; i++) {
q_ins_ratios[i] = 1;
q_rm_ratios[i] = 1;
}
}
printf("OPT: Queue count set to %s\n", arg);
break;
}
case 'l': {
if ( strcmp(arg, "true") == 0 ) {
printf("OPT: load balancing thread will be enabled\n");
load_balance_thread_arg = true;
}
else if ( strcmp(arg, "false") == 0 ) {
printf("OPT: load balancing thread will NOT be enabled\n");
load_balance_thread_arg = false;
}
else {
//LOG_ERR_T( (long) -1, "Option to load balance argument must be ""true"" or ""false""\n");
fprintf(stderr, "OPT[ERROR]: Option to load balance argument must be ""true"" or ""false""\n");
exit(-1);
}
break;
}
case 'h': {
printf("OPT: Hook enabled. Enter 'set var debug_wait=1' to start program.\n");
hook = true;
break;
}
case 's': {
char *endptr;
max_qsize = strtoul(arg, &endptr, 10);
if ( endptr == arg ) {
//LOG_ERR_T( (long) -1, "Cannot parse number\n");
fprintf(stderr, "OPT[ERROR]: Maximum qsize must be number\n");
exit(-1);
}
printf("OPT: Maximum queue size was set to %lu.\n", max_qsize);
break;
}
case 'a': {
char *endptr;
item_amount = strtoul(arg, &endptr, 10);
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "Cannot convert string to number\n");
fprintf (stderr, "OPT[ERROR]: 'a' Cannot convert string to number\n");
exit(-1);
}
printf("OPT: Amount of items to insert set to %s\n", arg);
break;
}
case 150: {
local_lb_threshold_percent = atof(arg);
if ( local_lb_threshold_percent == 0.0 ) {
//LOG_ERR_T( (long) -1, "Cannot parse floating point number\n");
fprintf(stderr, "OPT[ERROR]: LOCAL THRESHOLD PERCENT: Cannot parse floating point number\n");
exit(-1);
}
printf("OPT: Local LB threshold set to %lf%%\n", local_lb_threshold_percent);
(*arg_lb_count)++;
break;
}
case 151: {
global_lb_threshold_percent = atof(arg);
if ( global_lb_threshold_percent == 0.0 ) {
//LOG_ERR_T( (long) -1, "Cannot parse floating point number\n");
fprintf(stderr, "OPT[ERROR]: GLOBAL THRESHOLD PERCENT: Cannot parse floating point number\n");
exit(-1);
}
printf("OPT: Global LB threshold set to %lf%%\n", global_lb_threshold_percent);
(*arg_lb_count)++;
break;
}
case 152: {
char *endptr;
local_lb_threshold_static = strtoul(arg, &endptr, 10);
if ( endptr == arg ) {
//LOG_ERR_T( (long) -1, "Cannot parse number\n");
fprintf(stderr, "OPT[ERROR]: LOCAL THRESHOLD STATIC: Cannot parse number\n");
exit(-1);
}
printf("OPT: Local LB threshold set to %lu items\n", local_lb_threshold_static);
(*arg_lb_count)++;
break;
}
case 153: {
char *endptr;
global_lb_threshold_static = strtoul(arg, &endptr, 10);
if ( endptr == arg ) {
//LOG_ERR_T( (long) -1, "Cannot parse number\n");
fprintf(stderr, "OPT[ERROR]: GLOBAL THRESHOLD STATIC: Cannot parse number\n");
exit(-1);
}
printf("OPT: Global LB threshold set to %lu items\n", global_lb_threshold_static);
(*arg_lb_count)++;
break;
}
case 154: {
if ( strcmp(arg, "static") == 0 ) {
printf("OPT: Threshold type set to static\n");
threshold_type_arg = 1;
}
else if ( strcmp(arg, "percent") == 0 ) {
printf("OPT: Threshold type set to percent\n");
threshold_type_arg = 2;
}
else if ( strcmp(arg, "dynamic") == 0 ) {
printf("OPT: Threshold type set to dynamic\n");
threshold_type_arg = 3;
}
else {
//LOG_ERR_T( (long) -1, "Option to load balance type argument must be ""static"", ""percent"" or ""dynamic""\n");
fprintf(stderr, "OPT[ERROR]: Option to Threshold type argument must be ""static"", ""percent"" or ""dynamic""\n");
exit(-1);
}
break;
}
case 155: {
if ( strcmp(arg, "all") == 0 ) {
printf("OPT: Load balancing type set to balance all queues equal\n");
local_balance_type_arg = 1;
}
else if ( strcmp(arg, "pair") == 0 ) {
printf("OPT: Load balancing type set to balance between pairs of queue\n");
local_balance_type_arg = 2;
}
else {
//LOG_ERR_T( (long) -1, "Option to load balance type argument must be ""static"", ""percent"" or ""dynamic""\n");
fprintf(stderr, "OPT[ERROR]: Option to load balance type argument must be ""all"" or ""pair""\n");
exit(-1);
}
break;
}
case 220: {
char *endptr;
q_ins_ratios[0] = strtoul(arg, &endptr, 10);
errno = 0;
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "cannot convert string to number\n");
argp_failure (state, 1, 0, "OPT[ERROR]: 'qri1' Cannot convert string to number");
exit(-1);
}
printf("OPT: Q1 insertion ratio set to %u\n", q_ins_ratios[0]);
break;
}
case 221: {
char *endptr;
q_ins_ratios[1] = strtoul(arg, &endptr, 10);
errno = 0;
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "cannot convert string to number\n");
argp_failure (state, 1, 0, "OPT[ERROR]: 'qri2' Cannot convert string to number");
exit(-1);
}
printf("OPT: Q2 insertion ratio set to %u\n", q_ins_ratios[1]);
break;
}
case 222: {
char *endptr;
q_ins_ratios[2] = strtoul(arg, &endptr, 10);
errno = 0;
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "cannot convert string to number\n");
argp_failure (state, 1, 0, "OPT[ERROR]: 'qri3' Cannot convert string to number");
exit(-1);
}
printf("OPT: Q3 insertion ratio set to %u\n", q_ins_ratios[2]);
break;
}
case 223: {
char *endptr;
q_ins_ratios[3] = strtoul(arg, &endptr, 10);
errno = 0;
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "cannot convert string to number\n");
argp_failure (state, 1, 0, "OPT[ERROR]: 'qri4' Cannot convert string to number");
exit(-1);
}
printf("OPT: Q4 insertion ratio set to %u\n", q_ins_ratios[3]);
break;
}
case 225: {
char *endptr;
q_rm_ratios[0] = strtoul(arg, &endptr, 10);
errno = 0;
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "cannot convert string to number\n");
argp_failure (state, 1, 0, "OPT[ERROR]: 'qrm1' Cannot convert string to number");
exit(-1);
}
printf("OPT: Q1 removal ratio set to %u\n", q_rm_ratios[0]);
break;
}
case 226: {
char *endptr;
q_rm_ratios[1] = strtoul(arg, &endptr, 10);
errno = 0;
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "cannot convert string to number\n");
argp_failure (state, 1, 0, "OPT[ERROR]: 'qrm2' Cannot convert string to number");
exit(-1);
}
printf("OPT: Q2 removal ratio set to %u\n", q_rm_ratios[1]);
break;
}
case 227: {
char *endptr;
q_rm_ratios[2] = strtoul(arg, &endptr, 10);
errno = 0;
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "cannot convert string to number\n");
argp_failure (state, 1, 0, "OPT[ERROR]: 'qrm3' Cannot convert string to number");
exit(-1);
}
printf("OPT: Q3 removal ratio set to %u\n", q_rm_ratios[2]);
break;
}
case 228: {
char *endptr;
q_rm_ratios[3] = strtoul(arg, &endptr, 10);
errno = 0;
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "cannot convert string to number\n");
argp_failure (state, 1, 0, "OPT[ERROR]: 'qrm4' Cannot convert string to number");
exit(-1);
}
printf("OPT: Q4 removal ratio set to %u\n", q_rm_ratios[3]);
break;
}
case 224: {
char *endptr;
computation_load = strtoul(arg, &endptr, 10);
if (endptr == arg) {
//LOG_ERR_T( (long) -1, "Cannot convert string to number\n");
fprintf (stderr, "OPT[ERROR]: 'computation_load' Cannot convert string to number\n");
exit(-1);
}
free(q_ins_ratios);
free(q_rm_ratios);
q_ins_ratios = (unsigned int*) malloc(queue_count_arg * sizeof(unsigned int));
q_rm_ratios = (unsigned int*) malloc(queue_count_arg * sizeof(unsigned int));
for (int i = 0; i < queue_count_arg; i++) {
q_ins_ratios[i] = computation_load;
q_rm_ratios[i] = computation_load;
}
printf("OPT: Computation load set to %s\n", arg);
break;
}
case ARGP_KEY_END: {
printf("\n");
if ( *arg_lb_count < 3 && *arg_lb_count != 0 ) {
argp_usage (state);
//LOG_ERR_T( (long) -1, "Too few arguments for LB\n");
argp_failure (state, 1, 0, "OPT[ERROR]: Too few arguments for LB");
exit(-1);
}
break;
}
default: {
//printf("OPT: Unknown argument '%s'\n", arg);
return ARGP_ERR_UNKNOWN;
}
}
//If returns non zero value, argp will stop and raise that error value
return 0;
}
/* Parse a single option. */
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
/* Get the input argument from argp_parse, which we
know is a pointer to our arguments structure. */
struct arguments *arguments = state->input;
int *arg_count = arguments->arg_count;
switch (key)
{
case 't':
arguments->task = arg;
break;
case 'k':
arguments->k = atoi(arg);
break;
case 'n':
arguments->n_iter = atoi(arg);
break;
case 's':
arguments->solver = arg;
break;
case 'r':
arguments->l2_reg = atof(arg);
break;
case 222:
arguments->l2_reg_w = atof(arg);
break;
case 333:
arguments->l2_reg_V = atof(arg);
break;
case 444:
arguments->step_size = atof(arg);
break;
case 556:
arguments->rng_seed = atof(arg);
break;
case 555:
arguments->train_pairs = arg;
break;
case 55:
arguments->test_predict_file = arg;
break;
case 'i':
arguments->init_var = atof(arg);
break;
case 'q':
arguments->silent = 1;
break;
case 'v':
arguments->verbose = 1;
break;
case ARGP_KEY_ARG:
{
(*arg_count)--;
if (state->arg_num == 0){
arguments->train_file = arg;
}
if (state->arg_num == 1){
arguments->test_file = arg;
}
arguments->args[state->arg_num] = arg;
}
break;
case ARGP_KEY_END:
{
if (*arg_count > 0)
argp_failure (state, 1, 0, "too few arguments");
else if (*arg_count < 0)
argp_failure (state, 1, 0, "too many arguments");
}
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
struct fstab_argp_params *params = state->input;
error_t err;
switch (key)
{
case ARGP_KEY_INIT:
state->child_inputs[0] = params; /* pass down to fstab_argp parser */
break;
case 'd':
source_goaway = 1;
break;
case FAKE_KEY:
fake = 1;
break;
case 'f':
goaway_flags |= FSYS_GOAWAY_FORCE;
break;
case 'n':
/* do nothing */
break;
case 'r':
readonly = 1;
break;
case 'S':
goaway_flags |= FSYS_GOAWAY_NOSYNC;
break;
case 'O':
err = argz_create_sep (arg, ',', &test_opts, &test_opts_len);
if (err)
argp_failure (state, 100, ENOMEM, "%s", arg);
break;
case 'v':
verbose += 1;
break;
case ARGP_KEY_ARG:
err = argz_add (&targets, &targets_len, arg);
if (err)
argp_failure (state, 100, ENOMEM, "%s", arg);
break;
case ARGP_KEY_NO_ARGS:
if (! params->do_all)
{
argp_error (state,
"filesystem argument required if --all is not given");
return EINVAL;
}
break;
case ARGP_KEY_END:
if (params->do_all && targets)
{
argp_error (state, "filesystem argument not allowed with --all");
return EINVAL;
}
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
struct fstab_argp_params *params = state->input;
error_t err;
switch (key)
{
case ARGP_KEY_INIT:
state->child_inputs[0] = params; /* pass down to fstab_argp parser */
break;
#define ARGZ(call) \
err = argz_##call; \
if (err) \
argp_failure (state, 100, ENOMEM, "%s", arg); \
break
case 'r':
ARGZ (add (&options, &options_len, "ro"));
case 'w':
ARGZ (add (&options, &options_len, "rw"));
case 'u':
ARGZ (add (&options, &options_len, "update"));
case 'B':
ARGZ (add (&options, &options_len, "bind"));
case 'o':
ARGZ (add_sep (&options, &options_len, arg, ','));
case 'v':
++verbose;
break;
#undef ARGZ
case 'T':
{
char *end;
unsigned long int ms = strtoul (arg, &end, 10);
if (end && *end == '\0')
timeout = ms;
else
{
argp_error (state,
"--timeout needs a numeric argument (milliseconds)");
return EINVAL;
}
}
break;
case 'p':
if (arg == 0 || !strcasecmp (arg, "fstab"))
query_format = qf_fstab;
else if (!strcasecmp (arg, "mount"))
query_format = qf_standard;
else if (!strcasecmp (arg, "translator")
|| !strcasecmp (arg, "showtrans"))
query_format = qf_translator;
else
{
argp_error (state, "invalid argument to --format");
return EINVAL;
}
break;
case 'n':
/* do nothing */
break;
case 'f':
fake = 1;
break;
case 'O':
err = argz_create_sep (arg, ',', &test_opts, &test_opts_len);
if (err)
argp_failure (state, 100, ENOMEM, "%s", arg);
break;
case ARGP_KEY_ARG:
if (mountpoint == 0) /* One arg: mountpoint */
mountpoint = arg;
else if (device == 0) /* Two args: device, mountpoint */
{
device = mountpoint;
mountpoint = arg;
}
else /* More than two args. */
{
argp_error (state, "too many arguments");
return EINVAL;
}
break;
case ARGP_KEY_NO_ARGS:
if (! params->do_all)
{
params->do_all = 1;
mode = query;
}
break;
case ARGP_KEY_END:
if (params->do_all && mountpoint)
{
argp_error (state, "filesystem argument not allowed with --all");
return EINVAL;
}
if (mode == query && options_len != 0)
{
argp_error (state,
"mount options not allowed without filesystem argument");
return EINVAL;
}
if (mountpoint)
switch (argz_count (params->types, params->types_len))
{
default:
argp_error (state,
"multiple types not allowed with filesystem argument");
return EINVAL;
case 1:
fstype = params->types;
params->types = 0;
params->types_len = 0;
break;
case 0:
break;
}
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
int parserFunc (int key, char *arg, struct argp_state *state)
{
(void) arg;
ArgParserLector* argParser = static_cast<ArgParserLector*> (state->input);
switch (key) {
case 'i':
{
char* endptr;
long idLocal = strtol (arg, &endptr, 10);
if (!(*arg != 0 && *endptr == 0) || idLocal <= 0) {
argp_failure (state, 1, 0,
"el id local debe ser mayor a 0.");
}
if (idLocal > std::numeric_limits<int>::max ()) {
argp_failure (state, 1, 0,
"el id local debe ser menor a %ld.",
std::numeric_limits<int>::max ());
}
argParser->_idLocal = static_cast<int> (idLocal);
break;
}
case 'b':
{
char* endptr;
long fdBroker = strtol (arg, &endptr, 10);
if (!(*arg != 0 && *endptr == 0) || fdBroker <= 0) {
argp_failure (state, 1, 0,
"el fd de la conexión al broker debe ser mayor a 0.");
}
if (fdBroker > std::numeric_limits<int>::max ()) {
argp_failure (state, 1, 0,
"el fd de la conexión al broker debe ser menor a %ld.",
std::numeric_limits<int>::max ());
}
argParser->_fdBroker = static_cast<int> (fdBroker);
break;
}
case ARGP_KEY_ARG:
if (state->arg_num == 0) {
argParser->_mqInterfaz = arg;
} else if (state->arg_num == 1) {
argParser->_broker = arg;
} else if (state->arg_num == 2) {
argParser->_recursos = arg;
} else if (state->arg_num == 3) {
char* endptr;
long idPuerta = strtol (arg, &endptr, 10);
if (!(*arg != 0 && *endptr == 0) || idPuerta <= 0) {
argp_failure (state, 1, 0,
"el id debe ser mayor a 0.");
}
argParser->_idPuerta = idPuerta;
}
break;
case ARGP_KEY_END:
if (state->arg_num < NUM_ARGS) {
argp_failure (state, 1, 0,
"no hay suficientes argumentos");
} else if (state->arg_num > NUM_ARGS) {
argp_failure (state, 1, 0,
"demasiados argumentos");
}
break;
}
return 0;
}
static error_t
main_argp_parser(int key, char *arg, struct argp_state *state)
{
CAST(srp_gen_options, self, state->input);
switch(key)
{
default:
return ARGP_ERR_UNKNOWN;
case ARGP_KEY_INIT:
state->child_inputs[0] = &self->style;
state->child_inputs[1] = NULL;
break;
case ARGP_KEY_END:
if (!self->name)
argp_error(state, "No user name given. Use the -l option, or set LOGNAME in the environment.");
{
struct lsh_fd *fd;
if (self->file)
{
fd = io_write_file(self->backend, self->file->data,
O_CREAT | O_EXCL | O_WRONLY,
0600, BLOCK_SIZE,
NULL, self->e);
if (!fd)
argp_failure(state, EXIT_FAILURE, errno, "Could not open '%s'.", self->file->data);
}
else
{
fd = io_write(make_lsh_fd(self->backend,
STDOUT_FILENO, "stdout",
self->e),
BLOCK_SIZE, NULL);
}
self->dest = &fd->write_buffer->super;
}
while (!self->passwd)
{
struct lsh_string *pw;
struct lsh_string *again;
pw = INTERACT_READ_PASSWORD(self->tty, 500,
ssh_format("Enter new SRP password: "******"Aborted.");
again = INTERACT_READ_PASSWORD(self->tty, 500,
ssh_format("Again: "), 1);
if (!again)
argp_failure(state, EXIT_FAILURE, 0, "Aborted.");
if (lsh_string_eq(pw, again))
self->passwd = pw;
else
lsh_string_free(pw);
lsh_string_free(again);
}
if (self->style < 0)
self->style = self->file ? SEXP_CANONICAL : SEXP_TRANSPORT;
break;
case 'o':
self->file = make_string(arg);
break;
case 'p':
self->passwd = ssh_format("%lz", arg);
break;
}
return 0;
}
