nest/cli.c

   1 /*
   2  *      BIRD Internet Routing Daemon -- Command-Line Interface
   3  *
   4  *      (c) 1999--2000 Martin Mares <mj@ucw.cz>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 /**
  10  * DOC: Command line interface
  11  *
  12  * This module takes care of the BIRD's command-line interface (CLI).
  13  * The CLI exists to provide a way to control BIRD remotely and to inspect
  14  * its status. It uses a very simple textual protocol over a stream
  15  * connection provided by the platform dependent code (on UNIX systems,
  16  * it's a UNIX domain socket).
  17  *
  18  * Each session of the CLI consists of a sequence of request and replies,
  19  * slightly resembling the FTP and SMTP protocols.
  20  * Requests are commands encoded as a single line of text, replies are
  21  * sequences of lines starting with a four-digit code followed by either
  22  * a space (if it's the last line of the reply) or a minus sign (when the
  23  * reply is going to continue with the next line), the rest of the line
  24  * contains a textual message semantics of which depends on the numeric
  25  * code. If a reply line has the same code as the previous one and it's
  26  * a continuation line, the whole prefix can be replaced by a single
  27  * white space character.
  28  *
  29  * Reply codes starting with 0 stand for `action successfully completed' messages,
  30  * 1 means `table entry', 8 `runtime error' and 9 `syntax error'.
  31  *
  32  * Each CLI session is internally represented by a &cli structure and a
  33  * resource pool containing all resources associated with the connection,
  34  * so that it can be easily freed whenever the connection gets closed, not depending
  35  * on the current state of command processing.
  36  *
  37  * The CLI commands are declared as a part of the configuration grammar
  38  * by using the |CF_CLI| macro. When a command is received, it is processed
  39  * by the same lexical analyzer and parser as used for the configuration, but
  40  * it's switched to a special mode by prepending a fake token to the text,
  41  * so that it uses only the CLI command rules. Then the parser invokes
  42  * an execution routine corresponding to the command, which either constructs
  43  * the whole reply and returns it back or (in case it expects the reply will be long)
  44  * it prints a partial reply and asks the CLI module (using the @cont hook)
  45  * to call it again when the output is transferred to the user.
  46  *
  47  * The @this_cli variable points to a &cli structure of the session being
  48  * currently parsed, but it's of course available only in command handlers
  49  * not entered using the @cont hook.
  50  *
  51  * TX buffer management works as follows: At cli.tx_buf there is a
  52  * list of TX buffers (struct cli_out), cli.tx_write is the buffer
  53  * currently used by the producer (cli_printf(), cli_alloc_out()) and
  54  * cli.tx_pos is the buffer currently used by the consumer
  55  * (cli_write(), in system dependent code). The producer uses
  56  * cli_out.wpos ptr as the current write position and the consumer
  57  * uses cli_out.outpos ptr as the current read position. When the
  58  * producer produces something, it calls cli_write_trigger(). If there
  59  * is not enough space in the current buffer, the producer allocates
  60  * the new one. When the consumer processes everything in the buffer
  61  * queue, it calls cli_written(), tha frees all buffers (except the
  62  * first one) and schedules cli.event .
  63  *
  64  */
  65
  66 #include "nest/bird.h"
  67 #include "nest/cli.h"
  68 #include "conf/conf.h"
  69 #include "lib/string.h"
  70
  71 pool *cli_pool;
  72
  73 static byte *
  74 cli_alloc_out(cli *c, int size)
  75 {
  76   struct cli_out *o;
  77
  78   if (!(o = c->tx_write) || o->wpos + size > o->end)
  79     {
  80       if (!o && c->tx_buf)
  81         o = c->tx_buf;
  82       else
  83         {
  84           o = mb_alloc(c->pool, sizeof(struct cli_out) + CLI_TX_BUF_SIZE);
  85           if (c->tx_write)
  86             c->tx_write->next = o;
  87           else
  88             c->tx_buf = o;
  89           o->wpos = o->outpos = o->buf;
  90           o->end = o->buf + CLI_TX_BUF_SIZE;
  91         }
  92       c->tx_write = o;
  93       if (!c->tx_pos)
  94         c->tx_pos = o;
  95       o->next = NULL;
  96     }
  97   o->wpos += size;
  98   return o->wpos - size;
  99 }
 100
 101 /**
 102  * cli_printf - send reply to a CLI connection
 103  * @c: CLI connection
 104  * @code: numeric code of the reply, negative for continuation lines
 105  * @msg: a printf()-like formatting string.
 106  *
 107  * This function send a single line of reply to a given CLI connection.
 108  * In works in all aspects like bsprintf() except that it automatically
 109  * prepends the reply line prefix.
 110  *
 111  * Please note that if the connection can be already busy sending some
 112  * data in which case cli_printf() stores the output to a temporary buffer,
 113  * so please avoid sending a large batch of replies without waiting
 114  * for the buffers to be flushed.
 115  *
 116  * If you want to write to the current CLI output, you can use the cli_msg()
 117  * macro instead.
 118  */
 119 void
 120 cli_printf(cli *c, int code, char *msg, ...)
 121 {
 122   va_list args;
 123   byte buf[CLI_LINE_SIZE];
 124   int cd = code;
 125   int errcode;
 126   int size, cnt;
 127
 128   if (cd < 0)
 129     {
 130       cd = -cd;
 131       if (cd == c->last_reply)
 132         size = bsprintf(buf, " ");
 133       else
 134         size = bsprintf(buf, "%04d-", cd);
 135       errcode = -8000;
 136     }
 137   else if (cd == CLI_ASYNC_CODE)
 138     {
 139       size = 1; buf[0] = '+';
 140       errcode = cd;
 141     }
 142   else
 143     {
 144       size = bsprintf(buf, "%04d ", cd);
 145       errcode = 8000;
 146     }
 147
 148   c->last_reply = cd;
 149   va_start(args, msg);
 150   cnt = bvsnprintf(buf+size, sizeof(buf)-size-1, msg, args);
 151   va_end(args);
 152   if (cnt < 0)
 153     {
 154       cli_printf(c, errcode, "<line overflow>");
 155       return;
 156     }
 157   size += cnt;
 158   buf[size++] = '\n';
 159   memcpy(cli_alloc_out(c, size), buf, size);
 160 }
 161
 162 static void
 163 cli_copy_message(cli *c)
 164 {
 165   byte *p, *q;
 166   uint cnt = 2;
 167
 168   if (c->ring_overflow)
 169     {
 170       byte buf[64];
 171       int n = bsprintf(buf, "<%d messages lost>\n", c->ring_overflow);
 172       c->ring_overflow = 0;
 173       memcpy(cli_alloc_out(c, n), buf, n);
 174     }
 175   p = c->ring_read;
 176   while (*p)
 177     {
 178       cnt++;
 179       p++;
 180       if (p == c->ring_end)
 181         p = c->ring_buf;
 182       ASSERT(p != c->ring_write);
 183     }
 184   c->async_msg_size += cnt;
 185   q = cli_alloc_out(c, cnt);
 186   *q++ = '+';
 187   p = c->ring_read;
 188   do
 189     {
 190       *q = *p++;
 191       if (p == c->ring_end)
 192         p = c->ring_buf;
 193     }
 194   while (*q++);
 195   c->ring_read = p;
 196   q[-1] = '\n';
 197 }
 198
 199 static void
 200 cli_hello(cli *c)
 201 {
 202   cli_printf(c, 1, "BIRD " BIRD_VERSION " ready.");
 203   c->cont = NULL;
 204 }
 205
 206 static void
 207 cli_free_out(cli *c)
 208 {
 209   struct cli_out *o, *p;
 210
 211   if (o = c->tx_buf)
 212     {
 213       o->wpos = o->outpos = o->buf;
 214       while (p = o->next)
 215         {
 216           o->next = p->next;
 217           mb_free(p);
 218         }
 219     }
 220   c->tx_write = c->tx_pos = NULL;
 221   c->async_msg_size = 0;
 222 }
 223
 224 void
 225 cli_written(cli *c)
 226 {
 227   cli_free_out(c);
 228   ev_schedule(c->event);
 229 }
 230
 231
 232 static byte *cli_rh_pos;
 233 static uint cli_rh_len;
 234 static int cli_rh_trick_flag;
 235 struct cli *this_cli;
 236
 237 static int
 238 cli_cmd_read_hook(byte *buf, uint max, UNUSED int fd)
 239 {
 240   if (!cli_rh_trick_flag)
 241     {
 242       cli_rh_trick_flag = 1;
 243       buf[0] = '!';
 244       return 1;
 245     }
 246   if (max > cli_rh_len)
 247     max = cli_rh_len;
 248   memcpy(buf, cli_rh_pos, max);
 249   cli_rh_pos += max;
 250   cli_rh_len -= max;
 251   return max;
 252 }
 253
 254 static void
 255 cli_command(struct cli *c)
 256 {
 257   struct config f;
 258   int res;
 259
 260   if (config->cli_debug > 1)
 261     log(L_TRACE "CLI: %s", c->rx_buf);
 262   bzero(&f, sizeof(f));
 263   f.mem = c->parser_pool;
 264   f.pool = rp_new(c->pool, "Config");
 265   cf_read_hook = cli_cmd_read_hook;
 266   cli_rh_pos = c->rx_buf;
 267   cli_rh_len = strlen(c->rx_buf);
 268   cli_rh_trick_flag = 0;
 269   this_cli = c;
 270   lp_flush(c->parser_pool);
 271   res = cli_parse(&f);
 272   if (!res)
 273     cli_printf(c, 9001, f.err_msg);
 274
 275   config_free(&f);
 276 }
 277
 278 static void
 279 cli_event(void *data)
 280 {
 281   cli *c = data;
 282   int err;
 283
 284   while (c->ring_read != c->ring_write &&
 285       c->async_msg_size < CLI_MAX_ASYNC_QUEUE)
 286     cli_copy_message(c);
 287
 288   if (c->tx_pos)
 289     ;
 290   else if (c->cont)
 291     c->cont(c);
 292   else
 293     {
 294       err = cli_get_command(c);
 295       if (!err)
 296         return;
 297       if (err < 0)
 298         cli_printf(c, 9000, "Command too long");
 299       else
 300         cli_command(c);
 301     }
 302
 303   cli_write_trigger(c);
 304 }
 305
 306 cli *
 307 cli_new(void *priv)
 308 {
 309   pool *p = rp_new(cli_pool, "CLI");
 310   cli *c = mb_alloc(p, sizeof(cli));
 311
 312   bzero(c, sizeof(cli));
 313   c->pool = p;
 314   c->priv = priv;
 315   c->event = ev_new(p);
 316   c->event->hook = cli_event;
 317   c->event->data = c;
 318   c->cont = cli_hello;
 319   c->parser_pool = lp_new_default(c->pool);
 320   c->show_pool = lp_new_default(c->pool);
 321   c->rx_buf = mb_alloc(c->pool, CLI_RX_BUF_SIZE);
 322   ev_schedule(c->event);
 323   return c;
 324 }
 325
 326 void
 327 cli_kick(cli *c)
 328 {
 329   if (!c->cont && !c->tx_pos)
 330     ev_schedule(c->event);
 331 }
 332
 333 static list cli_log_hooks;
 334 static int cli_log_inited;
 335
 336 void
 337 cli_set_log_echo(cli *c, uint mask, uint size)
 338 {
 339   if (c->ring_buf)
 340     {
 341       mb_free(c->ring_buf);
 342       c->ring_buf = c->ring_end = c->ring_read = c->ring_write = NULL;
 343       rem_node(&c->n);
 344     }
 345   c->log_mask = mask;
 346   if (mask && size)
 347     {
 348       c->ring_buf = mb_alloc(c->pool, size);
 349       c->ring_end = c->ring_buf + size;
 350       c->ring_read = c->ring_write = c->ring_buf;
 351       add_tail(&cli_log_hooks, &c->n);
 352       c->log_threshold = size / 8;
 353     }
 354   c->ring_overflow = 0;
 355 }
 356
 357 void
 358 cli_echo(uint class, byte *msg)
 359 {
 360   unsigned len, free, i, l;
 361   cli *c;
 362   byte *m;
 363
 364   if (!cli_log_inited || EMPTY_LIST(cli_log_hooks))
 365     return;
 366   len = strlen(msg) + 1;
 367   WALK_LIST(c, cli_log_hooks)
 368     {
 369       if (!(c->log_mask & (1 << class)))
 370         continue;
 371       if (c->ring_read <= c->ring_write)
 372         free = (c->ring_end - c->ring_buf) - (c->ring_write - c->ring_read + 1);
 373       else
 374         free = c->ring_read - c->ring_write - 1;
 375       if ((len > free) ||
 376           (free < c->log_threshold && class < (unsigned) L_INFO[0]))
 377         {
 378           c->ring_overflow++;
 379           continue;
 380         }
 381       if (c->ring_read == c->ring_write)
 382         ev_schedule(c->event);
 383       m = msg;
 384       l = len;
 385       while (l)
 386         {
 387           if (c->ring_read <= c->ring_write)
 388             i = c->ring_end - c->ring_write;
 389           else
 390             i = c->ring_read - c->ring_write;
 391           if (i > l)
 392             i = l;
 393           memcpy(c->ring_write, m, i);
 394           m += i;
 395           l -= i;
 396           c->ring_write += i;
 397           if (c->ring_write == c->ring_end)
 398             c->ring_write = c->ring_buf;
 399         }
 400     }
 401 }
 402
 403 /* Hack for scheduled undo notification */
 404 extern cli *cmd_reconfig_stored_cli;
 405
 406 void
 407 cli_free(cli *c)
 408 {
 409   cli_set_log_echo(c, 0, 0);
 410   if (c->cleanup)
 411     c->cleanup(c);
 412   if (c == cmd_reconfig_stored_cli)
 413     cmd_reconfig_stored_cli = NULL;
 414   rfree(c->pool);
 415 }
 416
 417 /**
 418  * cli_init - initialize the CLI module
 419  *
 420  * This function is called during BIRD startup to initialize
 421  * the internal data structures of the CLI module.
 422  */
 423 void
 424 cli_init(void)
 425 {
 426   cli_pool = rp_new(&root_pool, "CLI");
 427   init_list(&cli_log_hooks);
 428   cli_log_inited = 1;
 429 }