int cli_look_next_string_token(int *eof)
{
int tok_len;
char *old_tp;
assert(cli_lex_in_ptr);
if (!strlen(cli_lex_in_ptr->tp))
return(0);
old_tp = cli_lex_in_ptr->tp;
tok_len = cli_get_string_token(eof);
cli_lex_in_ptr->tp = old_tp;
return(tok_len);
}
/*
* ---------------------------------------------------------
* Parse one option.
* Read tokens from the input.
* Check if it is a valid qualifier or parameter.
* If it is a parameter, get it, and save it in the
* global parameter array.
* If it is a qualifier, get its value and save it in a value table,
* corresponding to this option.
*
* Arguments:
* pcmd_parms - pointer to command parameter table
* eof - pointer to end of file flag
*
* Return:
* 1 - option parsed OK
* -1 - failure to parse option
* 0 - no more tokens, in which case
* the eof flag is set on end of file.
* ---------------------------------------------------------
*/
int parse_arg(CLI_ENTRY *pcmd_parms, int *eof)
{
CLI_ENTRY *pparm;
char *opt_str, *val_str;
int neg_flg;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
/* -----------------------------------------
* get qualifier marker, or parameter token
* -----------------------------------------
*/
if (VAL_LIST == gpcmd_verb->val_type && TREF(parms_cnt) == gpcmd_verb->max_parms)
return (0);
if (!cli_look_next_token(eof))
return (0);
/* -------------------------------------------------------------------
* here cli_token_buf is set by the previous cli_look_next_token(eof)
* call itself since it in turn calls cli_gettoken()
* -------------------------------------------------------------------
*/
if (!cli_is_qualif(cli_token_buf) && !cli_is_assign(cli_token_buf))
{ /* ----------------------------------------------------
* If token is not a qualifier, it must be a parameter
*
* No need to check for eof on cli_get_string_token(eof) since
* already checked that on the previous cli_look_next_token.
* now you have to skip initial white spaces before reading
* the string since cli_get_string_token considers a space
* as a blank token. hence the need for the skip_white_space()
* call.
* ------------------------------------------------------------
*/
skip_white_space();
cli_get_string_token(eof);
if (TREF(parms_cnt) >= gpcmd_verb->max_parms)
{
SNPRINTF(cli_err_str, MAX_CLI_ERR_STR, "Too many parameters ");
return (-1);
}
TAREF1(parm_str_len, TREF(parms_cnt)) = strlen(cli_token_buf) + 1;
GROW_HEAP_IF_NEEDED(TREF(parms_cnt));
memcpy(TAREF1(parm_ary, TREF(parms_cnt)), cli_token_buf, TAREF1(parm_str_len, TREF(parms_cnt)));
(TREF(parms_cnt))++;
return (1);
}
/* ---------------------------------------------------------------------
* cli_gettoken(eof) need not be checked for return value since earlier
* itself we have checked for return value in cli_look_next_token(eof)
* ---------------------------------------------------------------------
*/
cli_gettoken(eof);
opt_str = cli_token_buf;
if (!pcmd_parms)
{
SNPRINTF(cli_err_str, MAX_CLI_ERR_STR, "No qualifiers allowed for this command");
return (-1);
}
/* ------------------------------------------
* Qualifiers must start with qualifier token
* ------------------------------------------
*/
if (!cli_is_qualif(cli_token_buf))
{
SNPRINTF(cli_err_str, MAX_CLI_ERR_STR, "Qualifier expected instead of : %s ", opt_str);
return (-1);
}
/* -------------------------
* Get the qualifier string
* -------------------------
*/
if (!cli_look_next_token(eof) || 0 == cli_gettoken(eof))
{
SNPRINTF(cli_err_str, MAX_CLI_ERR_STR, "Qualifier string missing %s ", opt_str);
return (-1);
}
/* ---------------------------------------
* Fold the qualifier string to upper case
* ---------------------------------------
*/
cli_strupper(opt_str);
/* -------------------------
* See if option is negated and update
* -------------------------
*/
if (-1 == (neg_flg = cli_check_negated(&opt_str, pcmd_parms, &pparm)))
return (-1);
/* -------------------------------------------------------------
* If value is disallowed for this qualifier, and an assignment
* token is encounter, report error, values not allowed for
* negated qualifiers
* -------------------------------------------------------------
*/
if (neg_flg || VAL_DISALLOWED == pparm->required)
{
if (cli_look_next_token(eof) && cli_is_assign(cli_token_buf))
{
SNPRINTF(cli_err_str, MAX_CLI_ERR_STR,
"Assignment is not allowed for this option : %s",
pparm->name);
return (-1);
}
} else
{ /* --------------------------------------------------
* Get Value either optional, or required.
* In either case, there must be an assignment token
* --------------------------------------------------
*/
if (!cli_look_next_token(eof) || !cli_is_assign(cli_token_buf))
{
if (VAL_REQ == pparm->required)
{
SNPRINTF(cli_err_str, MAX_CLI_ERR_STR, "Option : %s needs value", pparm->name);
return (-1);
} else
{
if (pparm->present)
{
/* The option was specified before, so clean up that one,
* the last one overrides
*/
if (pparm->pval_str)
free(pparm->pval_str);
if (pparm->qual_vals)
clear_parm_vals(pparm->qual_vals, FALSE);
}
/* -------------------------------
* Allocate memory and save value
* -------------------------------
*/
if (pparm->parm_values)
{
MALLOC_CPY_STR(pparm->pval_str, pparm->parm_values->prompt);
if (!cli_get_sub_quals(pparm))
return (-1);
}
}
} else
{
cli_gettoken(eof);
/* ---------------------------------
* Get the assignment token + value
* ---------------------------------
*/
if (!cli_is_assign(cli_token_buf))
{
SNPRINTF(cli_err_str, MAX_CLI_ERR_STR, "Assignment missing after option : %s", pparm->name);
return (-1);
}
/* --------------------------------------------------------
* get the value token, "=" is NOT a token terminator here
* --------------------------------------------------------
*/
if (!cli_look_next_string_token(eof) || 0 == cli_get_string_token(eof))
{
SNPRINTF(cli_err_str, MAX_CLI_ERR_STR, "Unrecognized option : %s, value expected but not found",
pparm->name);
cli_lex_in_ptr->tp = 0;
return (-1);
}
val_str = cli_token_buf;
if (!cli_numeric_check(pparm, val_str))
{
cli_lex_in_ptr->tp = 0;
return (-1);
}
if (pparm->present)
{ /* The option was specified before, so clean up that one,
* the last one overrides
*/
if (pparm->pval_str)
free(pparm->pval_str);
if (pparm->qual_vals)
clear_parm_vals(pparm->qual_vals, FALSE);
}
/* -------------------------------
* Allocate memory and save value
* -------------------------------
*/
MALLOC_CPY_STR(pparm->pval_str, cli_token_buf);
if (!cli_get_sub_quals(pparm))
return (-1);
}
}
if (pparm->present)
pparm->negated = 0;
pparm->negated = neg_flg;
pparm->present = 1;
if (NULL != pparm->func)
func = pparm->func;
/* ----------------------------------------------------------------------------------------------------------------------
* If there is another level, update global pointers
* Notice that this global pointer updation should be done only at the end of this routine in order to ensure that the
* check_disallow() function invoked below sees the currently parsed argument as present (i.e. pparm->present = 1)
* ----------------------------------------------------------------------------------------------------------------------
*/
if (pparm->parms)
{ /*-------------------------------------------------------------------------------------------
* Check that the disallow conditions for this level are met before switching to next level
*-------------------------------------------------------------------------------------------
*/
if (FALSE == check_disallow(gpcmd_verb))
return (-1);
gpqual_root = pparm;
clear_parm_vals(pparm->parms, TRUE);
gpcmd_qual = pparm->parms;
gpcmd_verb = pparm; /* this needs to be done in order for check_disallow() to do the proper disallow check.
* an example that will not work otherwise is cli_disallow_mupip_replic_receive() */
}
return (1);
}
