bird/nest/cli.c

427 lines
10 KiB
C
Raw Normal View History

/*
* BIRD Internet Routing Daemon -- Command-Line Interface
*
2000-06-03 22:40:39 +08:00
* (c) 1999--2000 Martin Mares <mj@ucw.cz>
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
2000-06-03 22:40:39 +08:00
/**
* DOC: Command line interface
*
* This module takes care of the BIRD's command-line interface (CLI).
* The CLI exists to provide a way to control BIRD remotely and to inspect
* its status. It uses a very simple textual protocol over a stream
* connection provided by the platform dependent code (on UNIX systems,
* it's a UNIX domain socket).
*
* Each session of the CLI consists of a sequence of request and replies,
* slightly resembling the FTP and SMTP protocols.
* Requests are commands encoded as a single line of text, replies are
* sequences of lines starting with a four-digit code followed by either
* a space (if it's the last line of the reply) or a minus sign (when the
* reply is going to continue with the next line), the rest of the line
* contains a textual message semantics of which depends on the numeric
* code. If a reply line has the same code as the previous one and it's
* a continuation line, the whole prefix can be replaced by a single
* white space character.
*
2000-06-07 21:25:53 +08:00
* Reply codes starting with 0 stand for `action successfully completed' messages,
2000-06-03 22:40:39 +08:00
* 1 means `table entry', 8 `runtime error' and 9 `syntax error'.
*
* Each CLI session is internally represented by a &cli structure and a
* resource pool containing all resources associated with the connection,
2000-06-07 21:25:53 +08:00
* so that it can be easily freed whenever the connection gets closed, not depending
2000-06-03 22:40:39 +08:00
* on the current state of command processing.
*
* The CLI commands are declared as a part of the configuration grammar
2000-06-08 20:37:21 +08:00
* by using the |CF_CLI| macro. When a command is received, it is processed
2000-06-07 20:29:08 +08:00
* by the same lexical analyzer and parser as used for the configuration, but
2000-06-03 22:40:39 +08:00
* it's switched to a special mode by prepending a fake token to the text,
* so that it uses only the CLI command rules. Then the parser invokes
* an execution routine corresponding to the command, which either constructs
2000-06-08 20:37:21 +08:00
* the whole reply and returns it back or (in case it expects the reply will be long)
2000-06-03 22:40:39 +08:00
* it prints a partial reply and asks the CLI module (using the @cont hook)
2000-06-07 21:25:53 +08:00
* to call it again when the output is transferred to the user.
2000-06-03 22:40:39 +08:00
*
* The @this_cli variable points to a &cli structure of the session being
* currently parsed, but it's of course available only in command handlers
* not entered using the @cont hook.
2009-07-14 20:18:54 +08:00
*
* TX buffer management works as follows: At cli.tx_buf there is a
* list of TX buffers (struct cli_out), cli.tx_write is the buffer
* currently used by the producer (cli_printf(), cli_alloc_out()) and
* cli.tx_pos is the buffer currently used by the consumer
* (cli_write(), in system dependent code). The producer uses
* cli_out.wpos ptr as the current write position and the consumer
* uses cli_out.outpos ptr as the current read position. When the
* producer produces something, it calls cli_write_trigger(). If there
* is not enough space in the current buffer, the producer allocates
* the new one. When the consumer processes everything in the buffer
* queue, it calls cli_written(), tha frees all buffers (except the
* first one) and schedules cli.event .
*
2000-06-03 22:40:39 +08:00
*/
#include "nest/bird.h"
#include "nest/cli.h"
#include "conf/conf.h"
#include "lib/string.h"
pool *cli_pool;
static byte *
cli_alloc_out(cli *c, int size)
{
struct cli_out *o;
if (!(o = c->tx_write) || o->wpos + size > o->end)
{
if (!o && c->tx_buf)
o = c->tx_buf;
else
{
o = mb_alloc(c->pool, sizeof(struct cli_out) + CLI_TX_BUF_SIZE);
if (c->tx_write)
c->tx_write->next = o;
else
c->tx_buf = o;
o->wpos = o->outpos = o->buf;
o->end = o->buf + CLI_TX_BUF_SIZE;
}
c->tx_write = o;
if (!c->tx_pos)
c->tx_pos = o;
o->next = NULL;
}
o->wpos += size;
return o->wpos - size;
}
2000-06-03 22:40:39 +08:00
/**
* cli_printf - send reply to a CLI connection
* @c: CLI connection
* @code: numeric code of the reply, negative for continuation lines
* @msg: a printf()-like formatting string.
*
* This function send a single line of reply to a given CLI connection.
* In works in all aspects like bsprintf() except that it automatically
* prepends the reply line prefix.
*
* Please note that if the connection can be already busy sending some
* data in which case cli_printf() stores the output to a temporary buffer,
* so please avoid sending a large batch of replies without waiting
* for the buffers to be flushed.
*
* If you want to write to the current CLI output, you can use the cli_msg()
* macro instead.
*/
void
cli_printf(cli *c, int code, char *msg, ...)
{
va_list args;
byte buf[CLI_LINE_SIZE];
1999-10-31 23:43:44 +08:00
int cd = code;
int errcode;
1999-10-31 23:43:44 +08:00
int size, cnt;
1999-10-31 23:43:44 +08:00
if (cd < 0)
{
cd = -cd;
if (cd == c->last_reply)
size = bsprintf(buf, " ");
else
size = bsprintf(buf, "%04d-", cd);
errcode = -8000;
}
else if (cd == CLI_ASYNC_CODE)
{
size = 1; buf[0] = '+';
errcode = cd;
1999-10-31 23:43:44 +08:00
}
else
{
size = bsprintf(buf, "%04d ", cd);
errcode = 8000;
}
1999-10-31 23:43:44 +08:00
c->last_reply = cd;
va_start(args, msg);
1999-10-31 23:43:44 +08:00
cnt = bvsnprintf(buf+size, sizeof(buf)-size-1, msg, args);
va_end(args);
1999-10-31 23:43:44 +08:00
if (cnt < 0)
{
cli_printf(c, errcode, "<line overflow>");
1999-10-31 23:43:44 +08:00
return;
}
size += cnt;
buf[size++] = '\n';
memcpy(cli_alloc_out(c, size), buf, size);
}
static void
cli_copy_message(cli *c)
{
byte *p, *q;
2015-05-19 14:53:34 +08:00
uint cnt = 2;
if (c->ring_overflow)
{
byte buf[64];
int n = bsprintf(buf, "<%d messages lost>\n", c->ring_overflow);
c->ring_overflow = 0;
memcpy(cli_alloc_out(c, n), buf, n);
}
p = c->ring_read;
while (*p)
{
cnt++;
p++;
if (p == c->ring_end)
p = c->ring_buf;
ASSERT(p != c->ring_write);
}
c->async_msg_size += cnt;
q = cli_alloc_out(c, cnt);
*q++ = '+';
p = c->ring_read;
do
{
*q = *p++;
if (p == c->ring_end)
p = c->ring_buf;
}
while (*q++);
c->ring_read = p;
q[-1] = '\n';
}
1999-10-31 23:43:44 +08:00
static void
cli_hello(cli *c)
{
cli_printf(c, 1, "BIRD " BIRD_VERSION " ready.");
c->cont = NULL;
}
static void
cli_free_out(cli *c)
{
struct cli_out *o, *p;
if (o = c->tx_buf)
{
o->wpos = o->outpos = o->buf;
while (p = o->next)
{
o->next = p->next;
mb_free(p);
}
}
c->tx_write = c->tx_pos = NULL;
c->async_msg_size = 0;
}
2009-07-14 20:18:54 +08:00
void
cli_written(cli *c)
{
cli_free_out(c);
ev_schedule(c->event);
}
static byte *cli_rh_pos;
2015-05-19 14:53:34 +08:00
static uint cli_rh_len;
static int cli_rh_trick_flag;
struct cli *this_cli;
static int
2015-05-19 14:53:34 +08:00
cli_cmd_read_hook(byte *buf, uint max, UNUSED int fd)
{
if (!cli_rh_trick_flag)
{
cli_rh_trick_flag = 1;
buf[0] = '!';
return 1;
}
if (max > cli_rh_len)
max = cli_rh_len;
memcpy(buf, cli_rh_pos, max);
cli_rh_pos += max;
cli_rh_len -= max;
return max;
}
static void
cli_command(struct cli *c)
{
struct config f;
int res;
if (config->cli_debug > 1)
log(L_TRACE "CLI: %s", c->rx_buf);
bzero(&f, sizeof(f));
f.mem = c->parser_pool;
cf_read_hook = cli_cmd_read_hook;
cli_rh_pos = c->rx_buf;
cli_rh_len = strlen(c->rx_buf);
cli_rh_trick_flag = 0;
this_cli = c;
lp_flush(c->parser_pool);
res = cli_parse(&f);
if (!res)
cli_printf(c, 9001, f.err_msg);
}
static void
cli_event(void *data)
{
cli *c = data;
int err;
while (c->ring_read != c->ring_write &&
c->async_msg_size < CLI_MAX_ASYNC_QUEUE)
cli_copy_message(c);
1999-10-31 23:43:44 +08:00
if (c->tx_pos)
;
else if (c->cont)
c->cont(c);
else
{
1999-10-31 23:43:44 +08:00
err = cli_get_command(c);
if (!err)
return;
1999-10-31 23:43:44 +08:00
if (err < 0)
cli_printf(c, 9000, "Command too long");
else
cli_command(c);
}
2009-07-14 20:18:54 +08:00
cli_write_trigger(c);
}
cli *
cli_new(void *priv)
{
pool *p = rp_new(cli_pool, "CLI");
cli *c = mb_alloc(p, sizeof(cli));
bzero(c, sizeof(cli));
c->pool = p;
c->priv = priv;
c->event = ev_new(p);
c->event->hook = cli_event;
c->event->data = c;
1999-10-31 23:43:44 +08:00
c->cont = cli_hello;
c->parser_pool = lp_new(c->pool, 4080);
c->show_pool = lp_new(c->pool, 4080);
c->rx_buf = mb_alloc(c->pool, CLI_RX_BUF_SIZE);
1999-10-31 23:43:44 +08:00
ev_schedule(c->event);
return c;
}
void
cli_kick(cli *c)
{
1999-10-31 23:43:44 +08:00
if (!c->cont && !c->tx_pos)
ev_schedule(c->event);
}
static list cli_log_hooks;
static int cli_log_inited;
void
2015-05-19 14:53:34 +08:00
cli_set_log_echo(cli *c, uint mask, uint size)
{
if (c->ring_buf)
{
mb_free(c->ring_buf);
c->ring_buf = c->ring_end = c->ring_read = c->ring_write = NULL;
rem_node(&c->n);
}
c->log_mask = mask;
if (mask && size)
{
c->ring_buf = mb_alloc(c->pool, size);
c->ring_end = c->ring_buf + size;
c->ring_read = c->ring_write = c->ring_buf;
add_tail(&cli_log_hooks, &c->n);
c->log_threshold = size / 8;
}
c->ring_overflow = 0;
}
void
2015-05-19 14:53:34 +08:00
cli_echo(uint class, byte *msg)
{
unsigned len, free, i, l;
cli *c;
byte *m;
if (!cli_log_inited || EMPTY_LIST(cli_log_hooks))
return;
len = strlen(msg) + 1;
WALK_LIST(c, cli_log_hooks)
{
if (!(c->log_mask & (1 << class)))
continue;
if (c->ring_read <= c->ring_write)
free = (c->ring_end - c->ring_buf) - (c->ring_write - c->ring_read + 1);
else
free = c->ring_read - c->ring_write - 1;
if ((len > free) ||
(free < c->log_threshold && class < (unsigned) L_INFO[0]))
{
c->ring_overflow++;
continue;
}
if (c->ring_read == c->ring_write)
ev_schedule(c->event);
m = msg;
l = len;
while (l)
{
if (c->ring_read <= c->ring_write)
i = c->ring_end - c->ring_write;
else
i = c->ring_read - c->ring_write;
if (i > l)
i = l;
memcpy(c->ring_write, m, i);
m += i;
l -= i;
c->ring_write += i;
if (c->ring_write == c->ring_end)
c->ring_write = c->ring_buf;
}
}
}
/* Hack for scheduled undo notification */
extern cli *cmd_reconfig_stored_cli;
void
cli_free(cli *c)
{
cli_set_log_echo(c, 0, 0);
1999-11-17 20:00:21 +08:00
if (c->cleanup)
c->cleanup(c);
if (c == cmd_reconfig_stored_cli)
cmd_reconfig_stored_cli = NULL;
rfree(c->pool);
}
2000-06-03 22:40:39 +08:00
/**
* cli_init - initialize the CLI module
*
* This function is called during BIRD startup to initialize
* the internal data structures of the CLI module.
*/
void
cli_init(void)
{
cli_pool = rp_new(&root_pool, "CLI");
init_list(&cli_log_hooks);
cli_log_inited = 1;
}