Mailing List Archive

From: David Lamparter <equinox@diac24.net>

This commit introduces .c and .h files issued from bgp.capnp
scheme file. Generating .c files from this scheme file
requires capnp compiler, and also some custom libraries that,
at the time of this writing are yet under development. So,
practically, in order to be able to compile without having
those custom libraries refreshed, along with capnp compiler,
the generated files are provided.
Consequently, it permits modifying those files. This is what
has been done to manually fix some RD prefix length issues.

Signed-off-by: David Lamparter <equinox@opensourcerouting.org>
Signed-off-by: Philippe Guibert <philippe.guibert@6wind.com>
---
bgpd/bgp.bcapnp.c | 1220 +++++++++++++++++++++++++++++++++++++++++++++++++++++
bgpd/bgp.bcapnp.h | 56 +++
bgpd/bgpd.ndef.hi | 15 +
bgpd/bgpd.ndef.i | 791 ++++++++++++++++++++++++++++++++++
4 files changed, 2082 insertions(+)
create mode 100644 bgpd/bgp.bcapnp.c
create mode 100644 bgpd/bgp.bcapnp.h
create mode 100644 bgpd/bgpd.ndef.hi
create mode 100644 bgpd/bgpd.ndef.i

diff --git a/bgpd/bgp.bcapnp.c b/bgpd/bgp.bcapnp.c
new file mode 100644
index 000000000000..83eb3dac3b6e
--- /dev/null
+++ b/bgpd/bgp.bcapnp.c
@@ -0,0 +1,1220 @@
+/*
+ * derived from GPLv2+ sources
+ */
+#include <stdbool.h>
+#include "c-capnproto/capn.h"
+#include "bgp.bcapnp.h"
+
+static const capn_text capn_val0 = {0, ""};
+
+
+#include "zebra.h"
+#include "bgpd.h"
+
+afi_t qcapn_AfiSafiKey_get_afi(capn_ptr p)
+{
+ capn_resolve(&p);
+ return capn_read8(p, 0);
+}
+
+
+safi_t qcapn_AfiSafiKey_get_safi(capn_ptr p)
+{
+ capn_resolve(&p);
+ return capn_read8(p, 1);
+}
+
+
+capn_ptr qcapn_new_AfiSafiKey(struct capn_segment *s)
+{
+ return capn_new_struct(s, 8, 0);
+}
+
+
+afi_t qcapn_AfiKey_get_afi(capn_ptr p)
+{
+ capn_resolve(&p);
+ return capn_read8(p, 0);
+}
+
+
+capn_ptr qcapn_new_AfiKey(struct capn_segment *s)
+{
+ return capn_new_struct(s, 8, 0);
+}
+
+
+
+void qcapn_VRFTableIter_read(struct tbliter_v4 *s, capn_ptr p)
+{
+ capn_resolve(&p);
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 0, 1);
+ s->prefix.family = AF_INET;
+ s->prefix.prefixlen = capn_read8(tmp_p, 4);
+ s->prefix.prefix.s_addr = htonl(capn_read32(tmp_p, 0));
+ }
+}
+
+
+
+void qcapn_VRFTableIter_write(const struct tbliter_v4 *s, capn_ptr p)
+{
+ capn_resolve(&p);
+
+ {
+ capn_ptr tempptr = capn_new_struct(p.seg, 8, 0);
+ capn_write8(tempptr, 4, s->prefix.prefixlen);
+ capn_write32(tempptr, 0, ntohl(s->prefix.prefix.s_addr));
+ capn_setp(p, 0, tempptr);
+ }
+}
+
+
+
+void qcapn_VRFTableIter_set(struct tbliter_v4 *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ {
+ /* MISSING: prefix */
+ }
+}
+
+
+capn_ptr qcapn_new_VRFTableIter(struct capn_segment *s)
+{
+ return capn_new_struct(s, 0, 1);
+}
+
+
+
+void qcapn_BGP_read(struct bgp *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ s->as = capn_read32(p, 0);
+ { capn_text tp = capn_get_text(p, 0, capn_val0); free(s->name); s->name = strdup(tp.str); }
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 1, 1);
+ s->router_id_static.s_addr = htonl(capn_read32(tmp_p, 0));
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 4) & (1 << 0));
+ if (tmp) s->flags |= BGP_FLAG_ALWAYS_COMPARE_MED;
+ else s->flags &= ~BGP_FLAG_ALWAYS_COMPARE_MED;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 4) & (1 << 1));
+ if (tmp) s->flags |= BGP_FLAG_DETERMINISTIC_MED;
+ else s->flags &= ~BGP_FLAG_DETERMINISTIC_MED;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 4) & (1 << 2));
+ if (tmp) s->flags |= BGP_FLAG_MED_MISSING_AS_WORST;
+ else s->flags &= ~BGP_FLAG_MED_MISSING_AS_WORST;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 4) & (1 << 3));
+ if (tmp) s->flags |= BGP_FLAG_MED_CONFED;
+ else s->flags &= ~BGP_FLAG_MED_CONFED;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 4) & (1 << 4));
+ if (tmp) s->flags |= BGP_FLAG_NO_DEFAULT_IPV4;
+ else s->flags &= ~BGP_FLAG_NO_DEFAULT_IPV4;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 4) & (1 << 5));
+ if (tmp) s->flags |= BGP_FLAG_NO_CLIENT_TO_CLIENT;
+ else s->flags &= ~BGP_FLAG_NO_CLIENT_TO_CLIENT;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 4) & (1 << 6));
+ if (tmp) s->flags |= BGP_FLAG_ENFORCE_FIRST_AS;
+ else s->flags &= ~BGP_FLAG_ENFORCE_FIRST_AS;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 4) & (1 << 7));
+ if (tmp) s->flags |= BGP_FLAG_COMPARE_ROUTER_ID;
+ else s->flags &= ~BGP_FLAG_COMPARE_ROUTER_ID;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 5) & (1 << 0));
+ if (tmp) s->flags |= BGP_FLAG_ASPATH_IGNORE;
+ else s->flags &= ~BGP_FLAG_ASPATH_IGNORE;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 5) & (1 << 1));
+ if (tmp) s->flags |= BGP_FLAG_IMPORT_CHECK;
+ else s->flags &= ~BGP_FLAG_IMPORT_CHECK;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 5) & (1 << 2));
+ if (tmp) s->flags |= BGP_FLAG_NO_FAST_EXT_FAILOVER;
+ else s->flags &= ~BGP_FLAG_NO_FAST_EXT_FAILOVER;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 5) & (1 << 3));
+ if (tmp) s->flags |= BGP_FLAG_LOG_NEIGHBOR_CHANGES;
+ else s->flags &= ~BGP_FLAG_LOG_NEIGHBOR_CHANGES;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 5) & (1 << 4));
+ if (tmp) s->flags |= BGP_FLAG_GRACEFUL_RESTART;
+ else s->flags &= ~BGP_FLAG_GRACEFUL_RESTART;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 5) & (1 << 5));
+ if (tmp) s->flags |= BGP_FLAG_ASPATH_CONFED;
+ else s->flags &= ~BGP_FLAG_ASPATH_CONFED;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 5) & (1 << 6));
+ if (tmp) s->flags |= BGP_FLAG_ASPATH_MULTIPATH_RELAX;
+ else s->flags &= ~BGP_FLAG_ASPATH_MULTIPATH_RELAX;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 5) & (1 << 7));
+ if (tmp) s->flags |= BGP_FLAG_GR_PRESERVE_FWD;
+ else s->flags &= ~BGP_FLAG_GR_PRESERVE_FWD;
+ }
+ s->distance_ebgp = capn_read8(p, 6);
+ s->distance_ibgp = capn_read8(p, 7);
+ s->distance_local = capn_read8(p, 8);
+ s->default_local_pref = capn_read32(p, 12);
+ s->default_holdtime = capn_read32(p, 16);
+ s->default_keepalive = capn_read32(p, 20);
+ s->restart_time = capn_read32(p, 24);
+ s->stalepath_time = capn_read32(p, 28);
+ { capn_text tp = capn_get_text(p, 2, capn_val0); free(s->notify_zmq_url); s->notify_zmq_url = strdup(tp.str); }
+}
+
+
+
+void qcapn_BGP_write(const struct bgp *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ capn_write32(p, 0, s->as);
+ { capn_text tp = { .str = s->name, .len = s->name ? strlen(s->name) : 0 }; capn_set_text(p, 0, tp); }
+
+ {
+ capn_ptr tempptr = capn_new_struct(p.seg, 8, 0);
+ capn_write32(tempptr, 0, ntohl(s->router_id_static.s_addr));
+ capn_setp(p, 1, tempptr);
+ }
+ capn_write1(p, 32, !!(s->flags & BGP_FLAG_ALWAYS_COMPARE_MED));
+ capn_write1(p, 33, !!(s->flags & BGP_FLAG_DETERMINISTIC_MED));
+ capn_write1(p, 34, !!(s->flags & BGP_FLAG_MED_MISSING_AS_WORST));
+ capn_write1(p, 35, !!(s->flags & BGP_FLAG_MED_CONFED));
+ capn_write1(p, 36, !!(s->flags & BGP_FLAG_NO_DEFAULT_IPV4));
+ capn_write1(p, 37, !!(s->flags & BGP_FLAG_NO_CLIENT_TO_CLIENT));
+ capn_write1(p, 38, !!(s->flags & BGP_FLAG_ENFORCE_FIRST_AS));
+ capn_write1(p, 39, !!(s->flags & BGP_FLAG_COMPARE_ROUTER_ID));
+ capn_write1(p, 40, !!(s->flags & BGP_FLAG_ASPATH_IGNORE));
+ capn_write1(p, 41, !!(s->flags & BGP_FLAG_IMPORT_CHECK));
+ capn_write1(p, 42, !!(s->flags & BGP_FLAG_NO_FAST_EXT_FAILOVER));
+ capn_write1(p, 43, !!(s->flags & BGP_FLAG_LOG_NEIGHBOR_CHANGES));
+ capn_write1(p, 44, !!(s->flags & BGP_FLAG_GRACEFUL_RESTART));
+ capn_write1(p, 45, !!(s->flags & BGP_FLAG_ASPATH_CONFED));
+ capn_write1(p, 46, !!(s->flags & BGP_FLAG_ASPATH_MULTIPATH_RELAX));
+ capn_write1(p, 47, !!(s->flags & BGP_FLAG_GR_PRESERVE_FWD));
+ capn_write8(p, 6, s->distance_ebgp);
+ capn_write8(p, 7, s->distance_ibgp);
+ capn_write8(p, 8, s->distance_local);
+ capn_write32(p, 12, s->default_local_pref);
+ capn_write32(p, 16, s->default_holdtime);
+ capn_write32(p, 20, s->default_keepalive);
+ capn_write32(p, 24, s->restart_time);
+ capn_write32(p, 28, s->stalepath_time);
+ { capn_text tp = { .str = s->notify_zmq_url, .len = s->notify_zmq_url ? strlen(s->notify_zmq_url) : 0 }; capn_set_text(p, 2, tp); }
+}
+
+
+
+void qcapn_BGP_set(struct bgp *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ {
+ /* MISSING: as */
+ }
+ {
+ /* MISSING: name */
+ }
+ {
+ struct in_addr router_id_static;
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 1, 1);
+ router_id_static.s_addr = htonl(capn_read32(tmp_p, 0));
+ }
+ bgp_router_id_static_set(s, router_id_static);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 4) & (1 << 0));
+ if (flags) bgp_flag_set(s, BGP_FLAG_ALWAYS_COMPARE_MED);
+ else bgp_flag_unset(s, BGP_FLAG_ALWAYS_COMPARE_MED);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 4) & (1 << 1));
+ if (flags) bgp_flag_set(s, BGP_FLAG_DETERMINISTIC_MED);
+ else bgp_flag_unset(s, BGP_FLAG_DETERMINISTIC_MED);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 4) & (1 << 2));
+ if (flags) bgp_flag_set(s, BGP_FLAG_MED_MISSING_AS_WORST);
+ else bgp_flag_unset(s, BGP_FLAG_MED_MISSING_AS_WORST);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 4) & (1 << 3));
+ if (flags) bgp_flag_set(s, BGP_FLAG_MED_CONFED);
+ else bgp_flag_unset(s, BGP_FLAG_MED_CONFED);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 4) & (1 << 4));
+ if (flags) bgp_flag_set(s, BGP_FLAG_NO_DEFAULT_IPV4);
+ else bgp_flag_unset(s, BGP_FLAG_NO_DEFAULT_IPV4);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 4) & (1 << 5));
+ if (flags) bgp_flag_set(s, BGP_FLAG_NO_CLIENT_TO_CLIENT);
+ else bgp_flag_unset(s, BGP_FLAG_NO_CLIENT_TO_CLIENT);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 4) & (1 << 6));
+ if (flags) bgp_flag_set(s, BGP_FLAG_ENFORCE_FIRST_AS);
+ else bgp_flag_unset(s, BGP_FLAG_ENFORCE_FIRST_AS);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 4) & (1 << 7));
+ if (flags) bgp_flag_set(s, BGP_FLAG_COMPARE_ROUTER_ID);
+ else bgp_flag_unset(s, BGP_FLAG_COMPARE_ROUTER_ID);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 5) & (1 << 0));
+ if (flags) bgp_flag_set(s, BGP_FLAG_ASPATH_IGNORE);
+ else bgp_flag_unset(s, BGP_FLAG_ASPATH_IGNORE);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 5) & (1 << 1));
+ if (flags) bgp_flag_set(s, BGP_FLAG_IMPORT_CHECK);
+ else bgp_flag_unset(s, BGP_FLAG_IMPORT_CHECK);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 5) & (1 << 2));
+ if (flags) bgp_flag_set(s, BGP_FLAG_NO_FAST_EXT_FAILOVER);
+ else bgp_flag_unset(s, BGP_FLAG_NO_FAST_EXT_FAILOVER);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 5) & (1 << 3));
+ if (flags) bgp_flag_set(s, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
+ else bgp_flag_unset(s, BGP_FLAG_LOG_NEIGHBOR_CHANGES);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 5) & (1 << 4));
+ if (flags) bgp_flag_set(s, BGP_FLAG_GRACEFUL_RESTART);
+ else bgp_flag_unset(s, BGP_FLAG_GRACEFUL_RESTART);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 5) & (1 << 5));
+ if (flags) bgp_flag_set(s, BGP_FLAG_ASPATH_CONFED);
+ else bgp_flag_unset(s, BGP_FLAG_ASPATH_CONFED);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 5) & (1 << 6));
+ if (flags) bgp_flag_set(s, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
+ else bgp_flag_unset(s, BGP_FLAG_ASPATH_MULTIPATH_RELAX);
+
+ }
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 5) & (1 << 7));
+ if (flags) bgp_flag_set(s, BGP_FLAG_GR_PRESERVE_FWD);
+ else bgp_flag_unset(s, BGP_FLAG_GR_PRESERVE_FWD);
+ }
+ {
+ u_int32_t default_local_pref;
+ default_local_pref = capn_read32(p, 12);
+ if (default_local_pref) { bgp_default_local_preference_set(s, default_local_pref); } else { bgp_default_local_preference_unset(s); }
+
+ }
+ {
+ u_int32_t keepalive;
+ u_int32_t holdtime;
+ keepalive = capn_read32(p, 20);
+ holdtime = capn_read32(p, 16);
+ if (keepalive || holdtime) { bgp_timers_set(s, keepalive, holdtime); } else { bgp_timers_unset(s); }
+
+
+ }
+ {
+ /* MISSING: restart_time */
+ }
+ {
+ const char * notify_zmq_url;
+ { capn_text tp = capn_get_text(p, 2, capn_val0); notify_zmq_url = tp.str; }
+ bgp_notify_zmq_url_set(s, notify_zmq_url);
+
+ }
+ s->distance_ebgp = capn_read8(p, 6);
+ s->distance_ibgp = capn_read8(p, 7);
+ s->distance_local = capn_read8(p, 8);
+ s->stalepath_time = capn_read32(p, 28);
+}
+
+
+as_t qcapn_BGP_get_as(capn_ptr p)
+{
+ capn_resolve(&p);
+ return capn_read32(p, 0);
+}
+
+
+capn_ptr qcapn_new_BGP(struct capn_segment *s)
+{
+ return capn_new_struct(s, 32, 3);
+}
+
+
+
+void qcapn_BGPAfiSafi_read(struct bgp *s, capn_ptr p, afi_t afi, safi_t safi)
+{
+ capn_resolve(&p);
+ { bool tmp;
+ tmp = !!(capn_read8(p, 0) & (1 << 0));
+ if (tmp) s->af_flags[afi][safi] |= BGP_CONFIG_DAMPENING;
+ else s->af_flags[afi][safi] &= ~BGP_CONFIG_DAMPENING;
+ }
+}
+
+
+
+void qcapn_BGPAfiSafi_write(const struct bgp *s, capn_ptr p, afi_t afi, safi_t safi)
+{
+ capn_resolve(&p);
+ capn_write1(p, 0, !!(s->af_flags[afi][safi] & BGP_CONFIG_DAMPENING));
+}
+
+
+
+void qcapn_BGPAfiSafi_set(struct bgp *s, capn_ptr p, afi_t afi, safi_t safi)
+{
+ capn_resolve(&p);
+ {
+ u_int16_t flags;
+ flags = !!(capn_read8(p, 0) & (1 << 0));
+ if (flags) bgp_af_flag_set(s, BGP_CONFIG_DAMPENING, afi, safi);
+ else bgp_af_flag_unset(s, BGP_CONFIG_DAMPENING, afi, safi);
+ }
+}
+
+
+capn_ptr qcapn_new_BGPAfiSafi(struct capn_segment *s)
+{
+ return capn_new_struct(s, 8, 0);
+}
+
+
+
+void qcapn_BGPPeer_read(struct peer *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ s->as = capn_read32(p, 0);
+ { capn_text tp = capn_get_text(p, 0, capn_val0); free(s->host); s->host = strdup(tp.str); }
+ { capn_text tp = capn_get_text(p, 1, capn_val0); free(s->desc); s->desc = strdup(tp.str); }
+ s->port = capn_read16(p, 4);
+ s->weight = capn_read32(p, 8);
+ s->holdtime = capn_read32(p, 12);
+ s->keepalive = capn_read32(p, 16);
+ { bool tmp;
+ tmp = !!(capn_read8(p, 6) & (1 << 0));
+ if (tmp) s->flags |= PEER_FLAG_PASSIVE;
+ else s->flags &= ~PEER_FLAG_PASSIVE;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 6) & (1 << 1));
+ if (tmp) s->flags |= PEER_FLAG_SHUTDOWN;
+ else s->flags &= ~PEER_FLAG_SHUTDOWN;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 6) & (1 << 2));
+ if (tmp) s->flags |= PEER_FLAG_DONT_CAPABILITY;
+ else s->flags &= ~PEER_FLAG_DONT_CAPABILITY;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 6) & (1 << 3));
+ if (tmp) s->flags |= PEER_FLAG_OVERRIDE_CAPABILITY;
+ else s->flags &= ~PEER_FLAG_OVERRIDE_CAPABILITY;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 6) & (1 << 4));
+ if (tmp) s->flags |= PEER_FLAG_STRICT_CAP_MATCH;
+ else s->flags &= ~PEER_FLAG_STRICT_CAP_MATCH;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 6) & (1 << 5));
+ if (tmp) s->flags |= PEER_FLAG_DYNAMIC_CAPABILITY;
+ else s->flags &= ~PEER_FLAG_DYNAMIC_CAPABILITY;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 6) & (1 << 6));
+ if (tmp) s->flags |= PEER_FLAG_DISABLE_CONNECTED_CHECK;
+ else s->flags &= ~PEER_FLAG_DISABLE_CONNECTED_CHECK;
+ }
+ s->ttl = capn_read32(p, 20);
+ /* MISSING: updateSource */
+}
+
+
+
+void qcapn_BGPPeer_write(const struct peer *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ capn_write32(p, 0, s->as);
+ { capn_text tp = { .str = s->host, .len = s->host ? strlen(s->host) : 0 }; capn_set_text(p, 0, tp); }
+ { capn_text tp = { .str = s->desc, .len = s->desc ? strlen(s->desc) : 0 }; capn_set_text(p, 1, tp); }
+ capn_write16(p, 4, s->port);
+ capn_write32(p, 8, s->weight);
+ capn_write32(p, 12, s->holdtime);
+ capn_write32(p, 16, s->keepalive);
+ capn_write1(p, 48, !!(s->flags & PEER_FLAG_PASSIVE));
+ capn_write1(p, 49, !!(s->flags & PEER_FLAG_SHUTDOWN));
+ capn_write1(p, 50, !!(s->flags & PEER_FLAG_DONT_CAPABILITY));
+ capn_write1(p, 51, !!(s->flags & PEER_FLAG_OVERRIDE_CAPABILITY));
+ capn_write1(p, 52, !!(s->flags & PEER_FLAG_STRICT_CAP_MATCH));
+ capn_write1(p, 53, !!(s->flags & PEER_FLAG_DYNAMIC_CAPABILITY));
+ capn_write1(p, 54, !!(s->flags & PEER_FLAG_DISABLE_CONNECTED_CHECK));
+ capn_write32(p, 20, s->ttl);
+ /* MISSING: updateSource */
+}
+
+
+
+void qcapn_BGPPeer_set(struct peer *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ {
+ /* MISSING: as */
+ }
+ {
+ /* MISSING: host */
+ }
+ {
+ const char * desc;
+ { capn_text tp = capn_get_text(p, 1, capn_val0); desc = tp.str; }
+ if (desc) { peer_description_set(s, desc); } else { peer_description_unset(s); }
+
+ }
+ {
+ unsigned port;
+ port = capn_read16(p, 4);
+ if (port) { peer_port_set(s, port); } else { peer_port_unset(s); }
+
+ }
+ {
+ u_int32_t weight;
+ weight = capn_read32(p, 8);
+ if (weight) { peer_weight_set(s, weight); } else { peer_weight_unset(s); }
+
+ }
+ {
+ u_int32_t keepalive;
+ u_int32_t holdtime;
+ keepalive = capn_read32(p, 16);
+ holdtime = capn_read32(p, 12);
+ if (keepalive || holdtime) { peer_timers_set(s, keepalive, holdtime); } else { peer_timers_unset(s); }
+
+
+ }
+ {
+ u_int32_t flags;
+ flags = !!(capn_read8(p, 6) & (1 << 0));
+ if (flags) peer_flag_set(s, PEER_FLAG_PASSIVE);
+ else peer_flag_unset(s, PEER_FLAG_PASSIVE);
+
+ }
+ {
+ u_int32_t flags;
+ flags = !!(capn_read8(p, 6) & (1 << 1));
+ if (flags) peer_flag_set(s, PEER_FLAG_SHUTDOWN);
+ else peer_flag_unset(s, PEER_FLAG_SHUTDOWN);
+
+ }
+ {
+ u_int32_t flags;
+ flags = !!(capn_read8(p, 6) & (1 << 2));
+ if (flags) peer_flag_set(s, PEER_FLAG_DONT_CAPABILITY);
+ else peer_flag_unset(s, PEER_FLAG_DONT_CAPABILITY);
+
+ }
+ {
+ u_int32_t flags;
+ flags = !!(capn_read8(p, 6) & (1 << 3));
+ if (flags) peer_flag_set(s, PEER_FLAG_OVERRIDE_CAPABILITY);
+ else peer_flag_unset(s, PEER_FLAG_OVERRIDE_CAPABILITY);
+
+ }
+ {
+ u_int32_t flags;
+ flags = !!(capn_read8(p, 6) & (1 << 4));
+ if (flags) peer_flag_set(s, PEER_FLAG_STRICT_CAP_MATCH);
+ else peer_flag_unset(s, PEER_FLAG_STRICT_CAP_MATCH);
+
+ }
+ {
+ u_int32_t flags;
+ flags = !!(capn_read8(p, 6) & (1 << 5));
+ if (flags) peer_flag_set(s, PEER_FLAG_DYNAMIC_CAPABILITY);
+ else peer_flag_unset(s, PEER_FLAG_DYNAMIC_CAPABILITY);
+
+ }
+ {
+ u_int32_t flags;
+ flags = !!(capn_read8(p, 6) & (1 << 6));
+ if (flags) peer_flag_set(s, PEER_FLAG_DISABLE_CONNECTED_CHECK);
+ else peer_flag_unset(s, PEER_FLAG_DISABLE_CONNECTED_CHECK);
+
+ }
+ {
+ int ttl;
+ ttl = capn_read32(p, 20);
+ if (ttl) { peer_ebgp_multihop_set(s, ttl); } else { peer_ebgp_multihop_unset(s); }
+
+ }
+ {
+ /* MISSING: update_source */
+ }
+}
+
+
+as_t qcapn_BGPPeer_get_as(capn_ptr p)
+{
+ capn_resolve(&p);
+ return capn_read32(p, 0);
+}
+
+
+const char * qcapn_BGPPeer_get_host(capn_ptr p)
+{
+ capn_resolve(&p);
+ capn_text tp = capn_get_text(p, 0, capn_val0);; return tp.str;
+}
+
+
+capn_ptr qcapn_new_BGPPeer(struct capn_segment *s)
+{
+ return capn_new_struct(s, 24, 3);
+}
+
+
+
+void qcapn_BGPPeerAfiSafi_read(struct peer *s, capn_ptr p, afi_t afi, safi_t safi)
+{
+ capn_resolve(&p);
+ s->afc[afi][safi] = !!(capn_read8(p, 0) & (1 << 0));
+ { bool tmp;
+ tmp = !!(capn_read8(p, 0) & (1 << 1));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_SEND_COMMUNITY;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_SEND_COMMUNITY;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 0) & (1 << 2));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_SEND_EXT_COMMUNITY;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_SEND_EXT_COMMUNITY;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 0) & (1 << 3));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_NEXTHOP_SELF;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_NEXTHOP_SELF;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 0) & (1 << 4));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_REFLECTOR_CLIENT;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_REFLECTOR_CLIENT;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 0) & (1 << 5));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_RSERVER_CLIENT;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_RSERVER_CLIENT;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 0) & (1 << 6));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_SOFT_RECONFIG;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_SOFT_RECONFIG;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 0) & (1 << 7));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_AS_PATH_UNCHANGED;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_AS_PATH_UNCHANGED;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 1) & (1 << 0));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_NEXTHOP_UNCHANGED;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_NEXTHOP_UNCHANGED;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 1) & (1 << 1));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_MED_UNCHANGED;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_MED_UNCHANGED;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 1) & (1 << 2));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_DEFAULT_ORIGINATE;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_DEFAULT_ORIGINATE;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 1) & (1 << 3));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_REMOVE_PRIVATE_AS;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_REMOVE_PRIVATE_AS;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 1) & (1 << 4));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_ALLOWAS_IN;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_ALLOWAS_IN;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 1) & (1 << 5));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_ORF_PREFIX_SM;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_ORF_PREFIX_SM;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 1) & (1 << 6));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_ORF_PREFIX_RM;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_ORF_PREFIX_RM;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 1) & (1 << 7));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_MAX_PREFIX;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_MAX_PREFIX;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 2) & (1 << 0));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_MAX_PREFIX_WARNING;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_MAX_PREFIX_WARNING;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 2) & (1 << 1));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED;
+ }
+ { bool tmp;
+ tmp = !!(capn_read8(p, 2) & (1 << 2));
+ if (tmp) s->af_flags[afi][safi] |= PEER_FLAG_NEXTHOP_SELF_ALL;
+ else s->af_flags[afi][safi] &= ~PEER_FLAG_NEXTHOP_SELF_ALL;
+ }
+ s->allowas_in[afi][safi] = capn_read8(p, 3);
+}
+
+
+
+void qcapn_BGPPeerAfiSafi_write(const struct peer *s, capn_ptr p, afi_t afi, safi_t safi)
+{
+ capn_resolve(&p);
+ capn_write1(p, 0, s->afc[afi][safi]);
+ capn_write1(p, 1, !!(s->af_flags[afi][safi] & PEER_FLAG_SEND_COMMUNITY));
+ capn_write1(p, 2, !!(s->af_flags[afi][safi] & PEER_FLAG_SEND_EXT_COMMUNITY));
+ capn_write1(p, 3, !!(s->af_flags[afi][safi] & PEER_FLAG_NEXTHOP_SELF));
+ capn_write1(p, 4, !!(s->af_flags[afi][safi] & PEER_FLAG_REFLECTOR_CLIENT));
+ capn_write1(p, 5, !!(s->af_flags[afi][safi] & PEER_FLAG_RSERVER_CLIENT));
+ capn_write1(p, 6, !!(s->af_flags[afi][safi] & PEER_FLAG_SOFT_RECONFIG));
+ capn_write1(p, 7, !!(s->af_flags[afi][safi] & PEER_FLAG_AS_PATH_UNCHANGED));
+ capn_write1(p, 8, !!(s->af_flags[afi][safi] & PEER_FLAG_NEXTHOP_UNCHANGED));
+ capn_write1(p, 9, !!(s->af_flags[afi][safi] & PEER_FLAG_MED_UNCHANGED));
+ capn_write1(p, 10, !!(s->af_flags[afi][safi] & PEER_FLAG_DEFAULT_ORIGINATE));
+ capn_write1(p, 11, !!(s->af_flags[afi][safi] & PEER_FLAG_REMOVE_PRIVATE_AS));
+ capn_write1(p, 12, !!(s->af_flags[afi][safi] & PEER_FLAG_ALLOWAS_IN));
+ capn_write1(p, 13, !!(s->af_flags[afi][safi] & PEER_FLAG_ORF_PREFIX_SM));
+ capn_write1(p, 14, !!(s->af_flags[afi][safi] & PEER_FLAG_ORF_PREFIX_RM));
+ capn_write1(p, 15, !!(s->af_flags[afi][safi] & PEER_FLAG_MAX_PREFIX));
+ capn_write1(p, 16, !!(s->af_flags[afi][safi] & PEER_FLAG_MAX_PREFIX_WARNING));
+ capn_write1(p, 17, !!(s->af_flags[afi][safi] & PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED));
+ capn_write1(p, 18, !!(s->af_flags[afi][safi] & PEER_FLAG_NEXTHOP_SELF_ALL));
+ capn_write8(p, 3, s->allowas_in[afi][safi]);
+}
+
+
+
+void qcapn_BGPPeerAfiSafi_set(struct peer *s, capn_ptr p, afi_t afi, safi_t safi)
+{
+ capn_resolve(&p);
+ {
+ u_char afc;
+ afc = !!(capn_read8(p, 0) & (1 << 0));
+ peer_afc_set(s, afi, safi, afc);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 0) & (1 << 1));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_SEND_COMMUNITY);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_SEND_COMMUNITY);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 0) & (1 << 2));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_SEND_EXT_COMMUNITY);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_SEND_EXT_COMMUNITY);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 0) & (1 << 3));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_NEXTHOP_SELF);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_NEXTHOP_SELF);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 0) & (1 << 4));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_REFLECTOR_CLIENT);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_REFLECTOR_CLIENT);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 0) & (1 << 5));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_RSERVER_CLIENT);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_RSERVER_CLIENT);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 0) & (1 << 6));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_SOFT_RECONFIG);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_SOFT_RECONFIG);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 0) & (1 << 7));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_AS_PATH_UNCHANGED);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_AS_PATH_UNCHANGED);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 1) & (1 << 0));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_NEXTHOP_UNCHANGED);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_NEXTHOP_UNCHANGED);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 1) & (1 << 1));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_MED_UNCHANGED);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_MED_UNCHANGED);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 1) & (1 << 2));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_DEFAULT_ORIGINATE);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_DEFAULT_ORIGINATE);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 1) & (1 << 3));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_REMOVE_PRIVATE_AS);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_REMOVE_PRIVATE_AS);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 1) & (1 << 4));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_ALLOWAS_IN);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_ALLOWAS_IN);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 1) & (1 << 5));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_ORF_PREFIX_SM);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_ORF_PREFIX_SM);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 1) & (1 << 6));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_ORF_PREFIX_RM);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_ORF_PREFIX_RM);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 1) & (1 << 7));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_MAX_PREFIX);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_MAX_PREFIX);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 2) & (1 << 0));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_MAX_PREFIX_WARNING);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_MAX_PREFIX_WARNING);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 2) & (1 << 1));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED);
+
+ }
+ {
+ u_int32_t af_flags;
+ af_flags = !!(capn_read8(p, 2) & (1 << 2));
+ if (af_flags) peer_af_flag_set(s, afi, safi, PEER_FLAG_NEXTHOP_SELF_ALL);
+ else peer_af_flag_unset(s, afi, safi, PEER_FLAG_NEXTHOP_SELF_ALL);
+
+ }
+ {
+ char allowas_in;
+ allowas_in = capn_read8(p, 3);
+ if (allowas_in) { peer_allowas_in_set(s, afi, safi, allowas_in); } else { peer_allowas_in_unset(s, afi, safi); }
+
+ }
+}
+
+
+capn_ptr qcapn_new_BGPPeerAfiSafi(struct capn_segment *s)
+{
+ return capn_new_struct(s, 8, 0);
+}
+
+
+
+void qcapn_BGPVRF_read(struct bgp_vrf *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ *(uint64_t *)s->outbound_rd.val = capn_read64(p, 0);
+ s->outbound_rd.family = AF_UNSPEC;
+ s->outbound_rd.prefixlen = 64;
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 0, 1);
+ capn_list64 listptr = { .p = capn_getp(tmp_p, 0, 1) };
+ size_t listsize = capn_len(listptr);
+ uint64_t buf[listsize];
+ capn_getv64(listptr, 0, buf, listsize);
+ if (s->rt_import)
+ ecommunity_unintern(&s->rt_import);
+ s->rt_import = ecommunity_parse ((uint8_t *)buf, listsize * 8);
+ }
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 1, 1);
+ capn_list64 listptr = { .p = capn_getp(tmp_p, 0, 1) };
+ size_t listsize = capn_len(listptr);
+ uint64_t buf[listsize];
+ capn_getv64(listptr, 0, buf, listsize);
+ if (s->rt_export)
+ ecommunity_unintern(&s->rt_export);
+ s->rt_export = ecommunity_parse ((uint8_t *)buf, listsize * 8);
+ }
+}
+
+
+
+void qcapn_BGPVRF_write(const struct bgp_vrf *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ capn_write64(p, 0, *(uint64_t *)s->outbound_rd.val);
+
+ {
+ capn_ptr tempptr = capn_new_struct(p.seg, 0, 1);
+ size_t size = s->rt_import ? s->rt_import->size : 0;
+ capn_list64 listptr = capn_new_list64(p.seg, size);
+ if (size)
+ capn_setv64(listptr, 0, (uint64_t *)s->rt_import->val, size);
+ capn_setp(tempptr, 0, listptr.p);
+ capn_setp(p, 0, tempptr);
+ }
+
+ {
+ capn_ptr tempptr = capn_new_struct(p.seg, 0, 1);
+ size_t size = s->rt_export ? s->rt_export->size : 0;
+ capn_list64 listptr = capn_new_list64(p.seg, size);
+ if (size)
+ capn_setv64(listptr, 0, (uint64_t *)s->rt_export->val, size);
+ capn_setp(tempptr, 0, listptr.p);
+ capn_setp(p, 1, tempptr);
+ }
+}
+
+
+
+void qcapn_BGPVRF_set(struct bgp_vrf *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ {
+ /* MISSING: outbound_rd */
+ }
+ {
+ struct ecommunity * rt_import;
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 0, 1);
+ capn_list64 listptr = { .p = capn_getp(tmp_p, 0, 1) };
+ size_t listsize = capn_len(listptr);
+ uint64_t buf[listsize];
+ capn_getv64(listptr, 0, buf, listsize);
+ rt_import = ecommunity_parse ((uint8_t *)buf, listsize * 8);
+ }
+ bgp_vrf_rt_import_set(s, rt_import);
+
+ ecommunity_unintern(&rt_import);
+ }
+ {
+ struct ecommunity * rt_export;
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 1, 1);
+ capn_list64 listptr = { .p = capn_getp(tmp_p, 0, 1) };
+ size_t listsize = capn_len(listptr);
+ uint64_t buf[listsize];
+ capn_getv64(listptr, 0, buf, listsize);
+ rt_export = ecommunity_parse ((uint8_t *)buf, listsize * 8);
+ }
+ bgp_vrf_rt_export_set(s, rt_export);
+
+ ecommunity_unintern(&rt_export);
+ }
+}
+
+
+struct prefix_rd qcapn_BGPVRF_get_outbound_rd(capn_ptr p)
+{
+ capn_resolve(&p);
+ struct prefix_rd tp;
+ tp.family = AF_UNSPEC;
+ tp.prefixlen = 64;
+ *(uint64_t *)tp.val = capn_read64(p, 0); return tp;
+}
+
+
+capn_ptr qcapn_new_BGPVRF(struct capn_segment *s)
+{
+ return capn_new_struct(s, 8, 2);
+}
+
+
+
+void qcapn_BGPVRFRoute_read(struct bgp_api_route *s, capn_ptr p)
+{
+ capn_resolve(&p);
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 0, 1);
+ s->prefix.family = AF_INET;
+ s->prefix.prefixlen = capn_read8(tmp_p, 4);
+ s->prefix.prefix.s_addr = htonl(capn_read32(tmp_p, 0));
+ }
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 1, 1);
+ s->nexthop.s_addr = htonl(capn_read32(tmp_p, 0));
+ }
+ s->label = capn_read32(p, 0);
+}
+
+
+
+void qcapn_BGPVRFRoute_write(const struct bgp_api_route *s, capn_ptr p)
+{
+ capn_resolve(&p);
+
+ {
+ capn_ptr tempptr = capn_new_struct(p.seg, 8, 0);
+ capn_write8(tempptr, 4, s->prefix.prefixlen);
+ capn_write32(tempptr, 0, ntohl(s->prefix.prefix.s_addr));
+ capn_setp(p, 0, tempptr);
+ }
+
+ {
+ capn_ptr tempptr = capn_new_struct(p.seg, 8, 0);
+ capn_write32(tempptr, 0, ntohl(s->nexthop.s_addr));
+ capn_setp(p, 1, tempptr);
+ }
+ capn_write32(p, 0, s->label);
+}
+
+
+
+void qcapn_BGPVRFRoute_set(struct bgp_api_route *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ {
+ /* MISSING: prefix */
+ }
+ {
+ /* MISSING: nexthop */
+ }
+ {
+ /* MISSING: label */
+ }
+}
+
+
+capn_ptr qcapn_new_BGPVRFRoute(struct capn_segment *s)
+{
+ return capn_new_struct(s, 8, 2);
+}
+
+
+
+void qcapn_BGPEventVRFRoute_read(struct bgp_event_vrf *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ s->announce = capn_read8(p, 0);
+ *(uint64_t *)s->outbound_rd.val = capn_read64(p, 8);
+ s->outbound_rd.family = AF_UNSPEC;
+ s->outbound_rd.prefixlen = 64;
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 0, 1);
+ s->prefix.family = AF_INET;
+ s->prefix.prefixlen = capn_read8(tmp_p, 4);
+ s->prefix.prefix.s_addr = htonl(capn_read32(tmp_p, 0));
+ }
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 1, 1);
+ s->nexthop.s_addr = htonl(capn_read32(tmp_p, 0));
+ }
+ s->label = capn_read32(p, 4);
+}
+
+
+
+void qcapn_BGPEventVRFRoute_write(const struct bgp_event_vrf *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ capn_write8(p, 0, s->announce);
+ capn_write64(p, 8, *(uint64_t *)s->outbound_rd.val);
+
+ {
+ capn_ptr tempptr = capn_new_struct(p.seg, 8, 0);
+ capn_write8(tempptr, 4, s->prefix.prefixlen);
+ capn_write32(tempptr, 0, ntohl(s->prefix.prefix.s_addr));
+ capn_setp(p, 0, tempptr);
+ }
+
+ {
+ capn_ptr tempptr = capn_new_struct(p.seg, 8, 0);
+ capn_write32(tempptr, 0, ntohl(s->nexthop.s_addr));
+ capn_setp(p, 1, tempptr);
+ }
+ capn_write32(p, 4, s->label);
+}
+
+
+
+void qcapn_BGPEventVRFRoute_set(struct bgp_event_vrf *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ {
+ /* MISSING: announce */
+ }
+ {
+ /* MISSING: outbound_rd */
+ }
+ {
+ /* MISSING: prefix */
+ }
+ {
+ /* MISSING: nexthop */
+ }
+ {
+ /* MISSING: label */
+ }
+}
+
+
+capn_ptr qcapn_new_BGPEventVRFRoute(struct capn_segment *s)
+{
+ return capn_new_struct(s, 16, 2);
+}
+
+
+
+void qcapn_BGPEventShut_read(struct bgp_event_shut *s, capn_ptr p)
+{
+ capn_resolve(&p);
+
+ {
+ capn_ptr tmp_p = capn_getp(p, 0, 1);
+ s->peer.s_addr = htonl(capn_read32(tmp_p, 0));
+ }
+ s->type = capn_read8(p, 0);
+ s->subtype = capn_read8(p, 1);
+}
+
+
+
+void qcapn_BGPEventShut_write(const struct bgp_event_shut *s, capn_ptr p)
+{
+ capn_resolve(&p);
+
+ {
+ capn_ptr tempptr = capn_new_struct(p.seg, 8, 0);
+ capn_write32(tempptr, 0, ntohl(s->peer.s_addr));
+ capn_setp(p, 0, tempptr);
+ }
+ capn_write8(p, 0, s->type);
+ capn_write8(p, 1, s->subtype);
+}
+
+
+
+void qcapn_BGPEventShut_set(struct bgp_event_shut *s, capn_ptr p)
+{
+ capn_resolve(&p);
+ {
+ /* MISSING: peer */
+ }
+ {
+ /* MISSING: type */
+ }
+ {
+ /* MISSING: subtype */
+ }
+}
+
+
+capn_ptr qcapn_new_BGPEventShut(struct capn_segment *s)
+{
+ return capn_new_struct(s, 8, 1);
+}
+
diff --git a/bgpd/bgp.bcapnp.h b/bgpd/bgp.bcapnp.h
new file mode 100644
index 000000000000..fafaf6cce83a
--- /dev/null
+++ b/bgpd/bgp.bcapnp.h
@@ -0,0 +1,56 @@
+/*
+ * derived from GPLv2+ sources
+ */
+#ifndef CAPN_C4C948A17D3B2250
+#define CAPN_C4C948A17D3B2250
+
+
+#include "zebra.h"
+#include "bgpd.h"
+afi_t qcapn_AfiSafiKey_get_afi(capn_ptr p);
+safi_t qcapn_AfiSafiKey_get_safi(capn_ptr p);
+capn_ptr qcapn_new_AfiSafiKey(struct capn_segment *s);
+afi_t qcapn_AfiKey_get_afi(capn_ptr p);
+capn_ptr qcapn_new_AfiKey(struct capn_segment *s);
+void qcapn_VRFTableIter_read(struct tbliter_v4 *s, capn_ptr p);
+void qcapn_VRFTableIter_write(const struct tbliter_v4 *s, capn_ptr p);
+void qcapn_VRFTableIter_set(struct tbliter_v4 *s, capn_ptr p);
+capn_ptr qcapn_new_VRFTableIter(struct capn_segment *s);
+void qcapn_BGP_read(struct bgp *s, capn_ptr p);
+void qcapn_BGP_write(const struct bgp *s, capn_ptr p);
+void qcapn_BGP_set(struct bgp *s, capn_ptr p);
+as_t qcapn_BGP_get_as(capn_ptr p);
+capn_ptr qcapn_new_BGP(struct capn_segment *s);
+void qcapn_BGPAfiSafi_read(struct bgp *s, capn_ptr p, afi_t afi, safi_t safi);
+void qcapn_BGPAfiSafi_write(const struct bgp *s, capn_ptr p, afi_t afi, safi_t safi);
+void qcapn_BGPAfiSafi_set(struct bgp *s, capn_ptr p, afi_t afi, safi_t safi);
+capn_ptr qcapn_new_BGPAfiSafi(struct capn_segment *s);
+void qcapn_BGPPeer_read(struct peer *s, capn_ptr p);
+void qcapn_BGPPeer_write(const struct peer *s, capn_ptr p);
+void qcapn_BGPPeer_set(struct peer *s, capn_ptr p);
+as_t qcapn_BGPPeer_get_as(capn_ptr p);
+const char * qcapn_BGPPeer_get_host(capn_ptr p);
+capn_ptr qcapn_new_BGPPeer(struct capn_segment *s);
+void qcapn_BGPPeerAfiSafi_read(struct peer *s, capn_ptr p, afi_t afi, safi_t safi);
+void qcapn_BGPPeerAfiSafi_write(const struct peer *s, capn_ptr p, afi_t afi, safi_t safi);
+void qcapn_BGPPeerAfiSafi_set(struct peer *s, capn_ptr p, afi_t afi, safi_t safi);
+capn_ptr qcapn_new_BGPPeerAfiSafi(struct capn_segment *s);
+void qcapn_BGPVRF_read(struct bgp_vrf *s, capn_ptr p);
+void qcapn_BGPVRF_write(const struct bgp_vrf *s, capn_ptr p);
+void qcapn_BGPVRF_set(struct bgp_vrf *s, capn_ptr p);
+struct prefix_rd qcapn_BGPVRF_get_outbound_rd(capn_ptr p);
+capn_ptr qcapn_new_BGPVRF(struct capn_segment *s);
+void qcapn_BGPVRFRoute_read(struct bgp_api_route *s, capn_ptr p);
+void qcapn_BGPVRFRoute_write(const struct bgp_api_route *s, capn_ptr p);
+void qcapn_BGPVRFRoute_set(struct bgp_api_route *s, capn_ptr p);
+capn_ptr qcapn_new_BGPVRFRoute(struct capn_segment *s);
+void qcapn_BGPEventVRFRoute_read(struct bgp_event_vrf *s, capn_ptr p);
+void qcapn_BGPEventVRFRoute_write(const struct bgp_event_vrf *s, capn_ptr p);
+void qcapn_BGPEventVRFRoute_set(struct bgp_event_vrf *s, capn_ptr p);
+capn_ptr qcapn_new_BGPEventVRFRoute(struct capn_segment *s);
+void qcapn_BGPEventShut_read(struct bgp_event_shut *s, capn_ptr p);
+void qcapn_BGPEventShut_write(const struct bgp_event_shut *s, capn_ptr p);
+void qcapn_BGPEventShut_set(struct bgp_event_shut *s, capn_ptr p);
+capn_ptr qcapn_new_BGPEventShut(struct capn_segment *s);
+
+#endif /* CAPN_C4C948A17D3B2250 */
diff --git a/bgpd/bgpd.ndef.hi b/bgpd/bgpd.ndef.hi
new file mode 100644
index 000000000000..62af2077b2ed
--- /dev/null
+++ b/bgpd/bgpd.ndef.hi
@@ -0,0 +1,15 @@
+/*
+ * derived from GPLv2+ sources
+ */
+
+/* [3dd958b139b0da5d] bgpd <> bgp_master */
+EXT_QZC_NODETYPE(bgp_master)
+
+/* [3fafaa5ff15d4317] bgp <> bgp */
+EXT_QZC_NODETYPE(bgp)
+
+/* [b7f3d8126eeb7a2b] bgp_peer <> peer */
+EXT_QZC_NODETYPE(peer)
+
+/* [cda67afc021c23cf] bgp_vrf <> bgp_vrf */
+EXT_QZC_NODETYPE(bgp_vrf)
diff --git a/bgpd/bgpd.ndef.i b/bgpd/bgpd.ndef.i
new file mode 100644
index 000000000000..54b5d185aa08
--- /dev/null
+++ b/bgpd/bgpd.ndef.i
@@ -0,0 +1,791 @@
+/*
+ * derived from GPLv2+ sources
+ */
+
+/* [] bgpd:1 <> bgp_master->bgp (bgp)*/
+
+static void
+_qzc_get_bgp_master_1(struct bgp_master *p,
+ struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+ struct QZCNodeList nl;
+ struct list *list = p->bgp;
+ QZCNodeList_ptr cp;
+ static const capn_ptr capn_null = {CAPN_NULL};
+ size_t i;
+
+ if (list) {
+ struct listnode *n = list->head;
+ nl.nodes = capn_new_list64(seg, list->count);
+ for (i = 0; n && i < list->count; i++) {
+ struct bgp *e = (struct bgp *)n->data;
+ n = n->next;
+
+ capn_set64(nl.nodes, i, e->qzc_node.nid);
+ }
+ } else
+ nl.nodes.p = capn_null;
+
+ cp = new_QZCNodeList(seg);
+ write_QZCNodeList(&nl, cp);
+ rep->data = cp.p;
+ rep->datatype = 0x9bb91c45a95a581d;
+}
+
+/* [] bgpd:1 <> bgp_master->bgp (bgp)*/
+
+static void
+_qzc_create_bgp_master_1(struct bgp_master *p,
+ struct QZCCreateReq *req, struct QZCCreateRep *rep,
+ struct capn_segment *seg)
+{
+ struct bgp *ret = NULL;
+ switch (req->datatype) {
+ case 0xfd0316f1800ae916:
+ {
+ as_t as = qcapn_BGP_get_as(req->data);
+ ret = bgp_create_api(p, as);
+ }
+ }
+ if (ret)
+ rep->newnid = ret->qzc_node.nid;
+}
+
+/* [3dd958b139b0da5d] bgpd <> bgp_master */
+static void
+_qzc_get_bgp_master(void *entity, struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+ struct bgp_master *p;
+ p = (struct bgp_master *)entity;
+ switch (req->elem) {
+ case 1:
+ _qzc_get_bgp_master_1(p, req, rep, seg);
+ return;
+ default:
+ return;
+ }
+}
+static void
+_qzc_createchild_bgp_master(void *entity,
+ struct QZCCreateReq *req, struct QZCCreateRep *rep,
+ struct capn_segment *seg)
+{
+ struct bgp_master *p;
+ p = (struct bgp_master *)entity;
+ switch (req->parentelem) {
+ case 1:
+ _qzc_create_bgp_master_1(p, req, rep, seg);
+ return;
+ default:
+ return;
+ }
+}
+
+struct qzc_nodetype qzc_t_bgp_master = {
+ .tid = 0x3dd958b139b0da5d,
+ .node_member_offset = (ptrdiff_t)offsetof(struct bgp_master, qzc_node),
+ .get = _qzc_get_bgp_master,
+ .createchild = _qzc_createchild_bgp_master,
+};
+/* WKN 37b64fdb20888a50 */
+static uint64_t _wknresolve_37b64fdb20888a50(void)
+{
+ struct bgp_master *elem = bm;
+ if (!elem)
+ return 0;
+ return elem->qzc_node.nid;
+}
+static struct qzc_wkn _wkn_37b64fdb20888a50 = {
+ .wid = 0x37b64fdb20888a50,
+ .resolve = _wknresolve_37b64fdb20888a50,
+};
+static void _wkninit_37b64fdb20888a50(void) __attribute__ ((constructor));
+static void _wkninit_37b64fdb20888a50(void)
+{
+ qzc_wkn_reg(&_wkn_37b64fdb20888a50);
+};
+
+/* [] bgp:1 <> bgp */
+
+static void
+_qzc_get_bgp_1(struct bgp *p,
+ struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+
+ if (req->ctxtype != 0)
+ /* error */
+ return;
+
+
+ rep->data = qcapn_new_BGP(seg);
+ qcapn_BGP_write(p, rep->data);
+ rep->datatype = 0xfd0316f1800ae916;
+}
+
+/* [] bgp:2 <> bgp->peer (peer)*/
+
+static void
+_qzc_get_bgp_2(struct bgp *p,
+ struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+ struct QZCNodeList nl;
+ struct list *list = p->peer;
+ QZCNodeList_ptr cp;
+ static const capn_ptr capn_null = {CAPN_NULL};
+ size_t i;
+
+ if (list) {
+ struct listnode *n = list->head;
+ nl.nodes = capn_new_list64(seg, list->count);
+ for (i = 0; n && i < list->count; i++) {
+ struct peer *e = (struct peer *)n->data;
+ n = n->next;
+
+ capn_set64(nl.nodes, i, e->qzc_node.nid);
+ }
+ } else
+ nl.nodes.p = capn_null;
+
+ cp = new_QZCNodeList(seg);
+ write_QZCNodeList(&nl, cp);
+ rep->data = cp.p;
+ rep->datatype = 0x9bb91c45a95a581d;
+}
+
+/* [] bgp:3 <> bgp->vrfs (bgp_vrf)*/
+
+static void
+_qzc_get_bgp_3(struct bgp *p,
+ struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+ struct QZCNodeList nl;
+ struct list *list = p->vrfs;
+ QZCNodeList_ptr cp;
+ static const capn_ptr capn_null = {CAPN_NULL};
+ size_t i;
+
+ if (list) {
+ struct listnode *n = list->head;
+ nl.nodes = capn_new_list64(seg, list->count);
+ for (i = 0; n && i < list->count; i++) {
+ struct bgp_vrf *e = (struct bgp_vrf *)n->data;
+ n = n->next;
+
+ capn_set64(nl.nodes, i, e->qzc_node.nid);
+ }
+ } else
+ nl.nodes.p = capn_null;
+
+ cp = new_QZCNodeList(seg);
+ write_QZCNodeList(&nl, cp);
+ rep->data = cp.p;
+ rep->datatype = 0x9bb91c45a95a581d;
+}
+
+/* [] bgp:2 <> bgp->peer (peer)*/
+
+static void
+_qzc_create_bgp_2(struct bgp *p,
+ struct QZCCreateReq *req, struct QZCCreateRep *rep,
+ struct capn_segment *seg)
+{
+ struct peer *ret = NULL;
+ switch (req->datatype) {
+ case 0xd1f1619cff93fcb9:
+ {
+ const char * host = qcapn_BGPPeer_get_host(req->data);
+ as_t as = qcapn_BGPPeer_get_as(req->data);
+ ret = peer_create_api(p, host, as);
+ }
+ }
+ if (ret)
+ rep->newnid = ret->qzc_node.nid;
+}
+
+/* [] bgp:3 <> bgp->vrfs (bgp_vrf)*/
+
+static void
+_qzc_create_bgp_3(struct bgp *p,
+ struct QZCCreateReq *req, struct QZCCreateRep *rep,
+ struct capn_segment *seg)
+{
+ struct bgp_vrf *ret = NULL;
+ switch (req->datatype) {
+ case 0x912c4b0c412022b1:
+ {
+ struct prefix_rd outbound_rd = qcapn_BGPVRF_get_outbound_rd(req->data);
+ ret = bgp_vrf_update_rd(p, NULL, &outbound_rd);
+ }
+ }
+ if (ret)
+ rep->newnid = ret->qzc_node.nid;
+}
+
+/* [] bgp:1 <> bgp */
+
+static void
+_qzc_set_bgp_1(struct bgp *p,
+ struct QZCSetReq *req,
+ struct capn_segment *seg)
+{
+
+ if (req->ctxtype != 0)
+ /* error */
+ return;
+
+
+ if (req->datatype != 0xfd0316f1800ae916)
+ /* error */
+ return;
+
+ qcapn_BGP_set(p, req->data);
+}
+
+/* [3fafaa5ff15d4317] bgp <> bgp */
+static void
+_qzc_get_bgp(void *entity, struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+ struct bgp *p;
+ p = (struct bgp *)entity;
+ switch (req->elem) {
+ case 1:
+ _qzc_get_bgp_1(p, req, rep, seg);
+ return;
+ case 2:
+ _qzc_get_bgp_2(p, req, rep, seg);
+ return;
+ case 3:
+ _qzc_get_bgp_3(p, req, rep, seg);
+ return;
+ default:
+ return;
+ }
+}
+static void
+_qzc_createchild_bgp(void *entity,
+ struct QZCCreateReq *req, struct QZCCreateRep *rep,
+ struct capn_segment *seg)
+{
+ struct bgp *p;
+ p = (struct bgp *)entity;
+ switch (req->parentelem) {
+ case 2:
+ _qzc_create_bgp_2(p, req, rep, seg);
+ return;
+ case 3:
+ _qzc_create_bgp_3(p, req, rep, seg);
+ return;
+ default:
+ return;
+ }
+}
+static void
+_qzc_set_bgp(void *entity,
+ struct QZCSetReq *req,
+ struct capn_segment *seg)
+{
+ struct bgp *p;
+ p = (struct bgp *)entity;
+ switch (req->elem) {
+ case 1:
+ _qzc_set_bgp_1(p, req, seg);
+ return;
+ default:
+ return;
+ }
+}
+static void
+_qzc_destroy_bgp(void *entity,
+ struct QZCDelReq *req,
+ struct capn_segment *seg)
+{
+ struct bgp *p;
+ p = (struct bgp *)entity;
+ bgp_delete(p);
+}
+
+struct qzc_nodetype qzc_t_bgp = {
+ .tid = 0x3fafaa5ff15d4317,
+ .node_member_offset = (ptrdiff_t)offsetof(struct bgp, qzc_node),
+ .get = _qzc_get_bgp,
+ .createchild = _qzc_createchild_bgp,
+ .set = _qzc_set_bgp,
+ .destroy = _qzc_destroy_bgp,
+};
+/* WKN ee130f407472b15a */
+static uint64_t _wknresolve_ee130f407472b15a(void)
+{
+ struct bgp *elem = bgp_get_default();
+ if (!elem)
+ return 0;
+ return elem->qzc_node.nid;
+}
+static struct qzc_wkn _wkn_ee130f407472b15a = {
+ .wid = 0xee130f407472b15a,
+ .resolve = _wknresolve_ee130f407472b15a,
+};
+static void _wkninit_ee130f407472b15a(void) __attribute__ ((constructor));
+static void _wkninit_ee130f407472b15a(void)
+{
+ qzc_wkn_reg(&_wkn_ee130f407472b15a);
+};
+
+/* [] bgp_peer:2 <> peer */
+
+static void
+_qzc_get_peer_2(struct peer *p,
+ struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+
+ if (req->ctxtype != 0)
+ /* error */
+ return;
+
+
+ rep->data = qcapn_new_BGPPeer(seg);
+ qcapn_BGPPeer_write(p, rep->data);
+ rep->datatype = 0xd1f1619cff93fcb9;
+}
+
+/* [] bgp_peer:3 <> peer */
+
+static void
+_qzc_get_peer_3(struct peer *p,
+ struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+ afi_t afi;
+ safi_t safi;
+
+ if (req->ctxtype != 0x9af9aec34821d76a)
+ /* error */
+ return;
+
+ afi = qcapn_AfiSafiKey_get_afi (req->ctxdata);
+ safi = qcapn_AfiSafiKey_get_safi (req->ctxdata);
+
+ rep->data = qcapn_new_BGPPeerAfiSafi(seg);
+ qcapn_BGPPeerAfiSafi_write(p, rep->data, afi, safi);
+ rep->datatype = 0x8a3b3cd8d134cad1;
+}
+
+/* [] bgp_peer:2 <> peer */
+
+static void
+_qzc_set_peer_2(struct peer *p,
+ struct QZCSetReq *req,
+ struct capn_segment *seg)
+{
+
+ if (req->ctxtype != 0)
+ /* error */
+ return;
+
+
+ if (req->datatype != 0xd1f1619cff93fcb9)
+ /* error */
+ return;
+
+ qcapn_BGPPeer_set(p, req->data);
+}
+
+/* [] bgp_peer:3 <> peer */
+
+static void
+_qzc_set_peer_3(struct peer *p,
+ struct QZCSetReq *req,
+ struct capn_segment *seg)
+{
+ afi_t afi;
+ safi_t safi;
+
+ if (req->ctxtype != 0x9af9aec34821d76a)
+ /* error */
+ return;
+
+ afi = qcapn_AfiSafiKey_get_afi (req->ctxdata);
+ safi = qcapn_AfiSafiKey_get_safi (req->ctxdata);
+
+ if (req->datatype != 0x8a3b3cd8d134cad1)
+ /* error */
+ return;
+
+ qcapn_BGPPeerAfiSafi_set(p, req->data, afi, safi);
+}
+
+/* [b7f3d8126eeb7a2b] bgp_peer <> peer */
+static void
+_qzc_get_peer(void *entity, struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+ struct peer *p;
+ p = (struct peer *)entity;
+ switch (req->elem) {
+ case 2:
+ _qzc_get_peer_2(p, req, rep, seg);
+ return;
+ case 3:
+ _qzc_get_peer_3(p, req, rep, seg);
+ return;
+ default:
+ return;
+ }
+}
+static void
+_qzc_set_peer(void *entity,
+ struct QZCSetReq *req,
+ struct capn_segment *seg)
+{
+ struct peer *p;
+ p = (struct peer *)entity;
+ switch (req->elem) {
+ case 2:
+ _qzc_set_peer_2(p, req, seg);
+ return;
+ case 3:
+ _qzc_set_peer_3(p, req, seg);
+ return;
+ default:
+ return;
+ }
+}
+static void
+_qzc_destroy_peer(void *entity,
+ struct QZCDelReq *req,
+ struct capn_segment *seg)
+{
+ struct peer *p;
+ p = (struct peer *)entity;
+ peer_delete(p);
+}
+
+struct qzc_nodetype qzc_t_peer = {
+ .tid = 0xb7f3d8126eeb7a2b,
+ .node_member_offset = (ptrdiff_t)offsetof(struct peer, qzc_node),
+ .get = _qzc_get_peer,
+ .set = _qzc_set_peer,
+ .destroy = _qzc_destroy_peer,
+};
+/* [] bgp_vrf:1 <> bgp_vrf */
+
+static void
+_qzc_get_bgp_vrf_1(struct bgp_vrf *p,
+ struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+
+ if (req->ctxtype != 0)
+ /* error */
+ return;
+
+
+ rep->data = qcapn_new_BGPVRF(seg);
+ qcapn_BGPVRF_write(p, rep->data);
+ rep->datatype = 0x912c4b0c412022b1;
+}
+
+static struct bgp_node * qcap_iter_bgp_vrf_rib(struct bgp_table *table,
+ const struct tbliter_v4 *prev_iter,
+ struct tbliter_v4 *next_iter,
+ bool *hasnext)
+{
+ struct bgp_node *bn;
+ if (!prev_iter) {
+ bn = bgp_table_top_nolock (table);
+ } else {
+ bn = bgp_table_get_next (table, (struct prefix *)&prev_iter->prefix);
+ if (bn)
+ bgp_unlock_node(bn);
+ }
+ if (bn) {
+ prefix_copy ((struct prefix *)&next_iter->prefix, &bn->p);
+ *hasnext = true;
+ } else
+ *hasnext = false;
+ return bn;
+}
+
+
+/* Iterated GET bgp_vrf:2 <> bgp_vrf->rib ()*/
+
+static void
+_qzc_get_bgp_vrf_2(struct bgp_vrf *p,
+ struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+ struct bgp_table * table;
+ struct tbliter_v4 iter, nextiter;
+ const struct tbliter_v4 *iterptr;
+ afi_t afi;
+
+ if (req->ctxtype != 0xac25a73c3ff455c0)
+ /* error */
+ return;
+
+ afi = qcapn_AfiKey_get_afi (req->ctxdata);
+ table = p->rib[afi];
+
+ if (req->itertype == 0xeb8ab4f58b7753ee) {
+ qcapn_VRFTableIter_read(&iter, req->iterdata);
+ iterptr = &iter;
+ } else if (req->itertype == 0) {
+ iterptr = NULL;
+ } else {
+ /* error */
+ return;
+ }
+
+ bool hasnext = false;
+ struct bgp_node * val = qcap_iter_bgp_vrf_rib(table, iterptr, &nextiter, &hasnext);
+
+ if (hasnext) {
+ rep->itertype = 0xeb8ab4f58b7753ee;
+ rep->nextiter = qcapn_new_VRFTableIter(seg);
+ qcapn_VRFTableIter_write(&nextiter, rep->nextiter);
+ } else
+ rep->itertype = 0;
+
+ rep->datatype = 0;
+ if (val) {
+ struct bgp_api_route *outptr;
+ struct bgp_api_route tmpval;
+ if (!bgp_api_route_get(&tmpval, val))
+ return;
+ outptr = &tmpval;
+ rep->data = qcapn_new_BGPVRFRoute(seg);
+ qcapn_BGPVRFRoute_write(outptr, rep->data);
+ rep->datatype = 0x8f217eb4bad6c06f;
+ }
+}
+
+
+
+static struct bgp_node * qcap_iter_bgp_vrf_route(struct bgp_table *table,
+ const struct tbliter_v4 *prev_iter,
+ struct tbliter_v4 *next_iter,
+ bool *hasnext)
+{
+ struct bgp_node *bn;
+ if (!prev_iter) {
+ bn = bgp_table_top_nolock (table);
+ } else {
+ bn = bgp_table_get_next (table, (struct prefix *)&prev_iter->prefix);
+ if (bn)
+ bgp_unlock_node(bn);
+ }
+ if (bn) {
+ prefix_copy ((struct prefix *)&next_iter->prefix, &bn->p);
+ *hasnext = true;
+ } else
+ *hasnext = false;
+ return bn;
+}
+
+
+/* Iterated GET bgp_vrf:3 <> bgp_vrf->route ()*/
+
+static void
+_qzc_get_bgp_vrf_3(struct bgp_vrf *p,
+ struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+ struct bgp_table * table;
+ struct tbliter_v4 iter, nextiter;
+ const struct tbliter_v4 *iterptr;
+ afi_t afi;
+
+ if (req->ctxtype != 0xac25a73c3ff455c0)
+ /* error */
+ return;
+
+ afi = qcapn_AfiKey_get_afi (req->ctxdata);
+ table = p->route[afi];
+
+ if (req->itertype == 0xeb8ab4f58b7753ee) {
+ qcapn_VRFTableIter_read(&iter, req->iterdata);
+ iterptr = &iter;
+ } else if (req->itertype == 0) {
+ iterptr = NULL;
+ } else {
+ /* error */
+ return;
+ }
+
+ bool hasnext = false;
+ struct bgp_node * val = qcap_iter_bgp_vrf_route(table, iterptr, &nextiter, &hasnext);
+
+ if (hasnext) {
+ rep->itertype = 0xeb8ab4f58b7753ee;
+ rep->nextiter = qcapn_new_VRFTableIter(seg);
+ qcapn_VRFTableIter_write(&nextiter, rep->nextiter);
+ } else
+ rep->itertype = 0;
+
+ rep->datatype = 0;
+ if (val) {
+ struct bgp_api_route *outptr;
+ struct bgp_api_route tmpval;
+ if (!bgp_api_static_get(&tmpval, val))
+ return;
+ outptr = &tmpval;
+ rep->data = qcapn_new_BGPVRFRoute(seg);
+ qcapn_BGPVRFRoute_write(outptr, rep->data);
+ rep->datatype = 0x8f217eb4bad6c06f;
+ }
+}
+
+
+
+/* [] bgp_vrf:1 <> bgp_vrf */
+
+static void
+_qzc_set_bgp_vrf_1(struct bgp_vrf *p,
+ struct QZCSetReq *req,
+ struct capn_segment *seg)
+{
+
+ if (req->ctxtype != 0)
+ /* error */
+ return;
+
+
+ if (req->datatype != 0x912c4b0c412022b1)
+ /* error */
+ return;
+
+ qcapn_BGPVRF_set(p, req->data);
+}
+
+/* Iterated item SET bgp_vrf:3 <> bgp_vrf-> ()*/
+
+static void
+_qzc_set_bgp_vrf_3(struct bgp_vrf *p,
+ struct QZCSetReq *req,
+ struct capn_segment *seg)
+{
+ afi_t afi;
+
+ if (req->ctxtype != 0xac25a73c3ff455c0)
+ /* error */
+ return;
+
+ afi = qcapn_AfiKey_get_afi (req->ctxdata);
+
+ if (req->datatype != 0x8f217eb4bad6c06f)
+ /* error */
+ return;
+
+ struct bgp_api_route data;
+ qcapn_BGPVRFRoute_read(&data, req->data);
+
+ bgp_vrf_static_set(p, afi, &data);
+}
+
+
+
+/* Iterated item SET bgp_vrf:3 <> bgp_vrf-> ()*/
+
+static void
+_qzc_unset_bgp_vrf_3(struct bgp_vrf *p,
+ struct QZCSetReq *req,
+ struct capn_segment *seg)
+{
+ afi_t afi;
+
+ if (req->ctxtype != 0xac25a73c3ff455c0)
+ /* error */
+ return;
+
+ afi = qcapn_AfiKey_get_afi (req->ctxdata);
+
+ if (req->datatype != 0x8f217eb4bad6c06f)
+ /* error */
+ return;
+
+ struct bgp_api_route data;
+ qcapn_BGPVRFRoute_read(&data, req->data);
+
+ bgp_vrf_static_unset(p, afi, &data);
+}
+
+
+
+/* [cda67afc021c23cf] bgp_vrf <> bgp_vrf */
+static void
+_qzc_get_bgp_vrf(void *entity, struct QZCGetReq *req, struct QZCGetRep *rep,
+ struct capn_segment *seg)
+{
+ struct bgp_vrf *p;
+ p = (struct bgp_vrf *)entity;
+ switch (req->elem) {
+ case 1:
+ _qzc_get_bgp_vrf_1(p, req, rep, seg);
+ return;
+ case 2:
+ _qzc_get_bgp_vrf_2(p, req, rep, seg);
+ return;
+ case 3:
+ _qzc_get_bgp_vrf_3(p, req, rep, seg);
+ return;
+ default:
+ return;
+ }
+}
+static void
+_qzc_set_bgp_vrf(void *entity,
+ struct QZCSetReq *req,
+ struct capn_segment *seg)
+{
+ struct bgp_vrf *p;
+ p = (struct bgp_vrf *)entity;
+ switch (req->elem) {
+ case 1:
+ _qzc_set_bgp_vrf_1(p, req, seg);
+ return;
+ case 3:
+ _qzc_set_bgp_vrf_3(p, req, seg);
+ return;
+ default:
+ return;
+ }
+}
+static void
+_qzc_unset_bgp_vrf(void *entity,
+ struct QZCSetReq *req,
+ struct capn_segment *seg)
+{
+ struct bgp_vrf *p;
+ p = (struct bgp_vrf *)entity;
+ switch (req->elem) {
+ case 3:
+ _qzc_unset_bgp_vrf_3(p, req, seg);
+ return;
+ default:
+ return;
+ }
+}
+static void
+_qzc_destroy_bgp_vrf(void *entity,
+ struct QZCDelReq *req,
+ struct capn_segment *seg)
+{
+ struct bgp_vrf *p;
+ p = (struct bgp_vrf *)entity;
+ bgp_vrf_delete(p);
+}
+
+struct qzc_nodetype qzc_t_bgp_vrf = {
+ .tid = 0xcda67afc021c23cf,
+ .node_member_offset = (ptrdiff_t)offsetof(struct bgp_vrf, qzc_node),
+ .get = _qzc_get_bgp_vrf,
+ .set = _qzc_set_bgp_vrf,
+ .unset = _qzc_unset_bgp_vrf,
+ .destroy = _qzc_destroy_bgp_vrf,
+};
--
2.1.4


_______________________________________________
Quagga-dev mailing list
Quagga-dev@lists.quagga.net
https://lists.quagga.net/mailman/listinfo/quagga-dev