cli.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2019-2022 Intel Corporation.
 */
 
#ifndef _CLI_H_
#define _CLI_H_
 
#include <libgen.h>
#include <sys/queue.h>         // for TAILQ_HEAD, CIRCLEQ_HEAD, TAILQ_ENTRY
#include <cne_common.h>        // for CNDP_API, __cne_cache_aligned
#include <cne_log.h>           // for CNE_ASSERT
#include <cli_common.h>
#include <cli_env.h>        // for cli_sfunc_t
#include <cli_search.h>
#include <cli_file.h>
#include <cli_gapbuf.h>
#include <cli_help.h>
#include <cli_history.h>
#include <cli_map.h>
#include <cne_strings.h>
#include <stdint.h>        // for uint32_t, uint16_t, uint8_t
#include <string.h>        // for strcat, NULL, strcpy, strdup, size_t
 
#include "cne_stdio.h"        // for cne_printf
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define CLI_ROOT_NAME "/"
#define CLI_BIN_NAME  "bin"
 
enum {
    CLI_MAX_ARGVS          = 64,   
    CLI_DEFAULT_NB_NODES   = 256,  
    CLI_DEFAULT_HIST_LINES = 128,  
    CLI_MAX_PATH_LENGTH    = 2048, 
    CLI_MAX_SCRATCH_LENGTH = 4096, 
    CLI_NAME_LEN           = 64,   
    CLI_MAX_LIST_NODES     = 128,  
    CLI_MAX_BINS           = 32,   
    CLI_DEFAULT_NODES      = 0,    
    CLI_SCREEN_WIDTH       = 80    
};
 
#define CLI_RECURSE_FLAG   (1 << 0)
#define CLI_LONG_LIST_FLAG (1 << 1)
 
typedef enum {
    CLI_UNK_NODE   = 0x0000, 
    CLI_DIR_NODE   = 0x0001, 
    CLI_CMD_NODE   = 0x0002, 
    CLI_FILE_NODE  = 0x0004, 
    CLI_ALIAS_NODE = 0x0008, 
    CLI_STR_NODE   = 0x0010, 
} node_type_t;
 
/* Keep this list in sync with the node_type_t enum above */
#define CLI_NODE_TYPES                                                     \
    {                                                                      \
        "Unknown", "Directory", "Command", "File", "Alias", "String", NULL \
    }
 
enum {
    CLI_EXE_TYPE   = (CLI_CMD_NODE | CLI_ALIAS_NODE),
    CLI_ALL_TYPE   = (CLI_EXE_TYPE | CLI_FILE_NODE | CLI_DIR_NODE),
    CLI_OTHER_TYPE = (CLI_DIR_NODE | CLI_FILE_NODE)
};
 
struct cli;
struct cli_node;
 
typedef int (*cli_cfunc_t)(int argc, char **argv);
typedef int (*cli_ffunc_t)(struct cli_node *node, char *buff, int len, uint32_t opt);
typedef int (*cli_prompt_t)(int continuation); 
typedef int (*cli_tree_t)(void);
/* Generic node structure for all node types in the directory tree */
struct cli_node {
    TAILQ_ENTRY(cli_node) next; 
    struct cli_node *parent;    
    char name[CLI_NAME_LEN];    
    uint16_t name_sz;           
    uint16_t fstate;            
    uint16_t fflags;            
    uint16_t pad0;
    node_type_t type; 
    union {
        cli_cfunc_t cfunc; 
        cli_ffunc_t ffunc; 
        cli_sfunc_t sfunc; 
    };
    const char *short_desc;       
    const char *alias_str;        
    size_t foffset;               
    size_t file_size;             
    char *file_data;              
    TAILQ_HEAD(, cli_node) items; 
} __cne_cache_aligned;            
#define MAX_CMD_FILES 16
 
typedef struct {
    char *filename[MAX_CMD_FILES];
    uint32_t idx;
} cli_files_t;
 
struct cli_cfg {
    int nb_nodes; 
    int nb_hist;  
};
 
struct cli {
    TAILQ_HEAD(, cli_node) root;      
    CIRCLEQ_HEAD(, cli_hist) hd_hist; 
    uint32_t flags;    
    uint32_t nb_nodes; 
    uint8_t plen;    
    uint8_t tab_cnt; 
    uint32_t nb_hist;                    
    struct cli_hist *curr_hist;          
    struct cli_node *bins[CLI_MAX_BINS]; 
    struct cli_node *exe_node;           
    struct cli_env *env;  
    struct gapbuf *gb;    
    struct cli_vt100 *vt; 
    char **argv;          
    cli_prompt_t prompt; 
    char *scratch;       
    char *kill;          
    struct cli_node *node_mem; 
    struct cli_hist *hist_mem; 
    TAILQ_HEAD(, help_node) help_nodes; 
    TAILQ_HEAD(, cli_node) free_nodes;  
    CIRCLEQ_HEAD(, cli_hist) free_hist; 
    void *user_state;                   
} __cne_cache_aligned;
 
