Annotation of embedaddon/bird/nest/cli.c, revision 1.1
1.1 ! misho 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: cf_read_hook = cli_cmd_read_hook;
! 265: cli_rh_pos = c->rx_buf;
! 266: cli_rh_len = strlen(c->rx_buf);
! 267: cli_rh_trick_flag = 0;
! 268: this_cli = c;
! 269: lp_flush(c->parser_pool);
! 270: res = cli_parse(&f);
! 271: if (!res)
! 272: cli_printf(c, 9001, f.err_msg);
! 273: }
! 274:
! 275: static void
! 276: cli_event(void *data)
! 277: {
! 278: cli *c = data;
! 279: int err;
! 280:
! 281: while (c->ring_read != c->ring_write &&
! 282: c->async_msg_size < CLI_MAX_ASYNC_QUEUE)
! 283: cli_copy_message(c);
! 284:
! 285: if (c->tx_pos)
! 286: ;
! 287: else if (c->cont)
! 288: c->cont(c);
! 289: else
! 290: {
! 291: err = cli_get_command(c);
! 292: if (!err)
! 293: return;
! 294: if (err < 0)
! 295: cli_printf(c, 9000, "Command too long");
! 296: else
! 297: cli_command(c);
! 298: }
! 299:
! 300: cli_write_trigger(c);
! 301: }
! 302:
! 303: cli *
! 304: cli_new(void *priv)
! 305: {
! 306: pool *p = rp_new(cli_pool, "CLI");
! 307: cli *c = mb_alloc(p, sizeof(cli));
! 308:
! 309: bzero(c, sizeof(cli));
! 310: c->pool = p;
! 311: c->priv = priv;
! 312: c->event = ev_new(p);
! 313: c->event->hook = cli_event;
! 314: c->event->data = c;
! 315: c->cont = cli_hello;
! 316: c->parser_pool = lp_new(c->pool, 4096);
! 317: c->rx_buf = mb_alloc(c->pool, CLI_RX_BUF_SIZE);
! 318: ev_schedule(c->event);
! 319: return c;
! 320: }
! 321:
! 322: void
! 323: cli_kick(cli *c)
! 324: {
! 325: if (!c->cont && !c->tx_pos)
! 326: ev_schedule(c->event);
! 327: }
! 328:
! 329: static list cli_log_hooks;
! 330: static int cli_log_inited;
! 331:
! 332: void
! 333: cli_set_log_echo(cli *c, uint mask, uint size)
! 334: {
! 335: if (c->ring_buf)
! 336: {
! 337: mb_free(c->ring_buf);
! 338: c->ring_buf = c->ring_end = c->ring_read = c->ring_write = NULL;
! 339: rem_node(&c->n);
! 340: }
! 341: c->log_mask = mask;
! 342: if (mask && size)
! 343: {
! 344: c->ring_buf = mb_alloc(c->pool, size);
! 345: c->ring_end = c->ring_buf + size;
! 346: c->ring_read = c->ring_write = c->ring_buf;
! 347: add_tail(&cli_log_hooks, &c->n);
! 348: c->log_threshold = size / 8;
! 349: }
! 350: c->ring_overflow = 0;
! 351: }
! 352:
! 353: void
! 354: cli_echo(uint class, byte *msg)
! 355: {
! 356: unsigned len, free, i, l;
! 357: cli *c;
! 358: byte *m;
! 359:
! 360: if (!cli_log_inited || EMPTY_LIST(cli_log_hooks))
! 361: return;
! 362: len = strlen(msg) + 1;
! 363: WALK_LIST(c, cli_log_hooks)
! 364: {
! 365: if (!(c->log_mask & (1 << class)))
! 366: continue;
! 367: if (c->ring_read <= c->ring_write)
! 368: free = (c->ring_end - c->ring_buf) - (c->ring_write - c->ring_read + 1);
! 369: else
! 370: free = c->ring_read - c->ring_write - 1;
! 371: if ((len > free) ||
! 372: (free < c->log_threshold && class < (unsigned) L_INFO[0]))
! 373: {
! 374: c->ring_overflow++;
! 375: continue;
! 376: }
! 377: if (c->ring_read == c->ring_write)
! 378: ev_schedule(c->event);
! 379: m = msg;
! 380: l = len;
! 381: while (l)
! 382: {
! 383: if (c->ring_read <= c->ring_write)
! 384: i = c->ring_end - c->ring_write;
! 385: else
! 386: i = c->ring_read - c->ring_write;
! 387: if (i > l)
! 388: i = l;
! 389: memcpy(c->ring_write, m, i);
! 390: m += i;
! 391: l -= i;
! 392: c->ring_write += i;
! 393: if (c->ring_write == c->ring_end)
! 394: c->ring_write = c->ring_buf;
! 395: }
! 396: }
! 397: }
! 398:
! 399: /* Hack for scheduled undo notification */
! 400: extern cli *cmd_reconfig_stored_cli;
! 401:
! 402: void
! 403: cli_free(cli *c)
! 404: {
! 405: cli_set_log_echo(c, 0, 0);
! 406: if (c->cleanup)
! 407: c->cleanup(c);
! 408: if (c == cmd_reconfig_stored_cli)
! 409: cmd_reconfig_stored_cli = NULL;
! 410: rfree(c->pool);
! 411: }
! 412:
! 413: /**
! 414: * cli_init - initialize the CLI module
! 415: *
! 416: * This function is called during BIRD startup to initialize
! 417: * the internal data structures of the CLI module.
! 418: */
! 419: void
! 420: cli_init(void)
! 421: {
! 422: cli_pool = rp_new(&root_pool, "CLI");
! 423: init_list(&cli_log_hooks);
! 424: cli_log_inited = 1;
! 425: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cli.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / nest