Project

General

Profile

Download (3.8 KB) Statistics
| Branch: | Revision:
/*
*
*
*
*/

#include <sys/time.h>
#include <string.h>
#include <stdlib.h>

#include "libcli/libcli.h"
#include "module.h"

/* head of the list of all modules */
static struct module_def *module_list;

/* register a new module - used by all other modules */
int register_module(struct module_def *module) {
/* FIXME - not thread safe */
module->next = module_list;
module_list = module;
return 0;
}

/*
* Because I want a flexible, modular architecture,
* I want to be able to register child commands from
* wildly different locations, thus I need some way
* to use the same parents.
*
* The 'best' way would be auto-vivification, but libcli
* is not constructed to allow that. A better way would
* be for libcli to have a command lookup function.
* It is also possible to just register the parent every
* time it is needed, but that clutters up the libcli
* namespace with duplicates
*
* for the moment, I am just going to create a list and
* some accessor functions.
*
*/
/* TODO - implement cli_command_lookup */
struct parent_def {
struct parent_def *next;
char *name;
struct cli_command *cmd;
};
static struct parent_def *parent_list;

struct cli_command *lookup_parent(char *name) {
struct parent_def *p = parent_list;
while(p) {
if (!strcmp(name,p->name)) {
return p->cmd;
}
p=p->next;
}
return NULL;
}

int register_parent(char *name, struct cli_command *cmd) {
if (lookup_parent(name)) {
return -1;
}

struct parent_def *p = malloc(sizeof(struct parent_def));
if (!p) {
return -1;
}
p->name=name;
p->cmd=cmd;

/* FIXME - not thread safe */
p->next = parent_list;
parent_list = p;
return 0;
}


/* command used for showing all modules config */
static int cmd_showrun(struct cli_def *cli, char *command, char *argv[], int argc) {
cli_print(cli,"!");
cli_print(cli,"! show run");
cli_print(cli,"!");

struct module_def *p = module_list;
while (p) {
cli_print(cli,"! module: %s",p->name);
if(p->showrun) {
p->showrun(cli);
}
cli_print(cli,"!");
p=p->next;
}
return CLI_OK;
}

/* command used for showing the loaded modules list */
static int cmd_showmodules(struct cli_def *cli, char *command, char *argv[], int argc) {
cli_print(cli, "Module list:");
struct module_def *p = module_list;
while (p) {
cli_print(cli,"\t%s\t%s",p->name,p->desc);
p=p->next;
}
return CLI_OK;
}

/* dump the parents table for debugging */
static int cmd_debugparents(struct cli_def *cli, char *command, char *argv[], int argc) {
cli_print(cli, "registered parents list:");
struct parent_def *p = parent_list;
while (p) {
cli_print(cli,"\t%s\t%p",p->name,p->cmd);
p=p->next;
}
return CLI_OK;
}


/* show the config for this module */
static int this_showrun(struct cli_def *cli) {
cli_print(cli, "!");
return CLI_OK;
}

/* Our local module definition */
static struct module_def this_module = {
.name = "modules",
.desc = "Module handling library",
.showrun = this_showrun,
};

/* initialise and register this module */
int modules_init(struct cli_def *cli) {

/* create the well known parent prefixes */
register_parent("show",
cli_register_command(cli, NULL, "show", NULL, PRIVILEGE_UNPRIVILEGED,
MODE_EXEC, "Show information about system"));
register_parent("debug",
cli_register_command(cli, NULL, "debug", NULL, PRIVILEGE_PRIVILEGED,
MODE_EXEC, "Commands used for debugging"));

/* register the commands from this module */
cli_register_command(cli, lookup_parent("show"), "running-config", cmd_showrun,
PRIVILEGE_PRIVILEGED, MODE_EXEC, "Current configuration");

cli_register_command(cli, lookup_parent("show"), "modules", cmd_showmodules,
PRIVILEGE_UNPRIVILEGED, MODE_EXEC, "Registered modules");

cli_register_command(cli, lookup_parent("debug"), "parents", cmd_debugparents,
PRIVILEGE_PRIVILEGED, MODE_EXEC, "Internal parent cmd list");

register_module(&this_module);
return 0;
}

(7-7/13)