extern struct cli *this_cli;
extern cli_files_t cli_cmd_files; 
/* cli.flags */
#define CLEAR_TO_EOL    (1 << 0)
#define DISPLAY_PROMPT  (1 << 1)
#define PROMPT_CONTINUE (1 << 2)
#define DELETE_CHAR     (1 << 3)
#define CLEAR_LINE      (1 << 4)
 
#define CLI_USE_TIMERS      (1 << 8) 
#define CLI_NODES_UNLIMITED (1 << 9) 
#define CLI_YIELD_IO        (1 << 10)
#define CLI_DEFAULT_TREE    (1 << 11)
 
static inline void
cli_set_flag(uint32_t x)
{
    this_cli->flags |= x;
}
 
static inline void
cli_clr_flag(uint32_t x)
{
    this_cli->flags &= ~x;
}
 
static inline int
cli_tst_flag(uint32_t x)
{
    return this_cli->flags & x;
}
 
typedef union {
    cli_cfunc_t cfunc; 
    cli_ffunc_t ffunc; 
    cli_sfunc_t sfunc; 
} cli_funcs_t;         /* Internal: Used in argument list for adding nodes */
 
struct cli_dir {
    const char *name; 
    uint8_t bin;
};
 
struct cli_cmd {
    const char *name;       
    cli_cfunc_t cfunc;      
    const char *short_desc; 
};                          
struct cli_alias {
    const char *name;       
    const char *alias_atr;  
    const char *short_desc; 
};                          
struct cli_file {
    const char *name;       
    cli_ffunc_t ffunc;      
    const char *short_desc; 
};                          
struct cli_str {
    const char *name;   
    cli_sfunc_t sfunc;  
    const char *string; 
};                      
struct cli_tree {
    node_type_t type; 
    union {
        struct cli_dir dir;     
        struct cli_cmd cmd;     
        struct cli_file file;   
        struct cli_alias alias; 
        struct cli_str str;     
    };
};
 
// clang-format off
#define c_dir(n)            { CLI_DIR_NODE,   .dir   = {.name = (n), .bin = 0} }
#define c_bin(n)            { CLI_DIR_NODE,   .dir   = {.name = (n), .bin = 1} }
#define c_cmd(n, f, h)      { CLI_CMD_NODE,   .cmd   = {.name = (n), .cfunc = (f), .short_desc = (h)} }
#define c_file(n, rw, h)    { CLI_FILE_NODE,  .file  = {.name = (n), .ffunc = (rw), .short_desc = (h)} }
#define c_alias(n, l, h)    { CLI_ALIAS_NODE, .alias = {.name = (n), .alias_atr = (l), .short_desc = (h)} }
#define c_str(n, f, s)      { CLI_STR_NODE,   .str   = {.name = (n), .sfunc = (f), .string = (s)} }
#define c_end()             { CLI_UNK_NODE,   .dir   = { NULL } }
// clang-format on
 
static inline void
cli_set_user_state(void *val)
{
    this_cli->user_state = val;
}
 
static inline struct cli_node *
get_root(void)
{
    CNE_ASSERT(this_cli != NULL);
    return this_cli->root.tqh_first;
}
 
static inline struct cli_node *
get_cwd(void)
{
    CNE_ASSERT(this_cli != NULL);
    return this_cli->bins[0];
}
 
static inline void
set_cwd(struct cli_node *node)
{
    CNE_ASSERT(this_cli != NULL);
    this_cli->bins[0] = node;
}
 
static inline int
is_cli_valid(void)
{
    return (this_cli) ? 1 : 0;
}
 
static inline int
is_match(const char *s1, const char *s2)
{
    if (!s1 || !s2)
        return 0;
 
    while ((*s1 != '\0') && (*s2 != '\0')) {
        if (*s1++ != *s2++)
            return 0;
    }
    if (*s1 != *s2)
        return 0;
 
    return 1;
}
 
static inline int
is_node(struct cli_node *node, uint32_t types)
{
    return node->type & types;
}
 
static inline int
is_command(struct cli_node *node)
{
    return is_node(node, CLI_CMD_NODE);
}
 
static inline int
is_alias(struct cli_node *node)
{
    return is_node(node, CLI_ALIAS_NODE);
}
 
