This diff add JSON output support for bgpctl.
Most commands should produce now a resonable JSON object.
The individual objects can probably be improved and extended.
I'm at a point where I'm happy with the result and looking for feedback.
It is possible to commit the non-JSON bits first and add output-json.c
once the output is enough stable.
--
:wq Claudio
Index: Makefile
===================================================================
RCS file: /cvs/src/usr.sbin/bgpctl/Makefile,v
retrieving revision 1.16
diff -u -p -r1.16 Makefile
--- Makefile 20 Dec 2019 09:16:05 -0000 1.16
+++ Makefile 30 Apr 2020 12:24:42 -0000
@@ -3,7 +3,7 @@
.PATH: ${.CURDIR}/../bgpd
PROG= bgpctl
-SRCS= bgpctl.c output.c parser.c mrtparser.c util.c
+SRCS= bgpctl.c output.c output_json.c parser.c mrtparser.c util.c json.c
CFLAGS+= -Wall
CFLAGS+= -Wstrict-prototypes -Wmissing-prototypes
CFLAGS+= -Wmissing-declarations
Index: bgpctl.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpctl/bgpctl.c,v
retrieving revision 1.259
diff -u -p -r1.259 bgpctl.c
--- bgpctl.c 20 Mar 2020 07:56:34 -0000 1.259
+++ bgpctl.c 30 Apr 2020 15:45:05 -0000
@@ -60,6 +60,7 @@ int match_aspath(void *, u_int16_t, st
struct imsgbuf *ibuf;
struct mrt_parser show_mrt = { show_mrt_dump, show_mrt_state, show_mrt_msg };
struct mrt_parser net_mrt = { network_mrt_dump, NULL, NULL };
+const struct output *output = &show_output;
int tableid;
int nodescr;
@@ -68,7 +69,7 @@ usage(void)
{
extern char *__progname;
- fprintf(stderr, "usage: %s [-n] [-s socket] command [argument ...]\n",
+ fprintf(stderr, "usage: %s [-jn] [-s socket] command [argument ...]\n",
__progname);
exit(1);
}
@@ -93,12 +94,15 @@ main(int argc, char *argv[])
if (asprintf(&sockname, "%s.%d", SOCKET_NAME, tableid) == -1)
err(1, "asprintf");
- while ((ch = getopt(argc, argv, "ns:")) != -1) {
+ while ((ch = getopt(argc, argv, "jns:")) != -1) {
switch (ch) {
case 'n':
if (++nodescr > 1)
usage();
break;
+ case 'j':
+ output = &json_output;
+ break;
case 's':
sockname = optarg;
break;
@@ -139,7 +143,7 @@ main(int argc, char *argv[])
if (res->flags & F_CTL_NEIGHBORS)
show_mrt.dump = show_mrt_dump_neighbors;
else
- show_head(res);
+ output->head(res);
mrt_parse(res->mrtfd, &show_mrt, 1);
exit(0);
default:
@@ -351,7 +355,7 @@ main(int argc, char *argv[])
if (msgbuf_write(&ibuf->w) <= 0 && errno != EAGAIN)
err(1, "write error");
- show_head(res);
+ output->head(res);
while (!done) {
if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
@@ -369,6 +373,9 @@ main(int argc, char *argv[])
imsg_free(&imsg);
}
}
+
+ output->tail();
+
close(fd);
free(ibuf);
@@ -394,33 +401,33 @@ show(struct imsg *imsg, struct parse_res
switch (imsg->hdr.type) {
case IMSG_CTL_SHOW_NEIGHBOR:
p = imsg->data;
- show_neighbor(p, res);
+ output->neighbor(p, res);
break;
case IMSG_CTL_SHOW_TIMER:
t = imsg->data;
if (t->type > 0 && t->type < Timer_Max)
- show_timer(t);
+ output->timer(t);
break;
case IMSG_CTL_SHOW_INTERFACE:
iface = imsg->data;
- show_interface(iface);
+ output->interface(iface);
break;
case IMSG_CTL_SHOW_NEXTHOP:
nh = imsg->data;
- show_nexthop(nh);
+ output->nexthop(nh);
break;
case IMSG_CTL_KROUTE:
case IMSG_CTL_SHOW_NETWORK:
if (imsg->hdr.len < IMSG_HEADER_SIZE + sizeof(*kf))
errx(1, "wrong imsg len");
kf = imsg->data;
- show_fib(kf);
+ output->fib(kf);
break;
case IMSG_CTL_SHOW_FIB_TABLES:
if (imsg->hdr.len < IMSG_HEADER_SIZE + sizeof(*kt))
errx(1, "wrong imsg len");
kt = imsg->data;
- show_fib_table(kt);
+ output->fib_table(kt);
break;
case IMSG_CTL_SHOW_RIB:
if (imsg->hdr.len < IMSG_HEADER_SIZE + sizeof(rib))
@@ -429,7 +436,7 @@ show(struct imsg *imsg, struct parse_res
aslen = imsg->hdr.len - IMSG_HEADER_SIZE - sizeof(rib);
asdata = imsg->data;
asdata += sizeof(rib);
- show_rib(&rib, asdata, aslen, res);
+ output->rib(&rib, asdata, aslen, res);
break;
case IMSG_CTL_SHOW_RIB_COMMUNITIES:
ilen = imsg->hdr.len - IMSG_HEADER_SIZE;
@@ -437,7 +444,7 @@ show(struct imsg *imsg, struct parse_res
warnx("bad IMSG_CTL_SHOW_RIB_COMMUNITIES received");
break;
}
- show_communities(imsg->data, ilen, res);
+ output->communities(imsg->data, ilen, res);
break;
case IMSG_CTL_SHOW_RIB_ATTR:
ilen = imsg->hdr.len - IMSG_HEADER_SIZE;
@@ -445,15 +452,15 @@ show(struct imsg *imsg, struct parse_res
warnx("bad IMSG_CTL_SHOW_RIB_ATTR received");
break;
}
- show_attr(imsg->data, ilen, res);
+ output->attr(imsg->data, ilen, res);
break;
case IMSG_CTL_SHOW_RIB_MEM:
memcpy(&stats, imsg->data, sizeof(stats));
- show_rib_mem(&stats);
+ output->rib_mem(&stats);
break;
case IMSG_CTL_SHOW_RIB_HASH:
memcpy(&hash, imsg->data, sizeof(hash));
- show_rib_hash(&hash);
+ output->rib_hash(&hash);
break;
case IMSG_CTL_RESULT:
if (imsg->hdr.len != IMSG_HEADER_SIZE + sizeof(rescode)) {
@@ -461,7 +468,7 @@ show(struct imsg *imsg, struct parse_res
break;
}
memcpy(&rescode, imsg->data, sizeof(rescode));
- show_result(rescode);
+ output->result(rescode);
return (1);
case IMSG_CTL_END:
return (1);
@@ -762,7 +769,7 @@ fmt_errstr(u_int8_t errcode, u_int8_t su
}
const char *
-fmt_attr(u_int8_t type, u_int8_t flags)
+fmt_attr(u_int8_t type, int flags)
{
#define CHECK_FLAGS(s, t, m) \
if (((s) & ~(ATTR_DEFMASK | (m))) != (t)) pflags = 1
@@ -841,7 +848,7 @@ fmt_attr(u_int8_t type, u_int8_t flags)
pflags = 1;
break;
}
- if (pflags) {
+ if (flags != -1 && pflags) {
strlcat(cstr, " flags [", sizeof(cstr));
if (flags & ATTR_OPTIONAL)
strlcat(cstr, "O", sizeof(cstr));
@@ -1123,10 +1130,10 @@ show_mrt_dump(struct mrt_rib *mr, struct
!match_aspath(mre->aspath, mre->aspath_len, &req->as))
continue;
- show_rib(&ctl, mre->aspath, mre->aspath_len, &res);
+ output->rib(&ctl, mre->aspath, mre->aspath_len, &res);
if (req->flags & F_CTL_DETAIL) {
for (j = 0; j < mre->nattrs; j++)
- show_attr(mre->attrs[j].attr,
+ output->attr(mre->attrs[j].attr,
mre->attrs[j].attr_len, &res);
}
}
@@ -1509,6 +1516,7 @@ show_mrt_notification(u_char *p, u_int16
}
}
+/* XXX this function does not handle JSON output */
static void
show_mrt_update(u_char *p, u_int16_t len)
{
@@ -1579,7 +1587,7 @@ show_mrt_update(u_char *p, u_int16_t len
attrlen += 1 + 2;
}
- show_attr(p, attrlen, 0);
+ output->attr(p, attrlen, 0);
p += attrlen;
alen -= attrlen;
len -= attrlen;
Index: bgpctl.h
===================================================================
RCS file: /cvs/src/usr.sbin/bgpctl/bgpctl.h,v
retrieving revision 1.4
diff -u -p -r1.4 bgpctl.h
--- bgpctl.h 20 Mar 2020 07:56:34 -0000 1.4
+++ bgpctl.h 30 Apr 2020 16:06:20 -0000
@@ -15,21 +15,27 @@
*/
struct parse_result;
-void show_head(struct parse_result *);
-void show_neighbor(struct peer *, struct parse_result *);
-void show_timer(struct ctl_timer *);
-void show_fib(struct kroute_full *);
-void show_fib_table(struct ktable *);
-void show_nexthop(struct ctl_show_nexthop *);
-void show_interface(struct ctl_show_interface *);
-void show_attr(u_char *, size_t, struct parse_result *);
-void show_communities(u_char *, size_t, struct parse_result *);
-void show_rib(struct ctl_show_rib *, u_char *, size_t,
- struct parse_result *);
-void show_rib_hash(struct rde_hashstats *);
-void show_rib_mem(struct rde_memstats *);
-void show_result(u_int);
+struct output {
+ void (*head)(struct parse_result *);
+ void (*neighbor)(struct peer *, struct parse_result *);
+ void (*timer)(struct ctl_timer *);
+ void (*fib)(struct kroute_full *);
+ void (*fib_table)(struct ktable *);
+ void (*nexthop)(struct ctl_show_nexthop *);
+ void (*interface)(struct ctl_show_interface *);
+ void (*attr)(u_char *, size_t, struct parse_result *);
+ void (*communities)(u_char *, size_t, struct parse_result *);
+ void (*rib)(struct ctl_show_rib *, u_char *, size_t,
+ struct parse_result *);
+ void (*rib_hash)(struct rde_hashstats *);
+ void (*rib_mem)(struct rde_memstats *);
+ void (*result)(u_int);
+ void (*tail)(void);
+};
+
+extern const struct output show_output, json_output;
+extern const size_t pt_sizes[];
#define EOL0(flag) ((flag & F_CTL_SSV) ? ';' : '\n')
@@ -43,8 +49,7 @@ const char *fmt_ovs(u_int8_t, int);
const char *fmt_auth_method(enum auth_method);
const char *fmt_mem(long long);
const char *fmt_errstr(u_int8_t, u_int8_t);
-const char *fmt_attr(u_int8_t, u_int8_t);
+const char *fmt_attr(u_int8_t, int);
const char *fmt_community(u_int16_t, u_int16_t);
const char *fmt_large_community(u_int32_t, u_int32_t, u_int32_t);
const char *fmt_ext_community(u_int8_t *);
-
Index: json.c
===================================================================
RCS file: json.c
diff -N json.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ json.c 30 Apr 2020 16:43:41 -0000
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2020 Claudio Jeker <[email protected]>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <err.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "json.h"
+
+#define JSON_MAX_STACK 16
+
+enum json_type {
+ NONE,
+ START,
+ ARRAY,
+ OBJECT
+};
+
+struct json_stack {
+ const char *name;
+ unsigned int count;
+ enum json_type type;
+} stack[JSON_MAX_STACK];
+
+char indent[JSON_MAX_STACK + 1];
+int level;
+
+static void
+do_coma_indent(void)
+{
+ if (stack[level].count++ > 0)
+ printf(",\n");
+ printf("\t%.*s", level, indent);
+}
+
+static void
+do_name(const char *name)
+{
+ if (stack[level].type == ARRAY)
+ return;
+ printf("\"%s\": ", name);
+}
+
+static int
+do_find(enum json_type type, const char *name)
+{
+ int i;
+
+ for (i = level; i > 0; i--)
+ if (type == stack[i].type &&
+ strcmp(name, stack[i].name) == 0)
+ return i;
+
+ /* not found */
+ return -1;
+}
+
+void
+json_do_start(void)
+{
+ memset(indent, '\t', JSON_MAX_STACK);
+ memset(stack, 0, sizeof(stack));
+ level = 0;
+ stack[level].type = START;
+
+ printf("{\n");
+}
+
+void
+json_do_finish(void)
+{
+ while (level > 0)
+ json_do_end();
+ printf("\n}\n");
+}
+
+void
+json_do_array(const char *name)
+{
+ int i, l;
+
+ if ((l = do_find(ARRAY, name)) > 0) {
+ /* array already in use, close element and move on */
+ for (i = level - l; i > 0; i--)
+ json_do_end();
+ return;
+ }
+ /* Do not stack arrays, while allowed this is not needed */
+ if (stack[level].type == ARRAY)
+ json_do_end();
+
+ do_coma_indent();
+ do_name(name);
+ printf("[\n");
+
+ if (++level >= JSON_MAX_STACK)
+ errx(1, "json stack too deep");
+
+ stack[level].name = name;
+ stack[level].type = ARRAY;
+ stack[level].count = 0;
+}
+
+void
+json_do_object(const char *name)
+{
+ int i, l;
+
+ if ((l = do_find(OBJECT, name)) > 0) {
+ /* roll back to that object and close it */
+ for (i = level - l; i >= 0; i--)
+ json_do_end();
+ }
+
+ do_coma_indent();
+ do_name(name);
+ printf("{\n");
+
+ if (++level >= JSON_MAX_STACK)
+ errx(1, "json stack too deep");
+
+ stack[level].name = name;
+ stack[level].type = OBJECT;
+ stack[level].count = 0;
+}
+
+void
+json_do_end(void)
+{
+ if (stack[level].type == ARRAY)
+ printf("\n%.*s]", level, indent);
+ else if (stack[level].type == OBJECT)
+ printf("\n%.*s}", level, indent);
+ else
+ errx(1, "json bad stack state");
+
+ stack[level].name = NULL;
+ stack[level].type = NONE;
+ stack[level].count = 0;
+
+ if (level-- <= 0)
+ errx(1, "json stack underflow");
+
+ stack[level].count++;
+}
+
+void
+json_do_printf(const char *name, const char *fmt, ...)
+{
+ va_list ap;
+
+ do_coma_indent();
+
+ do_name(name);
+ printf("\"");
+ va_start(ap, fmt);
+ vprintf(fmt, ap);
+ va_end(ap);
+ printf("\"");
+}
+
+void
+json_do_hexdump(const char *name, void *buf, size_t len)
+{
+ uint8_t *data = buf;
+ size_t i;
+
+ do_coma_indent();
+ do_name(name);
+ printf("\"");
+ for (i=0; i < len; i++)
+ printf("%02x", *(data+i));
+ printf("\"");
+}
+
+void
+json_do_bool(const char *name, int v)
+{
+ do_coma_indent();
+ do_name(name);
+ if (v)
+ printf("true");
+ else
+ printf("false");
+}
+
+void
+json_do_uint(const char *name, uint64_t v)
+{
+ do_coma_indent();
+ do_name(name);
+ printf("%llu", v);
+}
+
+void
+json_do_int(const char *name, int64_t v)
+{
+ do_coma_indent();
+ do_name(name);
+ printf("%lld", name, v);
+}
+
+void
+json_do_double(const char *name, double v)
+{
+ do_coma_indent();
+ do_name(name);
+ printf("%f", v);
+}
Index: json.h
===================================================================
RCS file: json.h
diff -N json.h
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ json.h 30 Apr 2020 16:03:33 -0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Claudio Jeker <[email protected]>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdarg.h>
+#include <sys/cdefs.h>
+
+void json_do_start(void);
+void json_do_finish(void);
+void json_do_array(const char *);
+void json_do_object(const char *);
+void json_do_end(void);
+void json_do_printf(const char *, const char *, ...)
+ __attribute__((__format__ (printf, 2, 3)));
+void json_do_hexdump(const char *, void *, size_t);
+void json_do_bool(const char *, int);
+void json_do_uint(const char *, uint64_t);
+void json_do_int(const char *, int64_t);
+void json_do_double(const char *, double);
Index: output.c
===================================================================
RCS file: /cvs/src/usr.sbin/bgpctl/output.c,v
retrieving revision 1.6
diff -u -p -r1.6 output.c
--- output.c 20 Mar 2020 07:56:34 -0000 1.6
+++ output.c 1 May 2020 11:04:45 -0000
@@ -32,7 +32,9 @@
#include "bgpctl.h"
#include "parser.h"
-void
+const size_t pt_sizes[AID_MAX] = AID_PTSIZE;
+
+static void
show_head(struct parse_result *res)
{
switch (res->action) {
@@ -200,6 +202,7 @@ show_neighbor_msgstats(struct peer *p)
static void
show_neighbor_full(struct peer *p, struct parse_result *res)
{
+ const char *errstr;
struct in_addr ina;
char *s;
int hascapamp = 0;
@@ -216,7 +219,6 @@ show_neighbor_full(struct peer *p, struc
} else if ((s = strdup(log_addr(&p->conf.remote_addr))) == NULL)
err(1, "strdup");
- ina.s_addr = p->remote_bgpid;
printf("BGP neighbor is %s, ", s);
free(s);
if (p->conf.remote_as == 0 && p->conf.template)
@@ -249,16 +251,19 @@ show_neighbor_full(struct peer *p, struc
if (p->conf.max_prefix || p->conf.max_out_prefix)
printf("\n");
- printf(" BGP version 4, remote router-id %s",
- inet_ntoa(ina));
- printf("%s\n", fmt_auth_method(p->auth.method));
+ if (p->state == STATE_ESTABLISHED) {
+ ina.s_addr = p->remote_bgpid;
+ printf(" BGP version 4, remote router-id %s",
+ inet_ntoa(ina));
+ printf("%s\n", fmt_auth_method(p->auth.method));
+ }
printf(" BGP state = %s", statenames[p->state]);
if (p->conf.down) {
printf(", marked down");
- if (*(p->conf.shutcomm)) {
- printf(" with shutdown reason \"%s\"",
- log_shutcomm(p->conf.shutcomm));
- }
+ }
+ if (*(p->conf.shutcomm)) {
+ printf(" with shutdown reason \"%s\"",
+ log_shutcomm(p->conf.shutcomm));
}
if (p->stats.last_updown != 0)
printf(", %s for %s",
@@ -295,18 +300,17 @@ show_neighbor_full(struct peer *p, struc
printf(" Last received shutdown reason: \"%s\"\n",
log_shutcomm(p->stats.last_shutcomm));
}
- if (p->state == STATE_IDLE) {
- const char *errstr;
- errstr = fmt_errstr(p->stats.last_sent_errcode,
- p->stats.last_sent_suberr);
- if (errstr)
- printf(" Last error sent: %s\n\n", errstr);
- errstr = fmt_errstr(p->stats.last_rcvd_errcode,
- p->stats.last_rcvd_suberr);
- if (errstr)
- printf(" Last error received: %s\n\n", errstr);
- } else {
+ errstr = fmt_errstr(p->stats.last_sent_errcode,
+ p->stats.last_sent_suberr);
+ if (errstr)
+ printf(" Last error sent: %s\n", errstr);
+ errstr = fmt_errstr(p->stats.last_rcvd_errcode,
+ p->stats.last_rcvd_suberr);
+ if (errstr)
+ printf(" Last error received: %s\n", errstr);
+
+ if (p->state >= STATE_OPENSENT) {
printf(" Local host: %20s, Local port: %5u\n",
log_addr(&p->local), p->local_port);
@@ -316,7 +320,7 @@ show_neighbor_full(struct peer *p, struc
}
}
-void
+static void
show_neighbor(struct peer *p, struct parse_result *res)
{
char *s;
@@ -360,7 +364,7 @@ show_neighbor(struct peer *p, struct par
}
}
-void
+static void
show_timer(struct ctl_timer *t)
{
printf(" %-20s ", timernames[t->type]);
@@ -371,7 +375,7 @@ show_timer(struct ctl_timer *t)
printf("due in %-13s\n", fmt_timeframe(t->val));
}
-void
+static void
show_fib(struct kroute_full *kf)
{
char *p;
@@ -388,7 +392,7 @@ show_fib(struct kroute_full *kf)
printf("\n");
}
-void
+static void
show_fib_table(struct ktable *kt)
{
printf("%5i %-20s %-8s%s\n", kt->rtableid, kt->descr,
@@ -396,7 +400,7 @@ show_fib_table(struct ktable *kt)
kt->fib_sync != kt->fib_conf ? "*" : "");
}
-void
+static void
show_nexthop(struct ctl_show_nexthop *nh)
{
struct kroute *k;
@@ -445,7 +449,7 @@ show_nexthop(struct ctl_show_nexthop *nh
printf("\n");
}
-void
+static void
show_interface(struct ctl_show_interface *iface)
{
printf("%-15s", iface->ifname);
@@ -462,13 +466,13 @@ show_interface(struct ctl_show_interface
printf("\n");
}
-void
+static void
show_communities(u_char *data, size_t len, struct parse_result *res)
{
struct community c;
size_t i;
u_int64_t ext;
- u_int8_t type = 0, nt;
+ u_int8_t type = 0;
if (len % sizeof(c))
return;
@@ -476,16 +480,15 @@ show_communities(u_char *data, size_t le
for (i = 0; i < len; i += sizeof(c)) {
memcpy(&c, data + i, sizeof(c));
- nt = c.flags;
- if (type != nt) {
+ if (type != c.flags) {
if (type != 0)
printf("%c", EOL0(res->flags));
- printf(" %s:", fmt_attr(nt,
+ printf(" %s:", fmt_attr(c.flags,
ATTR_OPTIONAL | ATTR_TRANSITIVE));
- type = nt;
+ type = c.flags;
}
- switch (nt) {
+ switch (c.flags) {
case COMMUNITY_TYPE_BASIC:
printf(" %s", fmt_community(c.data1, c.data2));
break;
@@ -525,8 +528,10 @@ show_community(u_char *data, u_int16_t l
u_int16_t a, v;
u_int16_t i;
- if (len & 0x3)
+ if (len & 0x3) {
+ printf("bad length");
return;
+ }
for (i = 0; i < len; i += 4) {
memcpy(&a, data + i, sizeof(a));
@@ -546,8 +551,10 @@ show_large_community(u_char *data, u_int
u_int32_t a, l1, l2;
u_int16_t i;
- if (len % 12)
+ if (len % 12) {
+ printf("bad length");
return;
+ }
for (i = 0; i < len; i += 12) {
memcpy(&a, data + i, sizeof(a));
@@ -556,7 +563,7 @@ show_large_community(u_char *data, u_int
a = ntohl(a);
l1 = ntohl(l1);
l2 = ntohl(l2);
- printf("%s", fmt_large_community(a, l1, l2));
+ printf("%s", fmt_large_community(a, l1, l2));
if (i + 12 < len)
printf(" ");
@@ -568,8 +575,10 @@ show_ext_community(u_char *data, u_int16
{
u_int16_t i;
- if (len & 0x7)
+ if (len & 0x7) {
+ printf("bad length");
return;
+ }
for (i = 0; i < len; i += 8) {
printf("%s", fmt_ext_community(data + i));
@@ -579,7 +588,7 @@ show_ext_community(u_char *data, u_int16
}
}
-void
+static void
show_attr(u_char *data, size_t len, struct parse_result *res)
{
u_char *path;
@@ -591,16 +600,20 @@ show_attr(u_char *data, size_t len, stru
u_int8_t flags, type, safi, aid, prefixlen;
int i, pos, e2, e4;
- if (len < 3)
- errx(1, "show_attr: too short bgp attr");
+ if (len < 3) {
+ warnx("Too short BGP attrbute");
+ return;
+ }
flags = data[0];
type = data[1];
/* get the attribute length */
if (flags & ATTR_EXTLEN) {
- if (len < 4)
- errx(1, "show_attr: too short bgp attr");
+ if (len < 4) {
+ warnx("Too short BGP attrbute");
+ return;
+ }
memcpy(&alen, data+2, sizeof(u_int16_t));
alen = ntohs(alen);
data += 4;
@@ -612,15 +625,17 @@ show_attr(u_char *data, size_t len, stru
}
/* bad imsg len how can that happen!? */
- if (alen > len)
- errx(1, "show_attr: bad length");
+ if (alen > len) {
+ warnx("Bad BGP attrbute length");
+ return;
+ }
printf(" %s: ", fmt_attr(type, flags));
switch (type) {
case ATTR_ORIGIN:
if (alen == 1)
- printf("%u", *data);
+ printf("%s", fmt_origin(*data, 0));
else
printf("bad length");
break;
@@ -683,8 +698,11 @@ show_attr(u_char *data, size_t len, stru
show_community(data, alen);
break;
case ATTR_ORIGINATOR_ID:
- memcpy(&id, data, sizeof(id));
- printf("%s", inet_ntoa(id));
+ if (alen == 4) {
+ memcpy(&id, data, sizeof(id));
+ printf("%s", inet_ntoa(id));
+ } else
+ printf("bad length");
break;
case ATTR_CLUSTER_LIST:
for (ioff = 0; ioff + sizeof(id) <= alen;
@@ -722,7 +740,7 @@ show_attr(u_char *data, size_t len, stru
alen--;
if (nhlen > len)
goto bad_len;
- bzero(&nexthop, sizeof(nexthop));
+ memset(&nexthop, 0, sizeof(nexthop));
switch (aid) {
case AID_INET6:
nexthop.aid = aid;
@@ -737,6 +755,13 @@ show_attr(u_char *data, size_t len, stru
memcpy(&nexthop.v4, data + sizeof(u_int64_t),
sizeof(nexthop.v4));
break;
+ case AID_VPN_IPv6:
+ if (nhlen != 24)
+ goto bad_len;
+ nexthop.aid = AID_INET6;
+ memcpy(&nexthop.v6, data + sizeof(u_int64_t),
+ sizeof(nexthop.v6));
+ break;
default:
printf("unhandled AID #%u", aid);
goto done;
@@ -758,6 +783,10 @@ show_attr(u_char *data, size_t len, stru
pos = nlri_get_vpn4(data, alen, &prefix,
&prefixlen, 1);
break;
+ case AID_VPN_IPv6:
+ pos = nlri_get_vpn6(data, alen, &prefix,
+ &prefixlen, 1);
+ break;
default:
printf("unhandled AID #%u", aid);
goto done;
@@ -845,7 +874,7 @@ show_rib_detail(struct ctl_show_rib *r,
fmt_timeframe(r->age), EOL0(flag0));
}
-void
+static void
show_rib(struct ctl_show_rib *r, u_char *asdata, size_t aslen,
struct parse_result *res)
{
@@ -855,10 +884,9 @@ show_rib(struct ctl_show_rib *r, u_char
show_rib_brief(r, asdata, aslen);
}
-void
+static void
show_rib_mem(struct rde_memstats *stats)
{
- static size_t pt_sizes[AID_MAX] = AID_PTSIZE;
size_t pts = 0;
int i;
@@ -915,7 +943,7 @@ show_rib_mem(struct rde_memstats *stats)
printf("\nRDE hash statistics\n");
}
-void
+static void
show_rib_hash(struct rde_hashstats *hash)
{
double avg, dev;
@@ -928,16 +956,37 @@ show_rib_hash(struct rde_hashstats *hash
hash->min, hash->max, avg, dev);
}
-void
+static void
show_result(u_int rescode)
{
if (rescode == 0)
printf("request processed\n");
- else {
- if (rescode >
- sizeof(ctl_res_strerror)/sizeof(ctl_res_strerror[0]))
- printf("unknown result error code %u\n", rescode);
- else
- printf("%s\n", ctl_res_strerror[rescode]);
- }
+ else if (rescode >
+ sizeof(ctl_res_strerror)/sizeof(ctl_res_strerror[0]))
+ printf("unknown result error code %u\n", rescode);
+ else
+ printf("%s\n", ctl_res_strerror[rescode]);
}
+
+static void
+show_tail(void)
+{
+ /* nothing */
+}
+
+const struct output show_output = {
+ .head = show_head,
+ .neighbor = show_neighbor,
+ .timer = show_timer,
+ .fib = show_fib,
+ .fib_table = show_fib_table,
+ .nexthop = show_nexthop,
+ .interface = show_interface,
+ .communities = show_communities,
+ .attr = show_attr,
+ .rib = show_rib,
+ .rib_mem = show_rib_mem,
+ .rib_hash = show_rib_hash,
+ .result = show_result,
+ .tail = show_tail
+};
Index: output_json.c
===================================================================
RCS file: output_json.c
diff -N output_json.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ output_json.c 1 May 2020 11:04:25 -0000
@@ -0,0 +1,954 @@
+/* $OpenBSD: output.c,v 1.6 2020/03/20 07:56:34 claudio Exp $ */
+
+/*
+ * Copyright (c) 2020 Claudio Jeker <[email protected]>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <err.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "bgpd.h"
+#include "session.h"
+#include "rde.h"
+
+#include "bgpctl.h"
+#include "parser.h"
+#include "json.h"
+
+static void
+json_head(struct parse_result *res)
+{
+ json_do_start();
+}
+
+static void
+json_neighbor_capabilities(struct capabilities *capa)
+{
+ int hascapamp;
+ uint8_t i;
+
+ for (i = 0; i < AID_MAX; i++)
+ if (capa->mp[i])
+ hascapamp = 1;
+ if (!hascapamp && !capa->refresh && !capa->grestart.restart &&
+ !capa->as4byte)
+ return;
+
+ json_do_object("capabilities");
+ json_do_bool("as4byte", capa->as4byte);
+ json_do_bool("refresh", capa->refresh);
+
+ if (hascapamp) {
+ json_do_array("multiprotocol");
+ for (i = 0; i < AID_MAX; i++)
+ if (capa->mp[i])
+ json_do_printf("mp", "%s", aid2str(i));
+ json_do_end();
+ }
+ if (capa->grestart.restart) {
+ int restarted = 0, present = 0;
+
+ for (i = 0; i < AID_MAX; i++)
+ if (capa->grestart.flags[i] & CAPA_GR_PRESENT) {
+ present = 1;
+ if (capa->grestart.flags[i] & CAPA_GR_RESTART)
+ restarted = 1;
+ break;
+ }
+ json_do_object("graceful_restart");
+ json_do_bool("eor", 1);
+ json_do_bool("restart", restarted);
+
+ if (capa->grestart.timeout)
+ json_do_uint("timeout", capa->grestart.timeout);
+
+ if (present) {
+ json_do_array("protocols");
+ for (i = 0; i < AID_MAX; i++)
+ if (capa->grestart.flags[i] & CAPA_GR_PRESENT) {
+ json_do_object("family");
+ json_do_printf("family", "%s",
+ aid2str(i));
+ json_do_bool("preserved",
+ capa->grestart.flags[i] &
+ CAPA_GR_FORWARD);
+ json_do_end();
+ }
+ json_do_end();
+ }
+
+ json_do_end();
+ }
+
+ json_do_end();
+}
+
+static void
+json_neighbor_stats(struct peer *p)
+{
+ json_do_object("stats");
+ json_do_printf("last_read", "%s", fmt_monotime(p->stats.last_read));
+ json_do_printf("last_write", "%s", fmt_monotime(p->stats.last_write));
+
+ json_do_object("prefixes");
+ json_do_uint("sent", p->stats.prefix_out_cnt);
+ json_do_uint("recieved", p->stats.prefix_cnt);
+ json_do_end();
+
+ json_do_object("message");
+
+ json_do_object("sent");
+ json_do_uint("open", p->stats.msg_sent_open);
+ json_do_uint("notifications", p->stats.msg_sent_notification);
+ json_do_uint("updates", p->stats.msg_sent_update);
+ json_do_uint("keepalives", p->stats.msg_sent_keepalive);
+ json_do_uint("route_refresh", p->stats.msg_sent_rrefresh);
+ json_do_uint("total",
+ p->stats.msg_sent_open + p->stats.msg_sent_notification +
+ p->stats.msg_sent_update + p->stats.msg_sent_keepalive +
+ p->stats.msg_sent_rrefresh);
+ json_do_end();
+
+ json_do_object("received");
+ json_do_uint("open", p->stats.msg_rcvd_open);
+ json_do_uint("notifications", p->stats.msg_rcvd_notification);
+ json_do_uint("updates", p->stats.msg_rcvd_update);
+ json_do_uint("keepalives", p->stats.msg_rcvd_keepalive);
+ json_do_uint("route_refresh", p->stats.msg_rcvd_rrefresh);
+ json_do_uint("total",
+ p->stats.msg_rcvd_open + p->stats.msg_rcvd_notification +
+ p->stats.msg_rcvd_update + p->stats.msg_rcvd_keepalive +
+ p->stats.msg_rcvd_rrefresh);
+ json_do_end();
+
+ json_do_end();
+
+ json_do_object("update");
+
+ json_do_object("sent");
+ json_do_uint("updates", p->stats.prefix_sent_update);
+ json_do_uint("withdraws", p->stats.prefix_sent_withdraw);
+ json_do_uint("eor", p->stats.prefix_sent_eor);
+ json_do_end();
+
+ json_do_object("received");
+ json_do_uint("updates", p->stats.prefix_rcvd_update);
+ json_do_uint("withdraws", p->stats.prefix_rcvd_withdraw);
+ json_do_uint("eor", p->stats.prefix_rcvd_eor);
+ json_do_end();
+
+ json_do_end();
+
+ json_do_end();
+}
+
+static void
+json_neighbor_full(struct peer *p)
+{
+ const char *errstr;
+
+ /* config */
+ json_do_object("config");
+ json_do_bool("template", p->conf.template);
+ json_do_bool("cloned", p->template != NULL);
+ json_do_bool("passive", p->conf.passive);
+ json_do_bool("down", p->conf.down);
+ json_do_bool("multihop", p->conf.ebgp && p->conf.distance > 1);
+ if (p->conf.ebgp && p->conf.distance > 1)
+ json_do_uint("multihop_distance", p->conf.distance);
+ if (p->conf.max_prefix) {
+ json_do_uint("max_prefix", p->conf.max_prefix);
+ if (p->conf.max_prefix_restart)
+ json_do_uint("max_prefix_restart",
+ p->conf.max_prefix_restart);
+ }
+ if (p->conf.max_out_prefix) {
+ json_do_uint("max_prefix", p->conf.max_out_prefix);
+ if (p->conf.max_out_prefix_restart)
+ json_do_uint("max_out_prefix_restart",
+ p->conf.max_out_prefix_restart);
+ }
+ if (p->auth.method != AUTH_NONE)
+ json_do_printf("authentication", "%s",
+ fmt_auth_method(p->auth.method));
+ json_do_bool("ttl_security", p->conf.ttlsec);
+ json_do_uint("holdtime", p->conf.holdtime);
+ json_do_uint("min_holdtime", p->conf.min_holdtime);
+
+ /* capabilities */
+ json_do_bool("announce_capabilities", p->conf.announce_capa);
+ json_neighbor_capabilities(&p->conf.capabilities);
+
+ json_do_end();
+
+
+ /* stats */
+ json_neighbor_stats(p);
+
+ /* errors */
+ if (*(p->conf.shutcomm))
+ json_do_printf("my_shutdown_reason", "%s",
+ log_shutcomm(p->conf.shutcomm));
+ if (*(p->stats.last_shutcomm))
+ json_do_printf("last_shutdown_reason", "%s",
+ log_shutcomm(p->stats.last_shutcomm));
+ errstr = fmt_errstr(p->stats.last_sent_errcode,
+ p->stats.last_sent_suberr);
+ if (errstr)
+ json_do_printf("last_error_sent", "%s", errstr);
+ errstr = fmt_errstr(p->stats.last_rcvd_errcode,
+ p->stats.last_rcvd_suberr);
+ if (errstr)
+ json_do_printf("last_error_received", "%s", errstr);
+
+ /* connection info */
+ if (p->state >= STATE_OPENSENT) {
+ json_do_object("session");
+ json_do_uint("holdtime", p->holdtime);
+ json_do_uint("keepalive", p->holdtime / 3);
+
+ json_do_object("local");
+ json_do_printf("address", "%s", log_addr(&p->local));
+ json_do_uint("port", p->local_port);
+ json_neighbor_capabilities(&p->capa.ann);
+ json_do_end();
+
+ json_do_object("remote");
+ json_do_printf("address", "%s", log_addr(&p->remote));
+ json_do_uint("port", p->remote_port);
+ json_neighbor_capabilities(&p->capa.peer);
+ json_do_end();
+
+ /* capabilities */
+ json_neighbor_capabilities(&p->capa.neg);
+
+ json_do_end();
+ }
+}
+
+static void
+json_neighbor(struct peer *p, struct parse_result *res)
+{
+ json_do_array("neighbors");
+
+ json_do_object("neighbor");
+
+ json_do_printf("remote_as", "%s", log_as(p->conf.remote_as));
+ if (p->conf.descr[0])
+ json_do_printf("description", "%s", p->conf.descr);
+ if (!p->conf.template)
+ json_do_printf("remote_addr", "%s",
+ log_addr(&p->conf.remote_addr));
+ else
+ json_do_printf("remote_addr", "%s/%u",
+ log_addr(&p->conf.remote_addr), p->conf.remote_masklen);
+ if (p->state == STATE_ESTABLISHED) {
+ struct in_addr ina;
+ ina.s_addr = p->remote_bgpid;
+ json_do_printf("bgpid", "%s", inet_ntoa(ina));
+ }
+ json_do_printf("state", "%s", statenames[p->state]);
+ json_do_printf("last_updown", "%s", fmt_monotime(p->stats.last_updown));
+
+ switch (res->action) {
+ case SHOW:
+ case SHOW_SUMMARY:
+ case SHOW_SUMMARY_TERSE:
+ /* only show basic data */
+ break;
+ case SHOW_NEIGHBOR:
+ case SHOW_NEIGHBOR_TIMERS:
+ case SHOW_NEIGHBOR_TERSE:
+ json_neighbor_full(p);
+ break;
+ default:
+ break;
+ }
+
+ /* keep the object open in case there are timers */
+}
+
+static void
+json_timer(struct ctl_timer *t)
+{
+ json_do_array("timers");
+
+ json_do_object("timer");
+ json_do_printf("name", "%s", timernames[t->type]);
+ json_do_int("due", t->val);
+ json_do_end();
+}
+
+static void
+json_fib(struct kroute_full *kf)
+{
+ const char *origin;
+
+ json_do_array("fib");
+
+ json_do_object("fib_entry");
+
+ json_do_printf("prefix", "%s/%u", log_addr(&kf->prefix), kf->prefixlen);
+ json_do_uint("priority", kf->priority);
+ json_do_bool("up", !(kf->flags & F_DOWN));
+ if (kf->flags & F_BGPD_INSERTED)
+ origin = "bgp";
+ else if (kf->flags & F_CONNECTED)
+ origin = "connected";
+ else if (kf->flags & F_STATIC)
+ origin = "static";
+ else if (kf->flags & F_DYNAMIC)
+ origin = "dynamic";
+ else
+ origin = "unknown";
+ json_do_printf("origin", "%s", origin);
+ json_do_bool("used_by_nexthop", kf->flags & F_NEXTHOP);
+ json_do_bool("blackhole", kf->flags & F_BLACKHOLE);
+ json_do_bool("reject", kf->flags & F_REJECT);
+
+ if (kf->flags & F_CONNECTED)
+ json_do_printf("nexthop", "link#%u", kf->ifindex);
+ else
+ json_do_printf("nexthop", "%s", log_addr(&kf->nexthop));
+
+ json_do_end();
+}
+
+static void
+json_fib_table(struct ktable *kt)
+{
+ json_do_array("fibtables");
+
+ json_do_object("fibtable");
+ json_do_uint("rtableid", kt->rtableid);
+ json_do_printf("description", "%s", kt->descr);
+ json_do_bool("coupled", kt->fib_sync);
+ json_do_bool("admin_change", kt->fib_sync != kt->fib_conf);
+ json_do_end();
+}
+
+static void
+json_do_interface(struct ctl_show_interface *iface)
+{
+ json_do_object("interface");
+
+ json_do_printf("name", "%s", iface->ifname);
+ json_do_uint("rdomain", iface->rdomain);
+ json_do_bool("is_up", iface->is_up);
+ json_do_bool("nh_reachable", iface->nh_reachable);
+
+ if (iface->media[0])
+ json_do_printf("media", "%s", iface->media);
+
+ json_do_printf("linkstate", "%s", iface->linkstate);
+ if (iface->baudrate > 0)
+ json_do_uint("baudrate", iface->baudrate);
+
+ json_do_end();
+}
+
+static void
+json_nexthop(struct ctl_show_nexthop *nh)
+{
+ struct kroute *k;
+ struct kroute6 *k6;
+
+ json_do_array("nexthops");
+
+ json_do_object("nexthop");
+
+ json_do_printf("address", "%s", log_addr(&nh->addr));
+ json_do_bool("valid", nh->valid);
+
+ if (!nh->krvalid)
+ goto done;
+
+ switch (nh->addr.aid) {
+ case AID_INET:
+ k = &nh->kr.kr4;
+ json_do_printf("prefix", "%s/%u", inet_ntoa(k->prefix),
+ k->prefixlen);
+ json_do_uint("priority", k->priority);
+ json_do_bool("connected", k->flags & F_CONNECTED);
+ json_do_printf("nexthop", "%s", inet_ntoa(k->nexthop));
+ break;
+ case AID_INET6:
+ k6 = &nh->kr.kr6;
+ json_do_printf("prefix", "%s/%u", log_in6addr(&k6->prefix),
+ k6->prefixlen);
+ json_do_uint("priority", k6->priority);
+ json_do_bool("connected", k6->flags & F_CONNECTED);
+ json_do_printf("nexthop", "%s", log_in6addr(&k6->nexthop));
+ break;
+ default:
+ warnx("nexthop: unknown address family");
+ goto done;
+ }
+ if (nh->iface.ifname[0])
+ json_do_interface(&nh->iface);
+done:
+ json_do_end();
+ /* keep array open */
+}
+
+static void
+json_interface(struct ctl_show_interface *iface)
+{
+ json_do_array("interfaces");
+ json_do_interface(iface);
+}
+
+static void
+json_communities(u_char *data, size_t len, struct parse_result *res)
+{
+ struct community c;
+ size_t i;
+ uint64_t ext;
+
+ if (len % sizeof(c)) {
+ warnx("communities: bad size");
+ return;
+ }
+
+ for (i = 0; i < len; i += sizeof(c)) {
+ memcpy(&c, data + i, sizeof(c));
+
+ switch (c.flags) {
+ case COMMUNITY_TYPE_BASIC:
+ json_do_array("communities");
+ json_do_printf("community", "%s",
+ fmt_community(c.data1, c.data2));
+ break;
+ case COMMUNITY_TYPE_LARGE:
+ json_do_array("large_communities");
+ json_do_printf("community", "%s",
+ fmt_large_community(c.data1, c.data2, c.data3));
+ break;
+ case COMMUNITY_TYPE_EXT:
+ ext = (uint64_t)c.data3 << 48;
+ switch (c.data3 >> 8) {
+ case EXT_COMMUNITY_TRANS_TWO_AS:
+ case EXT_COMMUNITY_TRANS_OPAQUE:
+ case EXT_COMMUNITY_TRANS_EVPN:
+ case EXT_COMMUNITY_NON_TRANS_OPAQUE:
+ ext |= ((uint64_t)c.data1 & 0xffff) << 32;
+ ext |= (uint64_t)c.data2;
+ break;
+ case EXT_COMMUNITY_TRANS_FOUR_AS:
+ case EXT_COMMUNITY_TRANS_IPV4:
+ ext |= (uint64_t)c.data1 << 16;
+ ext |= (uint64_t)c.data2 & 0xffff;
+ break;
+ }
+ ext = htobe64(ext);
+
+ json_do_array("extended_communities");
+ json_do_printf("community", "%s",
+ fmt_ext_community((void *)&ext));
+ break;
+ }
+ }
+}
+
+static void
+json_do_community(u_char *data, uint16_t len)
+{
+ uint16_t a, v, i;
+
+ if (len & 0x3) {
+ json_do_printf("error", "bad length");
+ return;
+ }
+
+ json_do_array("communities");
+
+ for (i = 0; i < len; i += 4) {
+ memcpy(&a, data + i, sizeof(a));
+ memcpy(&v, data + i + 2, sizeof(v));
+ a = ntohs(a);
+ v = ntohs(v);
+ json_do_printf("community", "%s", fmt_community(a, v));
+ }
+
+ json_do_end();
+}
+
+static void
+json_do_large_community(u_char *data, uint16_t len)
+{
+ uint32_t a, l1, l2;
+ u_int16_t i;
+
+ if (len % 12) {
+ json_do_printf("error", "bad length");
+ return;
+ }
+
+ json_do_array("large_communities");
+
+ for (i = 0; i < len; i += 12) {
+ memcpy(&a, data + i, sizeof(a));
+ memcpy(&l1, data + i + 4, sizeof(l1));
+ memcpy(&l2, data + i + 8, sizeof(l2));
+ a = ntohl(a);
+ l1 = ntohl(l1);
+ l2 = ntohl(l2);
+
+ json_do_printf("community", "%s",
+ fmt_large_community(a, l1, l2));
+ }
+
+ json_do_end();
+}
+
+static void
+json_do_ext_community(u_char *data, uint16_t len)
+{
+ uint16_t i;
+
+ if (len & 0x7) {
+ json_do_printf("error", "bad length");
+ return;
+ }
+
+ json_do_array("extended_communities");
+
+ for (i = 0; i < len; i += 8)
+ json_do_printf("community", "%s", fmt_ext_community(data + i));
+
+ json_do_end();
+}
+
+static void
+json_attr(u_char *data, size_t len, struct parse_result *res)
+{
+ struct bgpd_addr prefix;
+ struct in_addr id;
+ char *aspath;
+ u_char *path;
+ uint32_t as;
+ uint16_t alen, afi, off, short_as;
+ uint8_t flags, type, safi, aid, prefixlen;
+ int e4, e2, pos;
+
+ if (len < 3) {
+ warnx("Too short BGP attrbute");
+ return;
+ }
+
+ flags = data[0];
+ type = data[1];
+ if (flags & ATTR_EXTLEN) {
+ if (len < 4) {
+ warnx("Too short BGP attrbute");
+ return;
+ }
+ memcpy(&alen, data+2, sizeof(uint16_t));
+ alen = ntohs(alen);
+ data += 4;
+ len -= 4;
+ } else {
+ alen = data[2];
+ data += 3;
+ len -= 3;
+ }
+
+ /* bad imsg len how can that happen!? */
+ if (alen > len) {
+ warnx("Bad BGP attrbute length");
+ return;
+ }
+
+ json_do_array("attributes");
+
+ json_do_object("attribute");
+ json_do_printf("type", "%s", fmt_attr(type, -1));
+ json_do_uint("length", alen);
+ json_do_object("flags");
+ json_do_bool("partial", flags & ATTR_PARTIAL);
+ json_do_bool("transitive", flags & ATTR_TRANSITIVE);
+ json_do_bool("optional", flags & ATTR_OPTIONAL);
+ json_do_end();
+
+ switch (type) {
+ case ATTR_ORIGIN:
+ if (alen == 1)
+ json_do_printf("origin", "%s", fmt_origin(*data, 0));
+ else
+ json_do_printf("error", "bad length");
+ break;
+ case ATTR_ASPATH:
+ case ATTR_AS4_PATH:
+ /* prefer 4-byte AS here */
+ e4 = aspath_verify(data, alen, 1);
+ e2 = aspath_verify(data, alen, 0);
+ if (e4 == 0 || e4 == AS_ERR_SOFT) {
+ path = data;
+ } else if (e2 == 0 || e2 == AS_ERR_SOFT) {
+ path = aspath_inflate(data, alen, &alen);
+ if (path == NULL)
+ errx(1, "aspath_inflate failed");
+ } else {
+ json_do_printf("error", "bad AS-Path");
+ break;
+ }
+ if (aspath_asprint(&aspath, path, alen) == -1)
+ err(1, NULL);
+ json_do_printf("aspath", "%s", aspath);
+ free(aspath);
+ if (path != data)
+ free(path);
+ break;
+ case ATTR_NEXTHOP:
+ if (alen == 4) {
+ memcpy(&id, data, sizeof(id));
+ json_do_printf("nexthop", "%s", inet_ntoa(id));
+ } else
+ json_do_printf("error", "bad length");
+ break;
+ case ATTR_MED:
+ case ATTR_LOCALPREF:
+ if (alen == 4) {
+ uint32_t val;
+ memcpy(&val, data, sizeof(val));
+ json_do_uint("metric", ntohl(val));
+ } else
+ json_do_printf("error", "bad length");
+ break;
+ case ATTR_AGGREGATOR:
+ case ATTR_AS4_AGGREGATOR:
+ if (alen == 8) {
+ memcpy(&as, data, sizeof(as));
+ memcpy(&id, data + sizeof(as), sizeof(id));
+ as = ntohl(as);
+ } else if (alen == 6) {
+ memcpy(&short_as, data, sizeof(short_as));
+ memcpy(&id, data + sizeof(short_as), sizeof(id));
+ as = ntohs(short_as);
+ } else {
+ json_do_printf("error", "bad AS-Path");
+ break;
+ }
+ json_do_uint("AS", as);
+ json_do_printf("router_id", "%s", inet_ntoa(id));
+ break;
+ case ATTR_COMMUNITIES:
+ json_do_community(data, alen);
+ break;
+ case ATTR_ORIGINATOR_ID:
+ if (alen == 4) {
+ memcpy(&id, data, sizeof(id));
+ json_do_printf("originator", "%s", inet_ntoa(id));
+ } else
+ json_do_printf("error", "bad length");
+ break;
+ case ATTR_CLUSTER_LIST:
+ json_do_array("cluster_list");
+ for (off = 0; off + sizeof(id) <= alen;
+ off += sizeof(id)) {
+ memcpy(&id, data + off, sizeof(id));
+ json_do_printf("cluster_id", "%s", inet_ntoa(id));
+ }
+ json_do_end();
+ break;
+ case ATTR_MP_REACH_NLRI:
+ case ATTR_MP_UNREACH_NLRI:
+ if (alen < 3) {
+bad_len:
+ json_do_printf("error", "bad length");
+ break;
+ }
+ memcpy(&afi, data, 2);
+ data += 2;
+ alen -= 2;
+ afi = ntohs(afi);
+ safi = *data++;
+ alen--;
+
+ if (afi2aid(afi, safi, &aid) == -1) {
+ json_do_printf("error", "bad AFI/SAFI pair: %d/%d",
+ afi, safi);
+ break;
+ }
+ json_do_printf("family", "%s", aid2str(aid));
+
+ if (type == ATTR_MP_REACH_NLRI) {
+ struct bgpd_addr nexthop;
+ uint8_t nhlen;
+ if (len == 0)
+ goto bad_len;
+ nhlen = *data++;
+ alen--;
+ if (nhlen > len)
+ goto bad_len;
+ memset(&nexthop, 0, sizeof(nexthop));
+ switch (aid) {
+ case AID_INET6:
+ nexthop.aid = aid;
+ if (nhlen != 16 && nhlen != 32)
+ goto bad_len;
+ memcpy(&nexthop.v6.s6_addr, data, 16);
+ break;
+ case AID_VPN_IPv4:
+ if (nhlen != 12)
+ goto bad_len;
+ nexthop.aid = AID_INET;
+ memcpy(&nexthop.v4, data + sizeof(uint64_t),
+ sizeof(nexthop.v4));
+ break;
+ case AID_VPN_IPv6:
+ if (nhlen != 24)
+ goto bad_len;
+ nexthop.aid = AID_INET6;
+ memcpy(&nexthop.v6, data + sizeof(uint64_t),
+ sizeof(nexthop.v6));
+ break;
+ default:
+ json_do_printf("error", "unhandled AID: %d",
+ aid);
+ return;
+ }
+ /* ignore reserved (old SNPA) field as per RFC4760 */
+ data += nhlen + 1;
+ alen -= nhlen + 1;
+
+ json_do_printf("nexthop", "%s", log_addr(&nexthop));
+ }
+
+ json_do_array("NLRI");
+ while (alen > 0) {
+ switch (aid) {
+ case AID_INET6:
+ pos = nlri_get_prefix6(data, alen, &prefix,
+ &prefixlen);
+ break;
+ case AID_VPN_IPv4:
+ pos = nlri_get_vpn4(data, alen, &prefix,
+ &prefixlen, 1);
+ break;
+ case AID_VPN_IPv6:
+ pos = nlri_get_vpn6(data, alen, &prefix,
+ &prefixlen, 1);
+ break;
+ default:
+ json_do_printf("error", "unhandled AID: %d",
+ aid);
+ return;
+ }
+ if (pos == -1) {
+ json_do_printf("error", "bad %s prefix",
+ aid2str(aid));
+ break;
+ }
+ json_do_printf("prefix", "%s/%u", log_addr(&prefix),
+ prefixlen);
+ data += pos;
+ alen -= pos;
+ }
+ break;
+ case ATTR_EXT_COMMUNITIES:
+ json_do_ext_community(data, alen);
+ break;
+ case ATTR_LARGE_COMMUNITIES:
+ json_do_large_community(data, alen);
+ break;
+ case ATTR_ATOMIC_AGGREGATE:
+ default:
+ if (alen)
+ json_do_hexdump("data", data, alen);
+ break;
+ }
+}
+
+static void
+json_rib(struct ctl_show_rib *r, u_char *asdata, size_t aslen,
+ struct parse_result *res)
+{
+ struct in_addr id;
+ char *aspath;
+
+ json_do_array("rib");
+
+ json_do_object("rib_entry");
+
+ json_do_printf("prefix", "%s/%u", log_addr(&r->prefix), r->prefixlen);
+
+ if (aspath_asprint(&aspath, asdata, aslen) == -1)
+ err(1, NULL);
+ json_do_printf("aspath", "%s", aspath);
+ free(aspath);
+
+ json_do_printf("exit_nexthop", "%s", log_addr(&r->exit_nexthop));
+ json_do_printf("true_nexthop", "%s", log_addr(&r->true_nexthop));
+
+ json_do_object("neighbor");
+ if (r->descr[0])
+ json_do_printf("description", "%s", r->descr);
+ json_do_printf("remote_addr", "%s", log_addr(&r->remote_addr));
+ id.s_addr = htonl(r->remote_id);
+ json_do_printf("bgp_id", "%s", inet_ntoa(id));
+ json_do_end();
+
+ /* flags */
+ json_do_bool("valid", r->flags & F_PREF_ELIGIBLE);
+ if (r->flags & F_PREF_ACTIVE)
+ json_do_bool("best", 1);
+ if (r->flags & F_PREF_INTERNAL)
+ json_do_printf("source", "%s", "internal");
+ else
+ json_do_printf("source", "%s", "external");
+ if (r->flags & F_PREF_STALE)
+ json_do_bool("stale", 1);
+ if (r->flags & F_PREF_ANNOUNCE)
+ json_do_bool("announced", 1);
+
+ /* various attribibutes */
+ json_do_printf("ovs", "%s", fmt_ovs(r->validation_state, 0));
+ json_do_printf("origin", "%s", fmt_origin(r->origin, 0));
+ json_do_uint("metric", r->med);
+ json_do_uint("localpref", r->local_pref);
+ json_do_uint("weight", r->weight);
+ json_do_printf("last_update", "%s", fmt_timeframe(r->age));
+
+ /* keep the object open for communities and attribuites */
+}
+
+static void
+json_rib_mem_element(const char *name, uint64_t count, uint64_t size,
+ uint64_t refs)
+{
+ json_do_object(name);
+ if (count != UINT64_MAX)
+ json_do_uint("count", count);
+ if (size != UINT64_MAX)
+ json_do_uint("size", size);
+ if (refs != UINT64_MAX)
+ json_do_uint("references", refs);
+ json_do_end();
+}
+
+static void
+json_rib_mem(struct rde_memstats *stats)
+{
+ size_t pts = 0;
+ int i;
+
+ json_do_object("memory");
+ for (i = 0; i < AID_MAX; i++) {
+ if (stats->pt_cnt[i] == 0)
+ continue;
+ pts += stats->pt_cnt[i] * pt_sizes[i];
+ json_rib_mem_element(aid_vals[i].name, stats->pt_cnt[i],
+ stats->pt_cnt[i] * pt_sizes[i], UINT64_MAX);
+ }
+ json_rib_mem_element("rib", stats->rib_cnt,
+ stats->rib_cnt * sizeof(struct rib_entry), UINT64_MAX);
+ json_rib_mem_element("prefix", stats->prefix_cnt,
+ stats->prefix_cnt * sizeof(struct prefix), UINT64_MAX);
+ json_rib_mem_element("rde_aspath", stats->path_cnt,
+ stats->path_cnt * sizeof(struct rde_aspath),
+ stats->path_refs);
+ json_rib_mem_element("aspath", stats->aspath_cnt,
+ stats->aspath_size, stats->aspath_refs);
+ json_rib_mem_element("community_entries", stats->comm_cnt,
+ stats->comm_cnt * sizeof(struct rde_community), UINT64_MAX);
+ json_rib_mem_element("community", stats->comm_nmemb,
+ stats->comm_size * sizeof(struct community), stats->comm_refs);
+ json_rib_mem_element("attributes_entries", stats->attr_cnt,
+ stats->attr_cnt * sizeof(struct attr), stats->attr_refs);
+ json_rib_mem_element("attributes", stats->attr_dcnt,
+ stats->attr_data, UINT64_MAX);
+ json_rib_mem_element("total", UINT64_MAX,
+ pts + stats->prefix_cnt * sizeof(struct prefix) +
+ stats->rib_cnt * sizeof(struct rib_entry) +
+ stats->path_cnt * sizeof(struct rde_aspath) +
+ stats->aspath_size + stats->attr_cnt * sizeof(struct attr) +
+ stats->attr_data, UINT64_MAX);
+ json_do_end();
+
+ json_do_object("sets");
+ json_rib_mem_element("as_set", stats->aset_nmemb,
+ stats->aset_size, UINT64_MAX);
+ json_rib_mem_element("as_set_tables", stats->aset_cnt, UINT64_MAX,
+ UINT64_MAX);
+ json_rib_mem_element("prefix_set", stats->pset_cnt, stats->pset_size,
+ UINT64_MAX);
+ json_rib_mem_element("total", UINT64_MAX,
+ stats->aset_size + stats->pset_size, UINT64_MAX);
+ json_do_end();
+}
+
+static void
+json_rib_hash(struct rde_hashstats *hash)
+{
+ double avg, dev;
+
+ json_do_array("hashtables");
+
+ avg = (double)hash->sum / (double)hash->num;
+ dev = sqrt(fmax(0, hash->sumq / hash->num - avg * avg));
+
+ json_do_object("hashtable");
+
+ json_do_printf("name", "%s", hash->name);
+ json_do_uint("size", hash->num);
+ json_do_uint("entries", hash->sum);
+ json_do_uint("min", hash->min);
+ json_do_uint("max", hash->max);
+ json_do_double("avg", avg);
+ json_do_double("std_dev", dev);
+ json_do_end();
+}
+
+static void
+json_result(u_int rescode)
+{
+ if (rescode == 0)
+ json_do_printf("status", "OK");
+ else if (rescode >
+ sizeof(ctl_res_strerror)/sizeof(ctl_res_strerror[0])) {
+ json_do_printf("status", "FAILED");
+ json_do_printf("error", "unknown error %d", rescode);
+ } else {
+ json_do_printf("status", "FAILED");
+ json_do_printf("error", "%s", ctl_res_strerror[rescode]);
+ }
+}
+
+static void
+json_tail(void)
+{
+ json_do_finish();
+}
+
+const struct output json_output = {
+ .head = json_head,
+ .neighbor = json_neighbor,
+ .timer = json_timer,
+ .fib = json_fib,
+ .fib_table = json_fib_table,
+ .nexthop = json_nexthop,
+ .interface = json_interface,
+ .communities = json_communities,
+ .attr = json_attr,
+ .rib = json_rib,
+ .rib_mem = json_rib_mem,
+ .rib_hash = json_rib_hash,
+ .result = json_result,
+ .tail = json_tail
+};
