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