static inline int
is_file(struct cli_node *node)
{
    return is_node(node, CLI_FILE_NODE);
}
 
static inline int
is_directory(struct cli_node *node)
{
    return is_node(node, CLI_DIR_NODE);
}
 
static inline int
is_executable(struct cli_node *node)
{
    return is_command(node) || is_alias(node);
}
 
static inline int
cli_usage(void)
{
    if (this_cli && this_cli->exe_node) {
        const char *p = this_cli->exe_node->short_desc;
 
        cne_printf("  Usage: %s\n", (p) ? p : "No description found");
    }
    return -1;
}
 
static inline const char *
cli_node_type(struct cli_node *node)
{
    const char *node_str[] = CLI_NODE_TYPES;
    switch (node->type) {
    case CLI_UNK_NODE:
    default:
        break;
    case CLI_DIR_NODE:
        return node_str[1];
    case CLI_CMD_NODE:
        return node_str[2];
    case CLI_FILE_NODE:
        return node_str[3];
    case CLI_ALIAS_NODE:
        return node_str[4];
    }
    return node_str[0];
}
 
static inline char *
cli_path_string(struct cli_node *node, char *path)
{
    if (!path)
        path = this_cli->scratch;
 
    if (!node)
        node = get_cwd();
 
    if (node->parent) {
        cli_path_string(node->parent, path);
        strcat(path, node->name);
        strcat(path, "/");
    } else
        strcpy(path, "/");
 
    return path;
}
 
static inline char *
cli_cwd_path(void)
{
    return cli_path_string(get_cwd(), NULL);
}
 
static inline void
cli_pwd(struct cli_node *node)
{
    cne_printf("%s", cli_path_string(node, NULL));
}
 
static inline int
cli_set_history_size(uint32_t nb_hist)
{
    return cli_set_history(nb_hist);
}
 
static inline uint32_t
cli_get_history_size(void)
{
    return this_cli->nb_hist;
}
 
static inline void
cli_history_list(void)
{
    cli_history_dump();
}
 
static inline struct cli_node *
cli_root_node(void)
{
    return this_cli->root.tqh_first;
}
 
CNDP_API int cli_create(struct cli_cfg *cfg);
 
CNDP_API int cli_create_with_defaults(struct cli_cfg *cfg);
 
CNDP_API int cli_setup(cli_prompt_t prompt, cli_tree_t default_func);
 
CNDP_API int cli_setup_with_defaults(void);
 
CNDP_API int cli_setup_with_tree(cli_tree_t tree);
 
CNDP_API cli_prompt_t cli_set_prompt(cli_prompt_t prompt);
 
CNDP_API struct cli_node *cli_create_root(const char *dirname);
 
CNDP_API int cli_default_tree_init(void);
 
CNDP_API void cli_destroy(void);
 
CNDP_API void cli_start(const char *msg);
 
CNDP_API void cli_start_with_timers(const char *msg);
 
CNDP_API int cli_execute(void);
 
CNDP_API int cli_add_bin(struct cli_node *node);
 
CNDP_API int cli_del_bin(struct cli_node *node);
 
CNDP_API int cli_add_bin_path(const char *path);
 
CNDP_API struct cli_node *cli_add_dir(const char *dirname, struct cli_node *parent);
 
CNDP_API struct cli_node *cli_add_cmd(const char *name, struct cli_node *dir, cli_cfunc_t func,
                                      const char *short_desc);
 
CNDP_API struct cli_node *cli_add_alias(const char *name, struct cli_node *dir, const char *line,
                                        const char *short_desc);
 
CNDP_API struct cli_node *cli_add_file(const char *name, struct cli_node *dir, cli_ffunc_t func,
                                       const char *short_desc);
 
CNDP_API int cli_add_str(const char *name, cli_sfunc_t func, const char *str);
 
CNDP_API int cli_add_tree(struct cli_node *dir, struct cli_tree *tree);
 
static inline int
cli_add_cmdfile(const char *filename)
{
    if (cli_cmd_files.idx >= MAX_CMD_FILES)
        return -1;
 
    cli_cmd_files.filename[cli_cmd_files.idx++] = strdup(filename);
 
    return 0;
}
 
CNDP_API int cli_execute_cmdfile(const char *path);
 
CNDP_API int cli_execute_cmdfiles(void);
 
CNDP_API int cli_remove_node(struct cli_node *node);
 
CNDP_API void cli_use_timers(void);
 
CNDP_API int cli_nodes_unlimited(void);
 
CNDP_API int cli_execute_cmd(int argc, char **argv);
 
CNDP_API int cli_get_quit_flag(void);
 
CNDP_API void cli_set_quit_flag(void);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _CLI_H_ */