800 lines
26 KiB
C
800 lines
26 KiB
C
/*
|
|
*
|
|
***** BEGIN LICENSE BLOCK *****
|
|
|
|
Copyright (C) 2009-2016 Olof Hagsand and Benny Holmgren
|
|
Copyright (C) 2017-2019 Olof Hagsand
|
|
Copyright (C) 2020-2022 Olof Hagsand and Rubicon Communications, LLC(Netgate)
|
|
|
|
This file is part of CLIXON.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
|
|
Alternatively, the contents of this file may be used under the terms of
|
|
the GNU General Public License Version 3 or later (the "GPL"),
|
|
in which case the provisions of the GPL are applicable instead
|
|
of those above. If you wish to allow use of your version of this file only
|
|
under the terms of the GPL, and not to allow others to
|
|
use your version of this file under the terms of Apache License version 2,
|
|
indicate your decision by deleting the provisions above and replace them with
|
|
the notice and other provisions required by the GPL. If you do not delete
|
|
the provisions above, a recipient may use your version of this file under
|
|
the terms of any one of the Apache License version 2 or the GPL.
|
|
|
|
***** END LICENSE BLOCK *****
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "clixon_config.h" /* generated by config & autoconf */
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <stdarg.h>
|
|
#include <syslog.h>
|
|
#include <errno.h>
|
|
#define __USE_GNU /* For RTLD_DEFAULT */
|
|
#include <dlfcn.h>
|
|
#include <libgen.h>
|
|
#include <grp.h>
|
|
#include <signal.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/param.h>
|
|
#include <netinet/in.h>
|
|
|
|
/* cligen */
|
|
#include <cligen/cligen.h>
|
|
|
|
/* clixon */
|
|
#include <clixon/clixon.h>
|
|
|
|
/* clicon_cli */
|
|
#include "clixon_cli_api.h"
|
|
#include "cli_plugin.h"
|
|
#include "cli_handle.h"
|
|
#include "cli_generate.h"
|
|
|
|
/*
|
|
* Constants
|
|
*/
|
|
#define CLI_DEFAULT_PROMPT "cli> "
|
|
|
|
/*
|
|
*
|
|
* CLI PLUGIN INTERFACE, INTERNAL SECTION
|
|
*
|
|
*/
|
|
|
|
/*! Generate CLIgen parse tree for syntax mode
|
|
*
|
|
* @param[in] h Clixon handle
|
|
* @param[in] m Syntax mode struct
|
|
* @retval 0 OK
|
|
* @retval -1 Error
|
|
*/
|
|
static int
|
|
gen_parse_tree(clixon_handle h,
|
|
char *name,
|
|
parse_tree *pt,
|
|
pt_head **php)
|
|
{
|
|
int retval = -1;
|
|
pt_head *ph;
|
|
|
|
if ((ph = cligen_ph_add(cli_cligen(h), name)) == NULL)
|
|
goto done;
|
|
if (cligen_ph_parsetree_set(ph, pt) < 0)
|
|
goto done;
|
|
if (cligen_ph_prompt_set(ph, CLI_DEFAULT_PROMPT) < 0){
|
|
clixon_err(OE_UNIX, errno, "cligen_ph_prompt_set");
|
|
goto done;
|
|
}
|
|
*php = ph;
|
|
retval = 0;
|
|
done:
|
|
return retval;
|
|
}
|
|
|
|
/*! Dynamic linking loader string to function mapper
|
|
*
|
|
* Maps strings from the CLI specification file to real funtions using dlopen
|
|
* mapping.
|
|
* First look for function name in local namespace if handle given (given plugin)
|
|
* Then check global namespace, i.e.m lib*.so
|
|
*
|
|
* @param[in] name Name of function
|
|
* @param[in] handle Handle to plugin .so module as returned by dlopen
|
|
* @param[out] error Static error string, if set indicates error
|
|
* @retval fn Function pointer
|
|
* @retval NULL Function not found or symbol NULL (check error for proper handling)
|
|
* @see see cli_plugin_load where (optional) handle opened
|
|
* @note the returned function is not type-checked which may result in segv at runtime
|
|
*/
|
|
void *
|
|
clixon_str2fn(char *name,
|
|
void *handle,
|
|
char **error)
|
|
{
|
|
void *fn = NULL;
|
|
|
|
/* Reset error */
|
|
*error = NULL;
|
|
/* Special check for auto-cli. If the virtual callback is used, it should be overwritten later
|
|
* by a callback given in the clispec, eg: set @datamodel, cli_set();
|
|
*/
|
|
if (strcmp(name, GENERATE_CALLBACK) == 0)
|
|
return NULL;
|
|
|
|
/* First check given plugin if any */
|
|
if (handle) {
|
|
dlerror(); /* Clear any existing error */
|
|
fn = dlsym(handle, name);
|
|
if ((*error = (char*)dlerror()) == NULL)
|
|
return fn; /* If no error we found the address of the callback */
|
|
}
|
|
|
|
/* Now check global namespace which includes any shared object loaded
|
|
* into the global namespace. I.e. all lib*.so as well as the
|
|
* master plugin if it exists
|
|
*/
|
|
dlerror(); /* Clear any existing error */
|
|
/* RTLD_DEFAULT instead of NULL for linux + FreeBSD:
|
|
* Use default search algorithm. Thanks jdl@netgate.com */
|
|
fn = dlsym(RTLD_DEFAULT, name);
|
|
if ((*error = (char*)dlerror()) == NULL)
|
|
return fn; /* If no error we found the address of the callback */
|
|
|
|
/* Return value not really relevant here as the error string is set to
|
|
* signal an error. However, just checking the function pointer for NULL
|
|
* should work in most cases, although it's not 100% correct.
|
|
*/
|
|
return NULL;
|
|
}
|
|
|
|
/*! Set output pipe flag in all callbacks
|
|
*
|
|
* @param[in] co CLIgen parse-tree object
|
|
* @param[in] arg Argument, cast to application-specific info
|
|
* @retval 0 OK
|
|
*/
|
|
static int
|
|
cli_mark_output_pipes(cg_obj *co,
|
|
void *arg)
|
|
{
|
|
cg_callback *cc;
|
|
|
|
for (cc = co->co_callbacks; cc; cc = co_callback_next(cc))
|
|
cc->cc_flags |= CC_FLAGS_PIPE_FUNCTION;
|
|
return 0;
|
|
}
|
|
|
|
/*! Load a file containing clispec syntax and append to specified modes, also load C plugin
|
|
*
|
|
* First load CLIgen file,
|
|
* Then find which .so to load by looking in the "CLICON_PLUGIN" variable in that file.
|
|
* Make a lookup of plugins already loaded and resolve callbacks from cligen trees to
|
|
* dl symbols in the plugin.
|
|
* @param[in] h Clixon handle
|
|
* @param[in] filename Name of file where syntax is specified (in syntax-group dir)
|
|
* @param[in] dir Name of dir, or NULL
|
|
* @param[out] ptall Universal CLIgen parse tree: apply to all modes
|
|
* @param[out] modes Keep track of all modes
|
|
* @retval 0 OK
|
|
* @retval -1 Error
|
|
* @see clixon_plugins_load Where .so plugin code has been loaded prior to this
|
|
*/
|
|
static int
|
|
clispec_load_file(clixon_handle h,
|
|
const char *filename,
|
|
const char *dir,
|
|
parse_tree *ptall,
|
|
cvec *modes)
|
|
{
|
|
int retval = -1;
|
|
void *handle = NULL; /* Handle to plugin .so module */
|
|
char *mode = NULL; /* Name of syntax mode to append new syntax */
|
|
parse_tree *pt = NULL;
|
|
FILE *f;
|
|
char filepath[MAXPATHLEN];
|
|
cvec *cvv = NULL;
|
|
char *prompt = NULL;
|
|
char **vec = NULL;
|
|
int i;
|
|
int nvec;
|
|
char *plgnam;
|
|
char *pipetree;
|
|
pt_head *ph;
|
|
#ifndef CLIXON_STATIC_PLUGINS
|
|
clixon_plugin_t *cp;
|
|
#endif
|
|
|
|
if ((pt = pt_new()) == NULL){
|
|
clixon_err(OE_UNIX, errno, "pt_new");
|
|
goto done;
|
|
}
|
|
if (dir)
|
|
snprintf(filepath, MAXPATHLEN-1, "%s/%s", dir, filename);
|
|
else
|
|
snprintf(filepath, MAXPATHLEN-1, "%s", filename);
|
|
if ((cvv = cvec_new(0)) == NULL){
|
|
clixon_err(OE_PLUGIN, errno, "cvec_new");
|
|
goto done;
|
|
}
|
|
/* Build parse tree from syntax spec. */
|
|
if ((f = fopen(filepath, "r")) == NULL){
|
|
clixon_err(OE_PLUGIN, errno, "fopen %s", filepath);
|
|
goto done;
|
|
}
|
|
|
|
/* Assuming this plugin is first in queue */
|
|
if (clispec_parse_file(h, f, filepath, NULL, pt, cvv) < 0){
|
|
clixon_err(OE_PLUGIN, 0, "failed to parse cli file %s", filepath);
|
|
fclose(f);
|
|
goto done;
|
|
}
|
|
fclose(f);
|
|
/* Get CLICON specific global variables:
|
|
* CLICON_MODE: which mode(s) this syntax applies to
|
|
* CLICON_PROMPT: Cli prompt in this mode (see cli_prompt_get)
|
|
* CLICON_PLUGIN: Name of C API plugin
|
|
* CLICON_PIPETREE: terminals are automatically expanded with this tree
|
|
* Note: the base case is that it is:
|
|
* (1) a single mode or
|
|
* (2) "*" all modes or "m1:m2" - a list of modes
|
|
* but for (2), prompt and plgnam may have unclear semantics
|
|
*/
|
|
mode = cvec_find_str(cvv, "CLICON_MODE");
|
|
prompt = cvec_find_str(cvv, "CLICON_PROMPT");
|
|
plgnam = cvec_find_str(cvv, "CLICON_PLUGIN");
|
|
pipetree = cvec_find_str(cvv, "CLICON_PIPETREE");
|
|
|
|
#ifndef CLIXON_STATIC_PLUGINS
|
|
if (plgnam != NULL) { /* Find plugin for callback resolving */
|
|
if ((cp = clixon_plugin_find(h, plgnam)) != NULL)
|
|
handle = clixon_plugin_handle_get(cp);
|
|
if (handle == NULL){
|
|
clixon_err(OE_PLUGIN, 0, "CLICON_PLUGIN set to '%s' in %s but plugin %s.so not found in %s",
|
|
plgnam, filename, plgnam,
|
|
clicon_cli_dir(h));
|
|
goto done;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* Algorithm to find output pipe trees: first mode is on the form |<treename>
|
|
*/
|
|
if (mode && strlen(mode) && IS_PIPE_TREE(mode)){
|
|
if (pt_apply(pt, cli_mark_output_pipes, -1, NULL) < 0)
|
|
goto done;
|
|
}
|
|
|
|
/* Resolve callback names to function pointers. */
|
|
if (cligen_callbackv_str2fn(pt, (cgv_str2fn_t*)clixon_str2fn, handle) < 0){
|
|
clixon_err(OE_PLUGIN, 0, "Mismatch between CLIgen file '%s' and CLI plugin file '%s'. Some possible errors:\n\t1. A function given in the CLIgen file does not exist in the plugin (ie link error)\n\t2. The CLIgen spec does not point to the correct plugin .so file (CLICON_PLUGIN=\"%s\" is wrong)",
|
|
filename, plgnam, plgnam);
|
|
goto done;
|
|
}
|
|
if (cligen_expandv_str2fn(pt, (expandv_str2fn_t*)clixon_str2fn, handle) < 0)
|
|
goto done;
|
|
/* Variable translation functions */
|
|
if (cligen_translate_str2fn(pt, (translate_str2fn_t*)clixon_str2fn, handle) < 0)
|
|
goto done;
|
|
|
|
/* Make sure we have a syntax mode specified */
|
|
if (mode == NULL || strlen(mode) < 1) { /* may be null if not given in file */
|
|
mode = clicon_cli_mode(h);
|
|
if (mode == NULL || strlen(mode) < 1) { /* may be null if not given in file */
|
|
clixon_err(OE_PLUGIN, 0, "No syntax mode specified in %s", filepath);
|
|
goto done;
|
|
}
|
|
}
|
|
/* Find all modes in CLICON_MODE string: where to append the pt syntax tree */
|
|
if ((vec = clicon_strsep(mode, ":", &nvec)) == NULL)
|
|
goto done;
|
|
|
|
if (nvec == 1 && strcmp(vec[0], "*") == 0){
|
|
/* Special case: Add this to all modes. Add to special "universal" syntax
|
|
* and add to all syntaxes after all files have been loaded. At this point
|
|
* all modes may not be known (not yet loaded)
|
|
*/
|
|
if (cligen_parsetree_merge(ptall, NULL, pt) < 0){
|
|
clixon_err(OE_PLUGIN, errno, "cligen_parsetree_merge");
|
|
goto done;
|
|
}
|
|
}
|
|
else {
|
|
for (i = 0; i < nvec; i++) {
|
|
char *name = vec[i];
|
|
parse_tree *ptnew = NULL;
|
|
cg_var *cv;
|
|
if ((ph = cligen_ph_find(cli_cligen(h), name)) == NULL){
|
|
if ((ptnew = pt_new()) == NULL){
|
|
clixon_err(OE_UNIX, errno, "pt_new");
|
|
goto done;
|
|
}
|
|
if (gen_parse_tree(h, name, ptnew, &ph) < 0)
|
|
goto done;
|
|
if (ph == NULL)
|
|
goto done;
|
|
if ((cv = cv_new(CGV_STRING)) == NULL){
|
|
clixon_err(OE_UNIX, errno, "cv_new");
|
|
goto done;
|
|
}
|
|
cv_string_set(cv, name);
|
|
if (cvec_append_var(modes, cv) < 0){
|
|
clixon_err(OE_UNIX, errno, "cvec_append_var");
|
|
goto done;
|
|
}
|
|
if (cv)
|
|
cv_free(cv);
|
|
}
|
|
if (pipetree) /* Set if any file has it (never reset) */
|
|
if (cligen_ph_pipe_set(ph, pipetree) < 0)
|
|
goto done;
|
|
if (cligen_parsetree_merge(cligen_ph_parsetree_get(ph), NULL, pt) < 0){
|
|
clixon_err(OE_PLUGIN, errno, "cligen_parsetree_merge");
|
|
goto done;
|
|
}
|
|
if (prompt){
|
|
if (cligen_ph_prompt_set(ph, prompt) < 0){
|
|
clixon_err(OE_UNIX, errno, "cligen_ph_prompt_set");
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
cligen_parsetree_free(pt, 1);
|
|
retval = 0;
|
|
done:
|
|
if (cvv)
|
|
cvec_free(cvv);
|
|
if (vec)
|
|
free(vec);
|
|
return retval;
|
|
}
|
|
|
|
/*! CLIgen spec syntax files and create CLIgen trees to drive the CLI syntax generator
|
|
*
|
|
* CLI .so plugins have been loaded: syntax table in place.
|
|
* Now load cligen syntax files and create cligen pt trees.
|
|
* @param[in] h Clixon handle
|
|
* @retval 0 OK
|
|
* @retval -1 Error
|
|
* XXX The parsetree loading needs a rewrite for multiple parse-trees
|
|
*/
|
|
int
|
|
clispec_load(clixon_handle h)
|
|
{
|
|
int retval = -1;
|
|
char *clispec_dir = NULL;
|
|
char *clispec_file = NULL;
|
|
int ndp;
|
|
int i;
|
|
struct dirent *dp = NULL;
|
|
cligen_susp_cb_t *fns = NULL;
|
|
cligen_interrupt_cb_t *fni = NULL;
|
|
clixon_plugin_t *cp;
|
|
parse_tree *ptall = NULL; /* Universal CLIgen parse tree all modes */
|
|
cvec *modes = NULL; /* Keep track of created modes */
|
|
pt_head *ph;
|
|
cg_var *cv = NULL;
|
|
|
|
if ((ptall = pt_new()) == NULL){
|
|
clixon_err(OE_UNIX, errno, "pt_new");
|
|
goto done;
|
|
}
|
|
if ((modes = cvec_new(0)) == NULL){
|
|
clixon_err(OE_UNIX, errno, "cvec_new");
|
|
goto done;
|
|
}
|
|
/* Format plugin directory path */
|
|
clispec_dir = clicon_clispec_dir(h);
|
|
clispec_file = clicon_option_str(h, "CLICON_CLISPEC_FILE");
|
|
|
|
/* Load single specific clispec file */
|
|
if (clispec_file){
|
|
if (clispec_load_file(h, clispec_file, NULL, ptall, modes) < 0)
|
|
goto done;
|
|
}
|
|
/* Load all clispec .cli files in directory */
|
|
if (clispec_dir){
|
|
/* Get directory list of files */
|
|
if ((ndp = clicon_file_dirent(clispec_dir, &dp, "(.cli)$", S_IFREG)) < 0)
|
|
goto done;
|
|
/* Load the syntax parse trees into cli_syntax stx structure */
|
|
for (i = 0; i < ndp; i++) {
|
|
clixon_debug(CLIXON_DBG_CLIENT, "Loading clispec syntax: '%s/%s'",
|
|
clispec_dir, dp[i].d_name);
|
|
if (clispec_load_file(h, dp[i].d_name, clispec_dir, ptall, modes) < 0)
|
|
goto done;
|
|
}
|
|
}
|
|
/* Were any syntax modes successfully loaded? If not, leave */
|
|
if (cvec_len(modes) == 0)
|
|
goto ok;
|
|
/* Go thorugh all modes and :
|
|
* 1) Add the universal syntax
|
|
* 2) add syntax tree (of those modes - "activate" syntax from stx to CLIgen)
|
|
*/
|
|
cv = NULL;
|
|
while ((cv = cvec_each(modes, cv)) != NULL){
|
|
if ((ph = cligen_ph_find(cli_cligen(h), cv_string_get(cv))) == NULL)
|
|
continue;
|
|
|
|
if (cligen_parsetree_merge(cligen_ph_parsetree_get(ph),
|
|
NULL,
|
|
ptall) < 0){
|
|
clixon_err(OE_PLUGIN, errno, "cligen_parsetree_merge");
|
|
goto done;
|
|
}
|
|
}
|
|
/* Set susp and interrupt callbacks into CLIgen */
|
|
cp = NULL;
|
|
while ((cp = clixon_plugin_each(h, cp)) != NULL) {
|
|
if (fns==NULL && (fns = clixon_plugin_api_get(cp)->ca_suspend) != NULL)
|
|
if (cli_susp_hook(h, fns) < 0)
|
|
goto done;
|
|
if (fni==NULL && (fni = clixon_plugin_api_get(cp)->ca_interrupt) != NULL)
|
|
if (cli_interrupt_hook(h, fni) < 0)
|
|
goto done;
|
|
}
|
|
ok:
|
|
/* All good. We can now proudly return a new group */
|
|
retval = 0;
|
|
done:
|
|
cligen_parsetree_free(ptall, 1);
|
|
if (modes)
|
|
cvec_free(modes);
|
|
if (dp)
|
|
free(dp);
|
|
return retval;
|
|
}
|
|
|
|
/*! Free resources in plugin
|
|
*
|
|
* @param[in] h Clixon handle
|
|
*/
|
|
int
|
|
cli_plugin_finish(clixon_handle h)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*! Help function to print a meaningful error string.
|
|
*
|
|
* Sometimes the libraries specify an error string, if so print that.
|
|
* Otherwise just print 'command error'.
|
|
* But do not print it if error is already logged in eg clixon_err() using STDERR logging
|
|
* See eg https://github.com/clicon/clixon/issues/325
|
|
* @param[in] f File handler to write error to.
|
|
*/
|
|
int
|
|
cli_handler_err(FILE *f)
|
|
{
|
|
if (clixon_err_category()){
|
|
/* Check if error is already logged on stderr */
|
|
if ((clixon_get_logflags() & CLIXON_LOG_STDERR) == 0){
|
|
if (clixon_err_category() != -1)
|
|
fprintf(f, "%s: ", clixon_err_str());
|
|
fprintf(f, "%s", clixon_err_reason());
|
|
if (clixon_err_subnr())
|
|
fprintf(f, ": %s", strerror(clixon_err_subnr()));
|
|
fprintf(f, "\n");
|
|
}
|
|
else
|
|
fprintf(f, "CLI command error\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*! Given a command string, parse and if match single command, eval it.
|
|
*
|
|
* Parse and evaluate the string according to
|
|
* the syntax parse tree of the syntax mode specified by *mode.
|
|
* If there is no match in the tree for the command, the parse hook
|
|
* will be called to see if another mode should be evaluated. If a
|
|
* match is found in another mode, the mode variable is updated to point at
|
|
* the new mode string.
|
|
*
|
|
* @param[in] h Clixon handle
|
|
* @param[in] cmd Command string
|
|
* @param[in,out] modenamep Pointer to the mode string pointer
|
|
* @param[out] result CLIgen match result, < 0: errors, >=0 number of matches
|
|
* @param[out] evalres Evaluation result if result=1
|
|
* @retval 0 OK
|
|
* @retval -1 Error
|
|
*/
|
|
int
|
|
clicon_parse(clixon_handle h,
|
|
char *cmd,
|
|
char **modenamep,
|
|
cligen_result *result,
|
|
int *evalres)
|
|
{
|
|
int retval = -1;
|
|
char *modename;
|
|
int ret;
|
|
parse_tree *pt; /* Orig */
|
|
cg_obj *match_obj = NULL;
|
|
cvec *cvv = NULL;
|
|
FILE *f;
|
|
char *reason = NULL;
|
|
cligen_handle ch;
|
|
pt_head *ph;
|
|
|
|
ch = cli_cligen(h);
|
|
if (clixon_get_logflags()&CLIXON_LOG_STDOUT)
|
|
f = stdout;
|
|
else
|
|
f = stderr;
|
|
modename = *modenamep;
|
|
ph = cligen_ph_find(cli_cligen(h), modename);
|
|
if (ph != NULL){
|
|
if (cligen_ph_active_set_byname(ch, modename) < 0){
|
|
fprintf(f, "No such parse-tree registered: %s\n", modename);
|
|
goto done;
|
|
}
|
|
if ((pt = cligen_pt_active_get(ch)) == NULL){
|
|
fprintf(f, "No such parse-tree registered: %s\n", modename);
|
|
goto done;
|
|
}
|
|
if (cliread_parse(ch, cmd, pt, &match_obj, &cvv, result, &reason) < 0)
|
|
goto done;
|
|
/* Debug command and result code */
|
|
clixon_debug(CLIXON_DBG_CLIENT, "result:%d command: \"%s\"", *result, cmd);
|
|
switch (*result) {
|
|
case CG_EOF: /* eof */
|
|
case CG_ERROR:
|
|
fprintf(f, "CLI parse error: %s\n", cmd); // In practice never happens
|
|
break;
|
|
case CG_NOMATCH: /* no match */
|
|
fprintf(f, "CLI syntax error: \"%s\": %s\n", cmd, reason);
|
|
break;
|
|
case CG_MATCH:
|
|
if (strcmp(modename, *modenamep)){ /* Command in different mode */
|
|
*modenamep = modename;
|
|
cli_set_syntax_mode(h, modename);
|
|
}
|
|
cli_output_reset();
|
|
if (!cligen_exiting(ch)) {
|
|
clixon_err_reset();
|
|
if ((ret = cligen_eval(ch, match_obj, cvv)) < 0) {
|
|
cli_handler_err(stdout);
|
|
if (clixon_err_subnr() == ESHUTDOWN)
|
|
goto done;
|
|
}
|
|
}
|
|
else
|
|
ret = 0;
|
|
if (evalres)
|
|
*evalres = ret;
|
|
break;
|
|
default:
|
|
fprintf(f, "CLI syntax error: \"%s\" is ambiguous\n", cmd);
|
|
break;
|
|
} /* switch result */
|
|
if (cvv){
|
|
cvec_free(cvv);
|
|
cvv = NULL;
|
|
}
|
|
}
|
|
retval = 0;
|
|
done:
|
|
fflush(f);
|
|
if (reason)
|
|
free(reason);
|
|
if (cvv)
|
|
cvec_free(cvv);
|
|
if (match_obj)
|
|
co_free(match_obj, 0);
|
|
return retval;
|
|
}
|
|
|
|
/*! Return a malloced expanded prompt string from printf-like format
|
|
*
|
|
* @param[in] h Clixon handle
|
|
* @param[in] fmt Format string, using %H, %
|
|
* @retval prompt Malloced string, free after use
|
|
* @retval NULL Error
|
|
*/
|
|
static char *
|
|
cli_prompt_get(clixon_handle h,
|
|
char *fmt)
|
|
{
|
|
char *s = fmt;
|
|
char hname[1024];
|
|
char tty[32];
|
|
char *tmp;
|
|
cbuf *cb = NULL;
|
|
char *path = NULL;
|
|
char *promptstr = NULL;
|
|
char *str0;
|
|
|
|
if ((cb = cbuf_new()) == NULL){
|
|
clixon_err(OE_XML, errno, "cbuf_new");
|
|
goto done;
|
|
}
|
|
/* Start with empty string */
|
|
while(*s) {
|
|
if (*s == '%' && *++s) {
|
|
switch(*s) {
|
|
case 'H': /* Hostname */
|
|
if (gethostname(hname, sizeof(hname)) != 0)
|
|
strncpy(hname, "unknown", sizeof(hname)-1);
|
|
cprintf(cb, "%s", hname);
|
|
break;
|
|
case 'U': /* Username */
|
|
tmp = getenv("USER");
|
|
cprintf(cb, "%s", tmp?tmp:"nobody");
|
|
break;
|
|
case 'T': /* TTY */
|
|
if(ttyname_r(fileno(stdin), tty, sizeof(tty)-1) < 0)
|
|
strcpy(tty, "notty");
|
|
cprintf(cb, "%s", tty);
|
|
break;
|
|
case 'W': /* Last element of working path */
|
|
if (clicon_data_get(h, "cli-edit-mode", &path) == 0 &&
|
|
strlen(path)){
|
|
int i;
|
|
|
|
for (i=strlen(path)-1; i>=0; i--)
|
|
if (path[i] == '/' || path[i] == ':')
|
|
/* see yang2api_path_fmt_1() why occasional trailing / */
|
|
if (i < strlen(path)-1)
|
|
break;
|
|
if (i >= 0)
|
|
cprintf(cb, "%s", &path[i+1]);
|
|
else
|
|
cprintf(cb, "%s", path);
|
|
}
|
|
else
|
|
cprintf(cb, "/");
|
|
break;
|
|
case 'w': /* Full Working edit path */
|
|
if (clicon_data_get(h, "cli-edit-mode", &path) == 0 &&
|
|
strlen(path))
|
|
cprintf(cb, "%s", path);
|
|
else
|
|
cprintf(cb, "/");
|
|
break;
|
|
default:
|
|
cprintf(cb, "%%");
|
|
cprintf(cb, "%c", *s);
|
|
}
|
|
}
|
|
else if (*s == '\\' && *++s) {
|
|
switch(*s) {
|
|
case 'n':
|
|
cprintf(cb, "\n");
|
|
break;
|
|
default:
|
|
cprintf(cb, "\\");
|
|
cprintf(cb, "%c", *s);
|
|
}
|
|
}
|
|
else
|
|
cprintf(cb, "%c", *s);
|
|
s++;
|
|
}
|
|
str0 = cbuf_len(cb) ? cbuf_get(cb) : CLI_DEFAULT_PROMPT;
|
|
if ((promptstr = strdup(str0)) == NULL){
|
|
clixon_err(OE_UNIX, errno, "strdup");
|
|
goto done;
|
|
}
|
|
done:
|
|
if (cb)
|
|
cbuf_free(cb);
|
|
return promptstr;
|
|
}
|
|
|
|
/*! Read command from CLIgen's cliread() using current syntax mode.
|
|
*
|
|
* @param[in] h Clixon handle
|
|
* @param[in] ph Parse-tree head
|
|
* @param[out] stringp Pointer to command buffer or NULL on EOF
|
|
* @retval 1 OK
|
|
* @retval 0 Fail but continue
|
|
* @retval -1 Error
|
|
*/
|
|
int
|
|
clicon_cliread(clixon_handle h,
|
|
pt_head *ph,
|
|
char **stringp)
|
|
{
|
|
int retval = -1;
|
|
char *name;
|
|
char *pfmt = NULL;
|
|
cli_prompthook_t *fn;
|
|
clixon_plugin_t *cp;
|
|
char *promptstr;
|
|
|
|
name = cligen_ph_name_get(ph);
|
|
/* Get prompt from plugin callback? */
|
|
cp = NULL;
|
|
while ((cp = clixon_plugin_each(h, cp)) != NULL) {
|
|
if ((fn = clixon_plugin_api_get(cp)->ca_prompt) == NULL)
|
|
continue;
|
|
pfmt = fn(h, name);
|
|
break;
|
|
}
|
|
if (clicon_quiet_mode(h))
|
|
cli_prompt_set(h, "");
|
|
else{
|
|
if ((promptstr = cli_prompt_get(h,
|
|
pfmt?pfmt:cligen_ph_prompt_get(ph)
|
|
)) == NULL)
|
|
goto done;
|
|
cli_prompt_set(h, promptstr);
|
|
free(promptstr);
|
|
}
|
|
clixon_err_reset();
|
|
if (cliread(cli_cligen(h), stringp) < 0){
|
|
cli_handler_err(stdout);
|
|
if (clixon_err_subnr() == ESHUTDOWN)
|
|
goto done;
|
|
goto fail;
|
|
}
|
|
|
|
retval = 1;
|
|
done:
|
|
if (pfmt)
|
|
free(pfmt);
|
|
return retval;
|
|
fail:
|
|
retval = 0;
|
|
goto done;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* CLI PLUGIN INTERFACE, PUBLIC SECTION
|
|
*
|
|
*/
|
|
|
|
/*! Set syntax mode mode for existing current plugin group.
|
|
*
|
|
* @param[in] h Clixon handle
|
|
* @retval 1 OK
|
|
* @retval 0 Not found / error
|
|
*/
|
|
int
|
|
cli_set_syntax_mode(clixon_handle h,
|
|
char *name)
|
|
{
|
|
|
|
pt_head *ph;
|
|
|
|
if ((ph = cligen_ph_find(cli_cligen(h), name)) == NULL)
|
|
return 0;
|
|
cligen_pt_head_active_set(cli_cligen(h), ph);
|
|
return 1;
|
|
}
|
|
|
|
/*! Get syntax mode name
|
|
*
|
|
* @param[in] h Clixon handle
|
|
*/
|
|
char *
|
|
cli_syntax_mode(clixon_handle h)
|
|
{
|
|
pt_head *ph;
|
|
|
|
if ((ph = cligen_pt_head_active_get(cli_cligen(h))) == NULL)
|
|
return NULL;
|
|
return cligen_ph_name_get(ph);
|
|
}
|
|
|