/usr/src/usr.sbin/bgpd/rde.c

Bug Summary

File:	src/usr.sbin/bgpd/rde.c
Warning:	line 348, column 9 Use of memory after it is freed
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name rde.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.sbin/bgpd/obj -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/usr.sbin/bgpd -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.sbin/bgpd/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/usr.sbin/bgpd/rde.c
1/*	$OpenBSD: rde.c,v 1.613 2023/12/14 13:52:37 claudio Exp $ */

3/*
* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
* Copyright (c) 2016 Job Snijders <job@instituut.net>
* Copyright (c) 2016 Peter Hessler <phessler@openbsd.org>
* Copyright (c) 2018 Sebastian Benoit <benno@openbsd.org>
*
* 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.
*/

22#include <sys/types.h>
23#include <sys/time.h>
24#include <sys/resource.h>

26#include <errno(*__errno()).h>
27#include <pwd.h>
28#include <poll.h>
29#include <signal.h>
30#include <stdio.h>
31#include <stdlib.h>
32#include <string.h>
33#include <syslog.h>
34#include <unistd.h>

36#include "bgpd.h"
37#include "session.h"
38#include "rde.h"
39#include "log.h"

41#define PFD_PIPE_MAIN0		0
42#define PFD_PIPE_SESSION1	1
43#define PFD_PIPE_SESSION_CTL2	2
44#define PFD_PIPE_ROA3		3
45#define PFD_PIPE_COUNT4		4

47void		 rde_sighdlr(int);
48void		 rde_dispatch_imsg_session(struct imsgbuf *);
49void		 rde_dispatch_imsg_parent(struct imsgbuf *);
50void		 rde_dispatch_imsg_rtr(struct imsgbuf *);
51void		 rde_dispatch_imsg_peer(struct rde_peer *, void *);
52void		 rde_update_dispatch(struct rde_peer *, struct imsg *);
53int		 rde_update_update(struct rde_peer *, uint32_t,
    struct filterstate *, struct bgpd_addr *, uint8_t);
55void		 rde_update_withdraw(struct rde_peer *, uint32_t,
    struct bgpd_addr *, uint8_t);
57int		 rde_attr_parse(u_char *, uint16_t, struct rde_peer *,
    struct filterstate *, struct mpattr *);
59int		 rde_attr_add(struct filterstate *, u_char *, uint16_t);
60uint8_t		 rde_attr_missing(struct rde_aspath *, int, uint16_t);
61int		 rde_get_mp_nexthop(u_char *, uint16_t, uint8_t,
    struct rde_peer *, struct filterstate *);
63void		 rde_as4byte_fixup(struct rde_peer *, struct rde_aspath *);
64uint8_t		 rde_aspa_validity(struct rde_peer *, struct rde_aspath *,
    uint8_t);
66void		 rde_reflector(struct rde_peer *, struct rde_aspath *);

68void		 rde_dump_ctx_new(struct ctl_show_rib_request *, pid_t,
    enum imsg_type);
70void		 rde_dump_ctx_throttle(pid_t, int);
71void		 rde_dump_ctx_terminate(pid_t);
72void		 rde_dump_mrt_new(struct mrt *, pid_t, int);

74int		 rde_l3vpn_import(struct rde_community *, struct l3vpn *);
75static void	 rde_commit_pftable(void);
76void		 rde_reload_done(void);
77static void	 rde_softreconfig_in_done(void *, uint8_t);
78static void	 rde_softreconfig_out_done(void *, uint8_t);
79static void	 rde_softreconfig_done(void);
80static void	 rde_softreconfig_out(struct rib_entry *, void *);
81static void	 rde_softreconfig_in(struct rib_entry *, void *);
82static void	 rde_softreconfig_sync_reeval(struct rib_entry *, void *);
83static void	 rde_softreconfig_sync_fib(struct rib_entry *, void *);
84static void	 rde_softreconfig_sync_done(void *, uint8_t);
85static void	 rde_rpki_reload(void);
86static int	 rde_roa_reload(void);
87static int	 rde_aspa_reload(void);
88int		 rde_update_queue_pending(void);
89void		 rde_update_queue_runner(uint8_t);
90struct rde_prefixset *rde_find_prefixset(char *, struct rde_prefixset_head *);
91void		 rde_mark_prefixsets_dirty(struct rde_prefixset_head *,
    struct rde_prefixset_head *);
93uint8_t		 rde_roa_validity(struct rde_prefixset *,
    struct bgpd_addr *, uint8_t, uint32_t);

96static void	 rde_peer_recv_eor(struct rde_peer *, uint8_t);
97static void	 rde_peer_send_eor(struct rde_peer *, uint8_t);

99void		 network_add(struct network_config *, struct filterstate *);
100void		 network_delete(struct network_config *);
101static void	 network_dump_upcall(struct rib_entry *, void *);
102static void	 network_flush_upcall(struct rib_entry *, void *);

104void		 flowspec_add(struct flowspec *, struct filterstate *,
    struct filter_set_head *);
106void		 flowspec_delete(struct flowspec *);
107static void	 flowspec_flush_upcall(struct rib_entry *, void *);
108static void	 flowspec_dump_upcall(struct rib_entry *, void *);
109static void	 flowspec_dump_done(void *, uint8_t);

111void		 rde_shutdown(void);
112static int	 ovs_match(struct prefix *, uint32_t);
113static int	 avs_match(struct prefix *, uint32_t);

115static struct imsgbuf		*ibuf_se;
116static struct imsgbuf		*ibuf_se_ctl;
117static struct imsgbuf		*ibuf_rtr;
118static struct imsgbuf		*ibuf_main;
119static struct bgpd_config	*conf, *nconf;
120static struct rde_prefixset	 rde_roa, roa_new;
121static struct rde_aspa		*rde_aspa, *aspa_new;
122static uint8_t			 rde_aspa_generation;

124volatile sig_atomic_t	 rde_quit = 0;
125struct filter_head	*out_rules, *out_rules_tmp;
126struct rde_memstats	 rdemem;
127int			 softreconfig;
128static int		 rde_eval_all;

130extern struct peer_tree	 peertable;
131extern struct rde_peer	*peerself;

133struct rde_dump_ctx {
LIST_ENTRY(rde_dump_ctx)struct { struct rde_dump_ctx *le_next; struct rde_dump_ctx **
le_prev; }	entry;
struct ctl_show_rib_request	req;
uint32_t			peerid;
uint8_t				throttled;
138};

140LIST_HEAD(, rde_dump_ctx)struct { struct rde_dump_ctx *lh_first; } rde_dump_h = LIST_HEAD_INITIALIZER(rde_dump_h){ ((void *)0) };

142struct rde_mrt_ctx {
LIST_ENTRY(rde_mrt_ctx)struct { struct rde_mrt_ctx *le_next; struct rde_mrt_ctx **le_prev
; }	entry;
struct mrt		mrt;
145};

147LIST_HEAD(, rde_mrt_ctx)struct { struct rde_mrt_ctx *lh_first; } rde_mrts = LIST_HEAD_INITIALIZER(rde_mrts){ ((void *)0) };
148u_int rde_mrt_cnt;

150void
151rde_sighdlr(int sig)
152{
switch (sig) {
case SIGINT2:
case SIGTERM15:
rde_quit = 1;
break;
}
159}

161void
162rde_main(int debug, int verbose)
163{
struct passwd		*pw;
struct pollfd		*pfd = NULL((void *)0);
struct rde_mrt_ctx	*mctx, *xmctx;
void			*newp;
u_int			 pfd_elms = 0, i, j;
int			 timeout;
uint8_t			 aid;

log_init(debug, LOG_DAEMON(3<<3));
log_setverbose(verbose);

log_procinit(log_procnames[PROC_RDE]);

if ((pw = getpwnam(BGPD_USER"_bgpd")) == NULL((void *)0))
1
Assuming the condition is false→
2
←
Taking false branch→
fatal("getpwnam");

if (chroot(pw->pw_dir) == -1)
3
←
Assuming the condition is false→
4
←
Taking false branch→
fatal("chroot");
if (chdir("/") == -1)
5
←
Assuming the condition is false→
6
←
Taking false branch→
fatal("chdir(\"/\")");

setproctitle("route decision engine");

if (setgroups(1, &pw->pw_gid) ||
7
←
Assuming the condition is false→
10
←
Taking false branch→
   setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
8
←
Assuming the condition is false→
   setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
9
←
Assuming the condition is false→
fatal("can't drop privileges");

if (pledge("stdio recvfd", NULL((void *)0)) == -1)
11
←
Assuming the condition is false→
12
←
Taking false branch→
fatal("pledge");

signal(SIGTERM15, rde_sighdlr);
signal(SIGINT2, rde_sighdlr);
signal(SIGPIPE13, SIG_IGN(void (*)(int))1);
signal(SIGHUP1, SIG_IGN(void (*)(int))1);
signal(SIGALRM14, SIG_IGN(void (*)(int))1);
signal(SIGUSR130, SIG_IGN(void (*)(int))1);

if ((ibuf_main = malloc(sizeof(struct imsgbuf))) == NULL((void *)0))
13
←
Assuming the condition is false→
14
←
Taking false branch→
fatal(NULL((void *)0));
imsg_init(ibuf_main, 3);

/* initialize the RIB structures */
if ((out_rules = calloc(1, sizeof(struct filter_head))) == NULL((void *)0))
15
←
Assuming the condition is false→
16
←
Taking false branch→
fatal(NULL((void *)0));
TAILQ_INIT(out_rules)do { (out_rules)->tqh_first = ((void *)0); (out_rules)->
tqh_last = &(out_rules)->tqh_first; } while (0);
17
←
Loop condition is false.  Exiting loop→

pt_init();
peer_init(out_rules);

/* make sure the default RIBs are setup */
rib_new("Adj-RIB-In", 0, F_RIB_NOFIB0x0004 | F_RIB_NOEVALUATE0x0002);

conf = new_config();
log_info("route decision engine ready");

while (rde_quit == 0) {
18
←
Assuming 'rde_quit' is not equal to 0→
19
←
Loop condition is false. Execution continues on line 320→
if (pfd_elms < PFD_PIPE_COUNT4 + rde_mrt_cnt) {
	if ((newp = reallocarray(pfd,
	    PFD_PIPE_COUNT4 + rde_mrt_cnt,
	    sizeof(struct pollfd))) == NULL((void *)0)) {
		/* panic for now  */
		log_warn("could not resize pfd from %u -> %u"
		    " entries", pfd_elms, PFD_PIPE_COUNT4 +
		    rde_mrt_cnt);
		fatalx("exiting");
	}
	pfd = newp;
	pfd_elms = PFD_PIPE_COUNT4 + rde_mrt_cnt;
}
timeout = -1;
memset(pfd, 0, sizeof(struct pollfd) * pfd_elms);

set_pollfd(&pfd[PFD_PIPE_MAIN0], ibuf_main);
set_pollfd(&pfd[PFD_PIPE_SESSION1], ibuf_se);
set_pollfd(&pfd[PFD_PIPE_SESSION_CTL2], ibuf_se_ctl);
set_pollfd(&pfd[PFD_PIPE_ROA3], ibuf_rtr);

i = PFD_PIPE_COUNT4;
for (mctx = LIST_FIRST(&rde_mrts)((&rde_mrts)->lh_first); mctx != 0; mctx = xmctx) {
	xmctx = LIST_NEXT(mctx, entry)((mctx)->entry.le_next);

	if (i >= pfd_elms)
		fatalx("poll pfd too small");
	if (mctx->mrt.wbuf.queued) {
		pfd[i].fd = mctx->mrt.wbuf.fd;
		pfd[i].events = POLLOUT0x0004;
		i++;
	} else if (mctx->mrt.state == MRT_STATE_REMOVE) {
		close(mctx->mrt.wbuf.fd);
		LIST_REMOVE(mctx, entry)do { if ((mctx)->entry.le_next != ((void *)0)) (mctx)->
entry.le_next->entry.le_prev = (mctx)->entry.le_prev; *
(mctx)->entry.le_prev = (mctx)->entry.le_next; ; ; } while
 (0);
		free(mctx);
		rde_mrt_cnt--;
	}
}

if (peer_imsg_pending() || rde_update_queue_pending() ||
    nexthop_pending() || rib_dump_pending())
	timeout = 0;

if (poll(pfd, i, timeout) == -1) {
	if (errno(*__errno()) == EINTR4)
		continue;
	fatal("poll error");
}

if (handle_pollfd(&pfd[PFD_PIPE_MAIN0], ibuf_main) == -1)
	fatalx("Lost connection to parent");
else
	rde_dispatch_imsg_parent(ibuf_main);

if (handle_pollfd(&pfd[PFD_PIPE_SESSION1], ibuf_se) == -1) {
	log_warnx("RDE: Lost connection to SE");
	msgbuf_clear(&ibuf_se->w);
	free(ibuf_se);
	ibuf_se = NULL((void *)0);
} else
	rde_dispatch_imsg_session(ibuf_se);

if (handle_pollfd(&pfd[PFD_PIPE_SESSION_CTL2], ibuf_se_ctl) ==
    -1) {
	log_warnx("RDE: Lost connection to SE control");
	msgbuf_clear(&ibuf_se_ctl->w);
	free(ibuf_se_ctl);
	ibuf_se_ctl = NULL((void *)0);
} else
	rde_dispatch_imsg_session(ibuf_se_ctl);

if (handle_pollfd(&pfd[PFD_PIPE_ROA3], ibuf_rtr) == -1) {
	log_warnx("RDE: Lost connection to ROA");
	msgbuf_clear(&ibuf_rtr->w);
	free(ibuf_rtr);
	ibuf_rtr = NULL((void *)0);
} else
	rde_dispatch_imsg_rtr(ibuf_rtr);

for (j = PFD_PIPE_COUNT4, mctx = LIST_FIRST(&rde_mrts)((&rde_mrts)->lh_first);
    j < i && mctx != 0; j++) {
	if (pfd[j].fd == mctx->mrt.wbuf.fd &&
	    pfd[j].revents & POLLOUT0x0004)
		mrt_write(&mctx->mrt);
	mctx = LIST_NEXT(mctx, entry)((mctx)->entry.le_next);
}

peer_foreach(rde_dispatch_imsg_peer, NULL((void *)0));
rib_dump_runner();
nexthop_runner();
if (ibuf_se && ibuf_se->w.queued < SESS_MSG_HIGH_MARK2000) {
	for (aid = AID_MIN1; aid < AID_MAX7; aid++)
		rde_update_queue_runner(aid);
}
/* commit pftable once per poll loop */
rde_commit_pftable();
}

/* do not clean up on shutdown on production, it takes ages. */
if (debug)
20
←
Assuming 'debug' is 0→
21
←
Taking false branch→
rde_shutdown();

free_config(conf);
free(pfd);

/* close pipes */
if (ibuf_se) {
22
←
Assuming 'ibuf_se' is null→
23
←
Taking false branch→
msgbuf_clear(&ibuf_se->w);
close(ibuf_se->fd);
free(ibuf_se);
}
if (ibuf_se_ctl) {
24
←
Assuming 'ibuf_se_ctl' is null→
25
←
Taking false branch→
msgbuf_clear(&ibuf_se_ctl->w);
close(ibuf_se_ctl->fd);
free(ibuf_se_ctl);
}
if (ibuf_rtr) {
26
←
Assuming 'ibuf_rtr' is null→
27
←
Taking false branch→
msgbuf_clear(&ibuf_rtr->w);
close(ibuf_rtr->fd);
free(ibuf_rtr);
}
msgbuf_clear(&ibuf_main->w);
close(ibuf_main->fd);
free(ibuf_main);

while ((mctx = LIST_FIRST(&rde_mrts)((&rde_mrts)->lh_first)) != NULL((void *)0)) {
28
←
Assuming the condition is true→
29
←
Loop condition is true.  Entering loop body→
34
←
Loop condition is true.  Entering loop body→
msgbuf_clear(&mctx->mrt.wbuf);
close(mctx->mrt.wbuf.fd);
35
←
Use of memory after it is freed
LIST_REMOVE(mctx, entry)do { if ((mctx)->entry.le_next != ((void *)0)) (mctx)->
entry.le_next->entry.le_prev = (mctx)->entry.le_prev; *
(mctx)->entry.le_prev = (mctx)->entry.le_next; ; ; } while
 (0);
30
←
Assuming field 'le_next' is equal to null→
31
←
Taking false branch→
32
←
Loop condition is false.  Exiting loop→
free(mctx);
33
←
Memory is released→
}

log_info("route decision engine exiting");
exit(0);
355}

357struct network_config	netconf_s, netconf_p;
358struct filterstate	netconf_state;
359struct filter_set_head	session_set = TAILQ_HEAD_INITIALIZER(session_set){ ((void *)0), &(session_set).tqh_first };
360struct filter_set_head	parent_set = TAILQ_HEAD_INITIALIZER(parent_set){ ((void *)0), &(parent_set).tqh_first };

362void
363rde_dispatch_imsg_session(struct imsgbuf *imsgbuf)
364{
static struct flowspec	*curflow;
struct imsg		 imsg;
struct rde_peer_stats	 stats;
struct ctl_show_set	 cset;
struct ctl_show_rib	 csr;
struct ctl_show_rib_request	req;
struct session_up	 sup;
struct rde_peer		*peer;
struct rde_aspath	*asp;
struct filter_set	*s;
struct as_set		*aset;
struct rde_prefixset	*pset;
uint8_t			*asdata;
ssize_t			 n;
size_t			 aslen;
int			 verbose;
uint16_t		 len;
uint8_t			 aid;

while (imsgbuf) {
if ((n = imsg_get(imsgbuf, &imsg)) == -1)
	fatal("rde_dispatch_imsg_session: imsg_get error");
if (n == 0)
	break;

switch (imsg.hdr.type) {
case IMSG_UPDATE:
case IMSG_REFRESH:
	if ((peer = peer_get(imsg.hdr.peerid)) == NULL((void *)0)) {
		log_warnx("rde_dispatch: unknown peer id %d",
		    imsg.hdr.peerid);
		break;
	}
	peer_imsg_push(peer, &imsg);
	break;
case IMSG_SESSION_ADD:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(struct peer_config))
		fatalx("incorrect size of session request");
	peer = peer_add(imsg.hdr.peerid, imsg.data, out_rules);
	/* make sure rde_eval_all is on if needed. */
	if (peer->conf.flags & PEERFLAG_EVALUATE_ALL0x04)
		rde_eval_all = 1;
	break;
case IMSG_SESSION_UP:
	if ((peer = peer_get(imsg.hdr.peerid)) == NULL((void *)0)) {
		log_warnx("%s: unknown peer id %d",
		    "IMSG_SESSION_UP", imsg.hdr.peerid);
		break;
	}
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) != sizeof(sup))
		fatalx("incorrect size of session request");
	memcpy(&sup, imsg.data, sizeof(sup));
	peer_up(peer, &sup);
	/* make sure rde_eval_all is on if needed. */
	if (peer_has_add_path(peer, AID_UNSPEC0, CAPA_AP_SEND0x02))
		rde_eval_all = 1;
	break;
case IMSG_SESSION_DOWN:
	if ((peer = peer_get(imsg.hdr.peerid)) == NULL((void *)0)) {
		log_warnx("%s: unknown peer id %d",
		    "IMSG_SESSION_DOWN", imsg.hdr.peerid);
		break;
	}
	peer_down(peer, NULL((void *)0));
	break;
case IMSG_SESSION_STALE:
case IMSG_SESSION_NOGRACE:
case IMSG_SESSION_FLUSH:
case IMSG_SESSION_RESTARTED:
	if ((peer = peer_get(imsg.hdr.peerid)) == NULL((void *)0)) {
		log_warnx("%s: unknown peer id %d",
		    "graceful restart", imsg.hdr.peerid);
		break;
	}
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) != sizeof(aid)) {
		log_warnx("%s: wrong imsg len", __func__);
		break;
	}
	memcpy(&aid, imsg.data, sizeof(aid));
	if (aid >= AID_MAX7) {
		log_warnx("%s: bad AID", __func__);
		break;
	}

	switch (imsg.hdr.type) {
	case IMSG_SESSION_STALE:
	case IMSG_SESSION_NOGRACE:
		peer_stale(peer, aid,
		    imsg.hdr.type == IMSG_SESSION_NOGRACE);
		break;
	case IMSG_SESSION_FLUSH:
		peer_flush(peer, aid, peer->staletime[aid]);
		break;
	case IMSG_SESSION_RESTARTED:
		if (peer->staletime[aid])
			peer_flush(peer, aid,
			    peer->staletime[aid]);
		break;
	}
	break;
case IMSG_NETWORK_ADD:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(struct network_config)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	memcpy(&netconf_s, imsg.data, sizeof(netconf_s));
	TAILQ_INIT(&netconf_s.attrset)do { (&netconf_s.attrset)->tqh_first = ((void *)0); (&
netconf_s.attrset)->tqh_last = &(&netconf_s.attrset
)->tqh_first; } while (0);
	rde_filterstate_init(&netconf_state);
	asp = &netconf_state.aspath;
	asp->aspath = aspath_get(NULL((void *)0), 0);
	asp->origin = ORIGIN_IGP0;
	asp->flags = F_ATTR_ORIGIN0x00001 | F_ATTR_ASPATH0x00002 |
	    F_ATTR_LOCALPREF0x00008 | F_PREFIX_ANNOUNCED0x00400 |
	    F_ANN_DYNAMIC0x00800;
	break;
case IMSG_NETWORK_ASPATH:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) <
	    sizeof(csr)) {
		log_warnx("rde_dispatch: wrong imsg len");
		memset(&netconf_s, 0, sizeof(netconf_s));
		break;
	}
	aslen = imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) - sizeof(csr);
	asdata = imsg.data;
	asdata += sizeof(struct ctl_show_rib);
	memcpy(&csr, imsg.data, sizeof(csr));
	asp = &netconf_state.aspath;
	asp->lpref = csr.local_pref;
	asp->med = csr.med;
	asp->weight = csr.weight;
	asp->flags = csr.flags;
	asp->origin = csr.origin;
	asp->flags |= F_PREFIX_ANNOUNCED0x00400 | F_ANN_DYNAMIC0x00800;
	aspath_put(asp->aspath);
	asp->aspath = aspath_get(asdata, aslen);
	break;
case IMSG_NETWORK_ATTR:
	if (imsg.hdr.len <= IMSG_HEADER_SIZEsizeof(struct imsg_hdr)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	/* parse optional path attributes */
	len = imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr);
	if (rde_attr_add(&netconf_state, imsg.data,
	    len) == -1) {
		log_warnx("rde_dispatch: bad network "
		    "attribute");
		rde_filterstate_clean(&netconf_state);
		memset(&netconf_s, 0, sizeof(netconf_s));
		break;
	}
	break;
case IMSG_NETWORK_DONE:
	if (imsg.hdr.len != IMSG_HEADER_SIZEsizeof(struct imsg_hdr)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	TAILQ_CONCAT(&netconf_s.attrset, &session_set, entry)do { if (!(((&session_set)->tqh_first) == ((void *)0))
) { *(&netconf_s.attrset)->tqh_last = (&session_set
)->tqh_first; (&session_set)->tqh_first->entry.tqe_prev
 = (&netconf_s.attrset)->tqh_last; (&netconf_s.attrset
)->tqh_last = (&session_set)->tqh_last; do { ((&
session_set))->tqh_first = ((void *)0); ((&session_set
))->tqh_last = &((&session_set))->tqh_first; } while
 (0); } } while (0);
	switch (netconf_s.prefix.aid) {
	case AID_INET1:
		if (netconf_s.prefixlen > 32)
			goto badnet;
		network_add(&netconf_s, &netconf_state);
		break;
	case AID_INET62:
		if (netconf_s.prefixlen > 128)
			goto badnet;
		network_add(&netconf_s, &netconf_state);
		break;
	case 0:
		/* something failed beforehand */
		break;
	default:
540badnet:
		log_warnx("request to insert invalid network");
		break;
	}
	rde_filterstate_clean(&netconf_state);
	break;
case IMSG_NETWORK_REMOVE:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(struct network_config)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	memcpy(&netconf_s, imsg.data, sizeof(netconf_s));
	TAILQ_INIT(&netconf_s.attrset)do { (&netconf_s.attrset)->tqh_first = ((void *)0); (&
netconf_s.attrset)->tqh_last = &(&netconf_s.attrset
)->tqh_first; } while (0);

	switch (netconf_s.prefix.aid) {
	case AID_INET1:
		if (netconf_s.prefixlen > 32)
			goto badnetdel;
		network_delete(&netconf_s);
		break;
	case AID_INET62:
		if (netconf_s.prefixlen > 128)
			goto badnetdel;
		network_delete(&netconf_s);
		break;
	default:
567badnetdel:
		log_warnx("request to remove invalid network");
		break;
	}
	break;
case IMSG_NETWORK_FLUSH:
	if (imsg.hdr.len != IMSG_HEADER_SIZEsizeof(struct imsg_hdr)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	if (rib_dump_new(RIB_ADJ_IN0, AID_UNSPEC0,
	    RDE_RUNNER_ROUNDS100, NULL((void *)0), network_flush_upcall,
	    NULL((void *)0), NULL((void *)0)) == -1)
		log_warn("rde_dispatch: IMSG_NETWORK_FLUSH");
	break;
case IMSG_FLOWSPEC_ADD:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) <= FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data))) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	if (curflow != NULL((void *)0)) {
		log_warnx("rde_dispatch: "
		    "unexpected flowspec add");
		break;
	}
	curflow = malloc(imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr));
	if (curflow == NULL((void *)0))
		fatal(NULL((void *)0));
	memcpy(curflow, imsg.data,
	    imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr));
	if (curflow->len + FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data)) !=
	    imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr)) {
		free(curflow);
		curflow = NULL((void *)0);
		log_warnx("rde_dispatch: wrong flowspec len");
		break;
	}
	rde_filterstate_init(&netconf_state);
	asp = &netconf_state.aspath;
	asp->aspath = aspath_get(NULL((void *)0), 0);
	asp->origin = ORIGIN_IGP0;
	asp->flags = F_ATTR_ORIGIN0x00001 | F_ATTR_ASPATH0x00002 |
	    F_ATTR_LOCALPREF0x00008 | F_PREFIX_ANNOUNCED0x00400 |
	    F_ANN_DYNAMIC0x00800;
	break;
case IMSG_FLOWSPEC_DONE:
	if (curflow == NULL((void *)0)) {
		log_warnx("rde_dispatch: "
		    "unexpected flowspec done");
		break;
	}

	if (flowspec_valid(curflow->data, curflow->len,
	    curflow->aid == AID_FLOWSPECv66) == -1)
		log_warnx("invalid flowspec update received "
		    "from bgpctl");
	else
		flowspec_add(curflow, &netconf_state,
		    &session_set);

	rde_filterstate_clean(&netconf_state);
	filterset_free(&session_set);
	free(curflow);
	curflow = NULL((void *)0);
	break;
case IMSG_FLOWSPEC_REMOVE:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) <= FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data))) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	if (curflow != NULL((void *)0)) {
		log_warnx("rde_dispatch: "
		    "unexpected flowspec remove");
		break;
	}
	curflow = malloc(imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr));
	if (curflow == NULL((void *)0))
		fatal(NULL((void *)0));
	memcpy(curflow, imsg.data,
	    imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr));
	if (curflow->len + FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data)) !=
	    imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr)) {
		free(curflow);
		curflow = NULL((void *)0);
		log_warnx("rde_dispatch: wrong flowspec len");
		break;
	}

	if (flowspec_valid(curflow->data, curflow->len,
	    curflow->aid == AID_FLOWSPECv66) == -1)
		log_warnx("invalid flowspec withdraw received "
		    "from bgpctl");
	else
		flowspec_delete(curflow);

	free(curflow);
	curflow = NULL((void *)0);
	break;
case IMSG_FLOWSPEC_FLUSH:
	if (imsg.hdr.len != IMSG_HEADER_SIZEsizeof(struct imsg_hdr)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	prefix_flowspec_dump(AID_UNSPEC0, NULL((void *)0),
	    flowspec_flush_upcall, NULL((void *)0));
	break;
case IMSG_FILTER_SET:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(struct filter_set)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	if ((s = malloc(sizeof(struct filter_set))) == NULL((void *)0))
		fatal(NULL((void *)0));
	memcpy(s, imsg.data, sizeof(struct filter_set));
	if (s->type == ACTION_SET_NEXTHOP) {
		s->action.nh_ref =
		    nexthop_get(&s->action.nexthop);
		s->type = ACTION_SET_NEXTHOP_REF;
	}
	TAILQ_INSERT_TAIL(&session_set, s, entry)do { (s)->entry.tqe_next = ((void *)0); (s)->entry.tqe_prev
 = (&session_set)->tqh_last; *(&session_set)->tqh_last
 = (s); (&session_set)->tqh_last = &(s)->entry.
tqe_next; } while (0);
	break;
case IMSG_CTL_SHOW_NETWORK:
case IMSG_CTL_SHOW_RIB:
case IMSG_CTL_SHOW_RIB_PREFIX:
	if (imsg.hdr.len != IMSG_HEADER_SIZEsizeof(struct imsg_hdr) + sizeof(req)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	memcpy(&req, imsg.data, sizeof(req));
	rde_dump_ctx_new(&req, imsg.hdr.pid, imsg.hdr.type);
	break;
case IMSG_CTL_SHOW_FLOWSPEC:
	if (imsg.hdr.len != IMSG_HEADER_SIZEsizeof(struct imsg_hdr) + sizeof(req)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	memcpy(&req, imsg.data, sizeof(req));
	prefix_flowspec_dump(req.aid, &imsg.hdr.pid,
	    flowspec_dump_upcall, flowspec_dump_done);
	break;
case IMSG_CTL_SHOW_NEIGHBOR:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) != 0) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	peer = peer_get(imsg.hdr.peerid);
	if (peer != NULL((void *)0))
		memcpy(&stats, &peer->stats, sizeof(stats));
	else
		memset(&stats, 0, sizeof(stats));
	imsg_compose(ibuf_se_ctl, IMSG_CTL_SHOW_NEIGHBOR,
	    imsg.hdr.peerid, imsg.hdr.pid, -1,
	    &stats, sizeof(stats));
	break;
case IMSG_CTL_SHOW_RIB_MEM:
	imsg_compose(ibuf_se_ctl, IMSG_CTL_SHOW_RIB_MEM, 0,
	    imsg.hdr.pid, -1, &rdemem, sizeof(rdemem));
	break;
case IMSG_CTL_SHOW_SET:
	/* first roa set */
	pset = &rde_roa;
	memset(&cset, 0, sizeof(cset));
	cset.type = ROA_SET;
	strlcpy(cset.name, "RPKI ROA", sizeof(cset.name));
	cset.lastchange = pset->lastchange;
	cset.v4_cnt = pset->th.v4_cnt;
	cset.v6_cnt = pset->th.v6_cnt;
	imsg_compose(ibuf_se_ctl, IMSG_CTL_SHOW_SET, 0,
	    imsg.hdr.pid, -1, &cset, sizeof(cset));

	/* then aspa set */
	memset(&cset, 0, sizeof(cset));
	cset.type = ASPA_SET;
	strlcpy(cset.name, "RPKI ASPA", sizeof(cset.name));
	aspa_table_stats(rde_aspa, &cset);
	imsg_compose(ibuf_se_ctl, IMSG_CTL_SHOW_SET, 0,
	    imsg.hdr.pid, -1, &cset, sizeof(cset));

	SIMPLEQ_FOREACH(aset, &conf->as_sets, entry)for((aset) = ((&conf->as_sets)->sqh_first); (aset) !=
 ((void *)0); (aset) = ((aset)->entry.sqe_next)) {
		memset(&cset, 0, sizeof(cset));
		cset.type = ASNUM_SET;
		strlcpy(cset.name, aset->name,
		    sizeof(cset.name));
		cset.lastchange = aset->lastchange;
		cset.as_cnt = set_nmemb(aset->set);
		imsg_compose(ibuf_se_ctl, IMSG_CTL_SHOW_SET, 0,
		    imsg.hdr.pid, -1, &cset, sizeof(cset));
	}
	SIMPLEQ_FOREACH(pset, &conf->rde_prefixsets, entry)for((pset) = ((&conf->rde_prefixsets)->sqh_first); (
pset) != ((void *)0); (pset) = ((pset)->entry.sqe_next)) {
		memset(&cset, 0, sizeof(cset));
		cset.type = PREFIX_SET;
		strlcpy(cset.name, pset->name,
		    sizeof(cset.name));
		cset.lastchange = pset->lastchange;
		cset.v4_cnt = pset->th.v4_cnt;
		cset.v6_cnt = pset->th.v6_cnt;
		imsg_compose(ibuf_se_ctl, IMSG_CTL_SHOW_SET, 0,
		    imsg.hdr.pid, -1, &cset, sizeof(cset));
	}
	SIMPLEQ_FOREACH(pset, &conf->rde_originsets, entry)for((pset) = ((&conf->rde_originsets)->sqh_first); (
pset) != ((void *)0); (pset) = ((pset)->entry.sqe_next)) {
		memset(&cset, 0, sizeof(cset));
		cset.type = ORIGIN_SET;
		strlcpy(cset.name, pset->name,
		    sizeof(cset.name));
		cset.lastchange = pset->lastchange;
		cset.v4_cnt = pset->th.v4_cnt;
		cset.v6_cnt = pset->th.v6_cnt;
		imsg_compose(ibuf_se_ctl, IMSG_CTL_SHOW_SET, 0,
		    imsg.hdr.pid, -1, &cset, sizeof(cset));
	}
	imsg_compose(ibuf_se_ctl, IMSG_CTL_END, 0, imsg.hdr.pid,
	    -1, NULL((void *)0), 0);
	break;
case IMSG_CTL_LOG_VERBOSE:
	/* already checked by SE */
	memcpy(&verbose, imsg.data, sizeof(verbose));
	log_setverbose(verbose);
	break;
case IMSG_CTL_END:
	imsg_compose(ibuf_se_ctl, IMSG_CTL_END, 0, imsg.hdr.pid,
	    -1, NULL((void *)0), 0);
	break;
case IMSG_CTL_TERMINATE:
	rde_dump_ctx_terminate(imsg.hdr.pid);
	break;
case IMSG_XON:
	if (imsg.hdr.peerid) {
		peer = peer_get(imsg.hdr.peerid);
		if (peer)
			peer->throttled = 0;
	} else {
		rde_dump_ctx_throttle(imsg.hdr.pid, 0);
	}
	break;
case IMSG_XOFF:
	if (imsg.hdr.peerid) {
		peer = peer_get(imsg.hdr.peerid);
		if (peer)
			peer->throttled = 1;
	} else {
		rde_dump_ctx_throttle(imsg.hdr.pid, 1);
	}
	break;
case IMSG_RECONF_DRAIN:
	imsg_compose(ibuf_se, IMSG_RECONF_DRAIN, 0, 0,
	    -1, NULL((void *)0), 0);
	break;
default:
	break;
}
imsg_free(&imsg);
}
820}

822void
823rde_dispatch_imsg_parent(struct imsgbuf *imsgbuf)
824{
static struct rde_prefixset	*last_prefixset;
static struct as_set	*last_as_set;
static struct l3vpn	*vpn;
static struct flowspec	*curflow;
struct imsg		 imsg;
struct mrt		 xmrt;
struct roa		 roa;
struct rde_rib		 rr;
struct filterstate	 state;
struct imsgbuf		*i;
struct filter_head	*nr;
struct filter_rule	*r;
struct filter_set	*s;
struct rib		*rib;
struct rde_prefixset	*ps;
struct rde_aspath	*asp;
struct prefixset_item	 psi;
char			*name;
size_t			 nmemb;
int			 n, fd, rv;
uint16_t		 rid;

while (imsgbuf) {
if ((n = imsg_get(imsgbuf, &imsg)) == -1)
	fatal("rde_dispatch_imsg_parent: imsg_get error");
if (n == 0)
	break;

switch (imsg.hdr.type) {
case IMSG_SOCKET_CONN:
case IMSG_SOCKET_CONN_CTL:
case IMSG_SOCKET_CONN_RTR:
	if ((fd = imsg_get_fd(&imsg)) == -1) {
		log_warnx("expected to receive imsg fd "
		    "but didn't receive any");
		break;
	}
	if ((i = malloc(sizeof(struct imsgbuf))) == NULL((void *)0))
		fatal(NULL((void *)0));
	imsg_init(i, fd);
	switch (imsg.hdr.type) {
	case IMSG_SOCKET_CONN:
		if (ibuf_se) {
			log_warnx("Unexpected imsg connection "
			    "to SE received");
			msgbuf_clear(&ibuf_se->w);
			free(ibuf_se);
		}
		ibuf_se = i;
		break;
	case IMSG_SOCKET_CONN_CTL:
		if (ibuf_se_ctl) {
			log_warnx("Unexpected imsg ctl "
			    "connection to SE received");
			msgbuf_clear(&ibuf_se_ctl->w);
			free(ibuf_se_ctl);
		}
		ibuf_se_ctl = i;
		break;
	case IMSG_SOCKET_CONN_RTR:
		if (ibuf_rtr) {
			log_warnx("Unexpected imsg ctl "
			    "connection to ROA received");
			msgbuf_clear(&ibuf_rtr->w);
			free(ibuf_rtr);
		}
		ibuf_rtr = i;
		break;
	}
	break;
case IMSG_NETWORK_ADD:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(struct network_config)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	memcpy(&netconf_p, imsg.data, sizeof(netconf_p));
	TAILQ_INIT(&netconf_p.attrset)do { (&netconf_p.attrset)->tqh_first = ((void *)0); (&
netconf_p.attrset)->tqh_last = &(&netconf_p.attrset
)->tqh_first; } while (0);
	break;
case IMSG_NETWORK_DONE:
	TAILQ_CONCAT(&netconf_p.attrset, &parent_set, entry)do { if (!(((&parent_set)->tqh_first) == ((void *)0)))
 { *(&netconf_p.attrset)->tqh_last = (&parent_set)
->tqh_first; (&parent_set)->tqh_first->entry.tqe_prev
 = (&netconf_p.attrset)->tqh_last; (&netconf_p.attrset
)->tqh_last = (&parent_set)->tqh_last; do { ((&
parent_set))->tqh_first = ((void *)0); ((&parent_set))
->tqh_last = &((&parent_set))->tqh_first; } while
 (0); } } while (0);

	rde_filterstate_init(&state);
	asp = &state.aspath;
	asp->aspath = aspath_get(NULL((void *)0), 0);
	asp->origin = ORIGIN_IGP0;
	asp->flags = F_ATTR_ORIGIN0x00001 | F_ATTR_ASPATH0x00002 |
	    F_ATTR_LOCALPREF0x00008 | F_PREFIX_ANNOUNCED0x00400;

	network_add(&netconf_p, &state);
	rde_filterstate_clean(&state);
	break;
case IMSG_NETWORK_REMOVE:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(struct network_config)) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	memcpy(&netconf_p, imsg.data, sizeof(netconf_p));
	TAILQ_INIT(&netconf_p.attrset)do { (&netconf_p.attrset)->tqh_first = ((void *)0); (&
netconf_p.attrset)->tqh_last = &(&netconf_p.attrset
)->tqh_first; } while (0);
	network_delete(&netconf_p);
	break;
case IMSG_FLOWSPEC_ADD:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) <= FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data))) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	if (curflow != NULL((void *)0)) {
		log_warnx("rde_dispatch: "
		    "unexpected flowspec add");
		break;
	}
	curflow = malloc(imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr));
	if (curflow == NULL((void *)0))
		fatal(NULL((void *)0));
	memcpy(curflow, imsg.data,
	    imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr));
	if (curflow->len + FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data)) !=
	    imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr)) {
		free(curflow);
		curflow = NULL((void *)0);
		log_warnx("rde_dispatch: wrong flowspec len");
		break;
	}
	break;
case IMSG_FLOWSPEC_DONE:
	if (curflow == NULL((void *)0)) {
		log_warnx("rde_dispatch: "
		    "unexpected flowspec done");
		break;
	}

	rde_filterstate_init(&state);
	asp = &state.aspath;
	asp->aspath = aspath_get(NULL((void *)0), 0);
	asp->origin = ORIGIN_IGP0;
	asp->flags = F_ATTR_ORIGIN0x00001 | F_ATTR_ASPATH0x00002 |
	    F_ATTR_LOCALPREF0x00008 | F_PREFIX_ANNOUNCED0x00400;

	if (flowspec_valid(curflow->data, curflow->len,
	    curflow->aid == AID_FLOWSPECv66) == -1)
		log_warnx("invalid flowspec update received "
		    "from parent");
	else
		flowspec_add(curflow, &state, &parent_set);

	rde_filterstate_clean(&state);
	filterset_free(&parent_set);
	free(curflow);
	curflow = NULL((void *)0);
	break;
case IMSG_FLOWSPEC_REMOVE:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) <= FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data))) {
		log_warnx("rde_dispatch: wrong imsg len");
		break;
	}
	if (curflow != NULL((void *)0)) {
		log_warnx("rde_dispatch: "
		    "unexpected flowspec remove");
		break;
	}
	curflow = malloc(imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr));
	if (curflow == NULL((void *)0))
		fatal(NULL((void *)0));
	memcpy(curflow, imsg.data,
	    imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr));
	if (curflow->len + FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data)) !=
	    imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr)) {
		free(curflow);
		curflow = NULL((void *)0);
		log_warnx("rde_dispatch: wrong flowspec len");
		break;
	}

	if (flowspec_valid(curflow->data, curflow->len,
	    curflow->aid == AID_FLOWSPECv66) == -1)
		log_warnx("invalid flowspec withdraw received "
		    "from parent");
	else
		flowspec_delete(curflow);

	free(curflow);
	curflow = NULL((void *)0);
	break;
case IMSG_RECONF_CONF:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(struct bgpd_config))
		fatalx("IMSG_RECONF_CONF bad len");
	out_rules_tmp = calloc(1, sizeof(struct filter_head));
	if (out_rules_tmp == NULL((void *)0))
		fatal(NULL((void *)0));
	TAILQ_INIT(out_rules_tmp)do { (out_rules_tmp)->tqh_first = ((void *)0); (out_rules_tmp
)->tqh_last = &(out_rules_tmp)->tqh_first; } while (
0);
	nconf = new_config();
	copy_config(nconf, imsg.data);

	for (rid = 0; rid < rib_size; rid++) {
		if ((rib = rib_byid(rid)) == NULL((void *)0))
			continue;
		rib->state = RECONF_DELETE;
		rib->fibstate = RECONF_NONE;
	}
	break;
case IMSG_RECONF_RIB:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(struct rde_rib))
		fatalx("IMSG_RECONF_RIB bad len");
	memcpy(&rr, imsg.data, sizeof(rr));
	rib = rib_byid(rib_find(rr.name));
	if (rib == NULL((void *)0)) {
		rib = rib_new(rr.name, rr.rtableid, rr.flags);
	} else if (rib->flags == rr.flags &&
	    rib->rtableid == rr.rtableid) {
		/* no change to rib apart from filters */
		rib->state = RECONF_KEEP;
	} else {
		/* reload rib because something changed */
		rib->flags_tmp = rr.flags;
		rib->rtableid_tmp = rr.rtableid;
		rib->state = RECONF_RELOAD;
	}
	break;
case IMSG_RECONF_FILTER:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(struct filter_rule))
		fatalx("IMSG_RECONF_FILTER bad len");
	if ((r = malloc(sizeof(struct filter_rule))) == NULL((void *)0))
		fatal(NULL((void *)0));
	memcpy(r, imsg.data, sizeof(struct filter_rule));
	if (r->match.prefixset.name[0] != '\0') {
		r->match.prefixset.ps =
		    rde_find_prefixset(r->match.prefixset.name,
			&nconf->rde_prefixsets);
		if (r->match.prefixset.ps == NULL((void *)0))
			log_warnx("%s: no prefixset for %s",
			    __func__, r->match.prefixset.name);
	}
	if (r->match.originset.name[0] != '\0') {
		r->match.originset.ps =
		    rde_find_prefixset(r->match.originset.name,
			&nconf->rde_originsets);
		if (r->match.originset.ps == NULL((void *)0))
			log_warnx("%s: no origin-set for %s",
			    __func__, r->match.originset.name);
	}
	if (r->match.as.flags & AS_FLAG_AS_SET_NAME0x02) {
		struct as_set * aset;

		aset = as_sets_lookup(&nconf->as_sets,
		    r->match.as.name);
		if (aset == NULL((void *)0)) {
			log_warnx("%s: no as-set for %s",
			    __func__, r->match.as.name);
		} else {
			r->match.as.flags = AS_FLAG_AS_SET0x04;
			r->match.as.aset = aset;
		}
	}
	TAILQ_INIT(&r->set)do { (&r->set)->tqh_first = ((void *)0); (&r->
set)->tqh_last = &(&r->set)->tqh_first; } while
 (0);
	TAILQ_CONCAT(&r->set, &parent_set, entry)do { if (!(((&parent_set)->tqh_first) == ((void *)0)))
 { *(&r->set)->tqh_last = (&parent_set)->tqh_first
; (&parent_set)->tqh_first->entry.tqe_prev = (&
r->set)->tqh_last; (&r->set)->tqh_last = (&
parent_set)->tqh_last; do { ((&parent_set))->tqh_first
 = ((void *)0); ((&parent_set))->tqh_last = &((&
parent_set))->tqh_first; } while (0); } } while (0);
	if ((rib = rib_byid(rib_find(r->rib))) == NULL((void *)0)) {
		log_warnx("IMSG_RECONF_FILTER: filter rule "
		    "for nonexistent rib %s", r->rib);
		filterset_free(&r->set);
		free(r);
		break;
	}
	r->peer.ribid = rib->id;
	if (r->dir == DIR_IN) {
		nr = rib->in_rules_tmp;
		if (nr == NULL((void *)0)) {
			nr = calloc(1,
			    sizeof(struct filter_head));
			if (nr == NULL((void *)0))
				fatal(NULL((void *)0));
			TAILQ_INIT(nr)do { (nr)->tqh_first = ((void *)0); (nr)->tqh_last = &
(nr)->tqh_first; } while (0);
			rib->in_rules_tmp = nr;
		}
		TAILQ_INSERT_TAIL(nr, r, entry)do { (r)->entry.tqe_next = ((void *)0); (r)->entry.tqe_prev
 = (nr)->tqh_last; *(nr)->tqh_last = (r); (nr)->tqh_last
 = &(r)->entry.tqe_next; } while (0);
	} else {
		TAILQ_INSERT_TAIL(out_rules_tmp, r, entry)do { (r)->entry.tqe_next = ((void *)0); (r)->entry.tqe_prev
 = (out_rules_tmp)->tqh_last; *(out_rules_tmp)->tqh_last
 = (r); (out_rules_tmp)->tqh_last = &(r)->entry.tqe_next
; } while (0);
	}
	break;
case IMSG_RECONF_PREFIX_SET:
case IMSG_RECONF_ORIGIN_SET:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(ps->name))
		fatalx("IMSG_RECONF_PREFIX_SET bad len");
	ps = calloc(1, sizeof(struct rde_prefixset));
	if (ps == NULL((void *)0))
		fatal(NULL((void *)0));
	memcpy(ps->name, imsg.data, sizeof(ps->name));
	if (imsg.hdr.type == IMSG_RECONF_ORIGIN_SET) {
		SIMPLEQ_INSERT_TAIL(&nconf->rde_originsets, ps,do { (ps)->entry.sqe_next = ((void *)0); *(&nconf->
rde_originsets)->sqh_last = (ps); (&nconf->rde_originsets
)->sqh_last = &(ps)->entry.sqe_next; } while (0)
		    entry)do { (ps)->entry.sqe_next = ((void *)0); *(&nconf->
rde_originsets)->sqh_last = (ps); (&nconf->rde_originsets
)->sqh_last = &(ps)->entry.sqe_next; } while (0);
	} else {
		SIMPLEQ_INSERT_TAIL(&nconf->rde_prefixsets, ps,do { (ps)->entry.sqe_next = ((void *)0); *(&nconf->
rde_prefixsets)->sqh_last = (ps); (&nconf->rde_prefixsets
)->sqh_last = &(ps)->entry.sqe_next; } while (0)
		    entry)do { (ps)->entry.sqe_next = ((void *)0); *(&nconf->
rde_prefixsets)->sqh_last = (ps); (&nconf->rde_prefixsets
)->sqh_last = &(ps)->entry.sqe_next; } while (0);
	}
	last_prefixset = ps;
	break;
case IMSG_RECONF_ROA_ITEM:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) != sizeof(roa))
		fatalx("IMSG_RECONF_ROA_ITEM bad len");
	memcpy(&roa, imsg.data, sizeof(roa));
	rv = trie_roa_add(&last_prefixset->th, &roa);
	break;
case IMSG_RECONF_PREFIX_SET_ITEM:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) != sizeof(psi))
		fatalx("IMSG_RECONF_PREFIX_SET_ITEM bad len");
	memcpy(&psi, imsg.data, sizeof(psi));
	if (last_prefixset == NULL((void *)0))
		fatalx("King Bula has no prefixset");
	rv = trie_add(&last_prefixset->th,
	    &psi.p.addr, psi.p.len,
	    psi.p.len_min, psi.p.len_max);
	if (rv == -1)
		log_warnx("trie_add(%s) %s/%u failed",
		    last_prefixset->name, log_addr(&psi.p.addr),
		    psi.p.len);
	break;
case IMSG_RECONF_AS_SET:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(nmemb) + SET_NAME_LEN128)
		fatalx("IMSG_RECONF_AS_SET bad len");
	memcpy(&nmemb, imsg.data, sizeof(nmemb));
	name = (char *)imsg.data + sizeof(nmemb);
	if (as_sets_lookup(&nconf->as_sets, name) != NULL((void *)0))
		fatalx("duplicate as-set %s", name);
	last_as_set = as_sets_new(&nconf->as_sets, name, nmemb,
	    sizeof(uint32_t));
	break;
case IMSG_RECONF_AS_SET_ITEMS:
	nmemb = imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr);
	nmemb /= sizeof(uint32_t);
	if (set_add(last_as_set->set, imsg.data, nmemb) != 0)
		fatal(NULL((void *)0));
	break;
case IMSG_RECONF_AS_SET_DONE:
	set_prep(last_as_set->set);
	last_as_set = NULL((void *)0);
	break;
case IMSG_RECONF_VPN:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(struct l3vpn))
		fatalx("IMSG_RECONF_VPN bad len");
	if ((vpn = malloc(sizeof(struct l3vpn))) == NULL((void *)0))
		fatal(NULL((void *)0));
	memcpy(vpn, imsg.data, sizeof(struct l3vpn));
	TAILQ_INIT(&vpn->import)do { (&vpn->import)->tqh_first = ((void *)0); (&
vpn->import)->tqh_last = &(&vpn->import)->
tqh_first; } while (0);
	TAILQ_INIT(&vpn->export)do { (&vpn->export)->tqh_first = ((void *)0); (&
vpn->export)->tqh_last = &(&vpn->export)->
tqh_first; } while (0);
	TAILQ_INIT(&vpn->net_l)do { (&vpn->net_l)->tqh_first = ((void *)0); (&
vpn->net_l)->tqh_last = &(&vpn->net_l)->tqh_first
; } while (0);
	SIMPLEQ_INSERT_TAIL(&nconf->l3vpns, vpn, entry)do { (vpn)->entry.sqe_next = ((void *)0); *(&nconf->
l3vpns)->sqh_last = (vpn); (&nconf->l3vpns)->sqh_last
 = &(vpn)->entry.sqe_next; } while (0);
	break;
case IMSG_RECONF_VPN_EXPORT:
	if (vpn == NULL((void *)0)) {
		log_warnx("rde_dispatch_imsg_parent: "
		    "IMSG_RECONF_VPN_EXPORT unexpected");
		break;
	}
	TAILQ_CONCAT(&vpn->export, &parent_set, entry)do { if (!(((&parent_set)->tqh_first) == ((void *)0)))
 { *(&vpn->export)->tqh_last = (&parent_set)->
tqh_first; (&parent_set)->tqh_first->entry.tqe_prev
 = (&vpn->export)->tqh_last; (&vpn->export)->
tqh_last = (&parent_set)->tqh_last; do { ((&parent_set
))->tqh_first = ((void *)0); ((&parent_set))->tqh_last
 = &((&parent_set))->tqh_first; } while (0); } } while
 (0);
	break;
case IMSG_RECONF_VPN_IMPORT:
	if (vpn == NULL((void *)0)) {
		log_warnx("rde_dispatch_imsg_parent: "
		    "IMSG_RECONF_VPN_IMPORT unexpected");
		break;
	}
	TAILQ_CONCAT(&vpn->import, &parent_set, entry)do { if (!(((&parent_set)->tqh_first) == ((void *)0)))
 { *(&vpn->import)->tqh_last = (&parent_set)->
tqh_first; (&parent_set)->tqh_first->entry.tqe_prev
 = (&vpn->import)->tqh_last; (&vpn->import)->
tqh_last = (&parent_set)->tqh_last; do { ((&parent_set
))->tqh_first = ((void *)0); ((&parent_set))->tqh_last
 = &((&parent_set))->tqh_first; } while (0); } } while
 (0);
	break;
case IMSG_RECONF_VPN_DONE:
	break;
case IMSG_RECONF_DRAIN:
	imsg_compose(ibuf_main, IMSG_RECONF_DRAIN, 0, 0,
	    -1, NULL((void *)0), 0);
	break;
case IMSG_RECONF_DONE:
	if (nconf == NULL((void *)0))
		fatalx("got IMSG_RECONF_DONE but no config");
	last_prefixset = NULL((void *)0);

	rde_reload_done();
	break;
case IMSG_NEXTHOP_UPDATE:
	nexthop_update(imsg.data);
	break;
case IMSG_FILTER_SET:
	if (imsg.hdr.len > IMSG_HEADER_SIZEsizeof(struct imsg_hdr) +
	    sizeof(struct filter_set))
		fatalx("IMSG_FILTER_SET bad len");
	if ((s = malloc(sizeof(struct filter_set))) == NULL((void *)0))
		fatal(NULL((void *)0));
	memcpy(s, imsg.data, sizeof(struct filter_set));
	if (s->type == ACTION_SET_NEXTHOP) {
		s->action.nh_ref =
		    nexthop_get(&s->action.nexthop);
		s->type = ACTION_SET_NEXTHOP_REF;
	}
	TAILQ_INSERT_TAIL(&parent_set, s, entry)do { (s)->entry.tqe_next = ((void *)0); (s)->entry.tqe_prev
 = (&parent_set)->tqh_last; *(&parent_set)->tqh_last
 = (s); (&parent_set)->tqh_last = &(s)->entry.tqe_next
; } while (0);
	break;
case IMSG_MRT_OPEN:
case IMSG_MRT_REOPEN:
	if (imsg.hdr.len > IMSG_HEADER_SIZEsizeof(struct imsg_hdr) +
	    sizeof(struct mrt)) {
		log_warnx("wrong imsg len");
		break;
	}
	memcpy(&xmrt, imsg.data, sizeof(xmrt));
	if ((fd = imsg_get_fd(&imsg)) == -1)
		log_warnx("expected to receive fd for mrt dump "
		    "but didn't receive any");
	else if (xmrt.type == MRT_TABLE_DUMP ||
	    xmrt.type == MRT_TABLE_DUMP_MP ||
	    xmrt.type == MRT_TABLE_DUMP_V2) {
		rde_dump_mrt_new(&xmrt, imsg.hdr.pid, fd);
	} else
		close(fd);
	break;
case IMSG_MRT_CLOSE:
	/* ignore end message because a dump is atomic */
	break;
default:
	fatalx("unhandled IMSG %u", imsg.hdr.type);
}
imsg_free(&imsg);
}
1250}

1252void
1253rde_dispatch_imsg_rtr(struct imsgbuf *imsgbuf)
1254{
static struct aspa_set	*aspa;
struct imsg		 imsg;
struct roa		 roa;
struct aspa_prep	 ap;
int			 n;

while (imsgbuf) {
if ((n = imsg_get(imsgbuf, &imsg)) == -1)
	fatal("rde_dispatch_imsg_parent: imsg_get error");
if (n == 0)
	break;

switch (imsg.hdr.type) {
case IMSG_RECONF_ROA_SET:
	/* start of update */
	trie_free(&roa_new.th);	/* clear new roa */
	break;
case IMSG_RECONF_ROA_ITEM:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(roa))
		fatalx("IMSG_RECONF_ROA_ITEM bad len");
	memcpy(&roa, imsg.data, sizeof(roa));
	if (trie_roa_add(&roa_new.th, &roa) != 0) {
		struct bgpd_addr p = {
			.aid = roa.aid,
			.v6ba.v6 = roa.prefix.inet6
		};
		log_warnx("trie_roa_add %s/%u failed",
		    log_addr(&p), roa.prefixlen);
	}
	break;
case IMSG_RECONF_ASPA_PREP:
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) != sizeof(ap))
		fatalx("IMSG_RECONF_ASPA_PREP bad len");
	if (aspa_new)
		fatalx("unexpected IMSG_RECONF_ASPA_PREP");
	memcpy(&ap, imsg.data, sizeof(ap));
	aspa_new = aspa_table_prep(ap.entries, ap.datasize);
	break;
case IMSG_RECONF_ASPA:
	if (aspa_new == NULL((void *)0))
		fatalx("unexpected IMSG_RECONF_ASPA");
	if (aspa != NULL((void *)0))
		fatalx("IMSG_RECONF_ASPA already sent");
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    sizeof(uint32_t) * 2)
		fatalx("IMSG_RECONF_ASPA bad len");

	if ((aspa = calloc(1, sizeof(*aspa))) == NULL((void *)0))
		fatal("IMSG_RECONF_ASPA");
	memcpy(&aspa->as, imsg.data, sizeof(aspa->as));
	memcpy(&aspa->num, (char *)imsg.data + sizeof(aspa->as),
	    sizeof(aspa->num));
	break;
case IMSG_RECONF_ASPA_TAS:
	if (aspa == NULL((void *)0))
		fatalx("unexpected IMSG_RECONF_ASPA_TAS");
	if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) !=
	    aspa->num * sizeof(uint32_t))
		fatalx("IMSG_RECONF_ASPA_TAS bad len");
	aspa->tas = reallocarray(NULL((void *)0), aspa->num,
	    sizeof(uint32_t));
	if (aspa->tas == NULL((void *)0))
		fatal("IMSG_RECONF_ASPA_TAS");
	memcpy(aspa->tas, imsg.data,
	    aspa->num * sizeof(uint32_t));
	break;
case IMSG_RECONF_ASPA_DONE:
	if (aspa_new == NULL((void *)0))
		fatalx("unexpected IMSG_RECONF_ASPA");
	aspa_add_set(aspa_new, aspa->as, aspa->tas,
	    aspa->num);
	free_aspa(aspa);
	aspa = NULL((void *)0);
	break;
case IMSG_RECONF_DONE:
	/* end of update */
	if (rde_roa_reload() + rde_aspa_reload() != 0)
		rde_rpki_reload();
	break;
}
imsg_free(&imsg);
}
1338}

1340void
1341rde_dispatch_imsg_peer(struct rde_peer *peer, void *bula)
1342{
struct route_refresh rr;
struct imsg imsg;

if (!peer_imsg_pop(peer, &imsg))
return;

switch (imsg.hdr.type) {
case IMSG_UPDATE:
if (peer->state != PEER_UP)
	break;
rde_update_dispatch(peer, &imsg);
break;
case IMSG_REFRESH:
if (imsg.hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) != sizeof(rr)) {
	log_warnx("route refresh: wrong imsg len");
	break;
}
memcpy(&rr, imsg.data, sizeof(rr));
if (rr.aid >= AID_MAX7) {
	log_peer_warnx(&peer->conf,
	    "route refresh: bad AID %d", rr.aid);
	break;
}
if (peer->capa.mp[rr.aid] == 0) {
	log_peer_warnx(&peer->conf,
	    "route refresh: AID %s not negotiated",
	    aid2str(rr.aid));
	break;
}
switch (rr.subtype) {
case ROUTE_REFRESH_REQUEST0:
	peer_dump(peer, rr.aid);
	break;
case ROUTE_REFRESH_BEGIN_RR1:
	/* check if graceful restart EOR was received */
	if ((peer->recv_eor & (1 << rr.aid)) == 0) {
		log_peer_warnx(&peer->conf,
		    "received %s BoRR before EoR",
		    aid2str(rr.aid));
		break;
	}
	peer_begin_rrefresh(peer, rr.aid);
	break;
case ROUTE_REFRESH_END_RR2:
	if ((peer->recv_eor & (1 << rr.aid)) != 0 &&
	    peer->staletime[rr.aid])
		peer_flush(peer, rr.aid,
		    peer->staletime[rr.aid]);
	else
		log_peer_warnx(&peer->conf,
		    "received unexpected %s EoRR",
		    aid2str(rr.aid));
	break;
default:
	log_peer_warnx(&peer->conf,
	    "route refresh: bad subtype %d", rr.subtype);
	break;
}
break;
default:
log_warnx("%s: unhandled imsg type %d", __func__,
    imsg.hdr.type);
break;
}

imsg_free(&imsg);
1409}

1411/* handle routing updates from the session engine. */
1412void
1413rde_update_dispatch(struct rde_peer *peer, struct imsg *imsg)
1414{
struct filterstate	 state;
struct bgpd_addr	 prefix;
struct mpattr		 mpa;
u_char			*p, *mpp = NULL((void *)0);
int			 pos = 0;
uint16_t		 afi, len, mplen;
uint16_t		 withdrawn_len;
uint16_t		 attrpath_len;
uint16_t		 nlri_len;
uint8_t			 aid, prefixlen, safi, subtype;
uint32_t		 fas, pathid;

p = imsg->data;

if (imsg->hdr.len < IMSG_HEADER_SIZEsizeof(struct imsg_hdr) + 2) {
rde_update_err(peer, ERR_UPDATE, ERR_UPD_ATTRLIST, NULL((void *)0), 0);
return;
}

memcpy(&len, p, 2);
withdrawn_len = ntohs(len)(__uint16_t)(__builtin_constant_p(len) ? (__uint16_t)(((__uint16_t
)(len) & 0xffU) << 8 | ((__uint16_t)(len) & 0xff00U
) >> 8) : __swap16md(len));
p += 2;
if (imsg->hdr.len < IMSG_HEADER_SIZEsizeof(struct imsg_hdr) + 2 + withdrawn_len + 2) {
rde_update_err(peer, ERR_UPDATE, ERR_UPD_ATTRLIST, NULL((void *)0), 0);
return;
}

p += withdrawn_len;
memcpy(&len, p, 2);
attrpath_len = len = ntohs(len)(__uint16_t)(__builtin_constant_p(len) ? (__uint16_t)(((__uint16_t
)(len) & 0xffU) << 8 | ((__uint16_t)(len) & 0xff00U
) >> 8) : __swap16md(len));
p += 2;
if (imsg->hdr.len <
   IMSG_HEADER_SIZEsizeof(struct imsg_hdr) + 2 + withdrawn_len + 2 + attrpath_len) {
rde_update_err(peer, ERR_UPDATE, ERR_UPD_ATTRLIST, NULL((void *)0), 0);
return;
}

nlri_len =
   imsg->hdr.len - IMSG_HEADER_SIZEsizeof(struct imsg_hdr) - 4 - withdrawn_len - attrpath_len;

if (attrpath_len == 0) {
/* 0 = no NLRI information in this message */
if (nlri_len != 0) {
	/* crap at end of update which should not be there */
	rde_update_err(peer, ERR_UPDATE,
	    ERR_UPD_ATTRLIST, NULL((void *)0), 0);
	return;
}
if (withdrawn_len == 0) {
	/* EoR marker */
	rde_peer_recv_eor(peer, AID_INET1);
	return;
}
}

memset(&mpa, 0, sizeof(mpa));
rde_filterstate_init(&state);
if (attrpath_len != 0) { /* 0 = no NLRI information in this message */
/* parse path attributes */
while (len > 0) {
	if ((pos = rde_attr_parse(p, len, peer, &state,
	    &mpa)) < 0)
		goto done;
	p += pos;
	len -= pos;
}

/* check for missing but necessary attributes */
if ((subtype = rde_attr_missing(&state.aspath, peer->conf.ebgp,
    nlri_len))) {
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_MISSNG_WK_ATTR,
	    &subtype, sizeof(uint8_t));
	goto done;
}

rde_as4byte_fixup(peer, &state.aspath);

/* enforce remote AS if requested */
if (state.aspath.flags & F_ATTR_ASPATH0x00002 &&
    peer->conf.enforce_as == ENFORCE_AS_ON) {
	fas = aspath_neighbor(state.aspath.aspath);
	if (peer->conf.remote_as != fas) {
	    log_peer_warnx(&peer->conf, "bad path, "
		"starting with %s, "
		"enforce neighbor-as enabled", log_as(fas));
	    rde_update_err(peer, ERR_UPDATE, ERR_UPD_ASPATH,
		    NULL((void *)0), 0);
	    goto done;
	}
}

/* aspath needs to be loop free. This is not a hard error. */
if (state.aspath.flags & F_ATTR_ASPATH0x00002 &&
    peer->conf.ebgp &&
    peer->conf.enforce_local_as == ENFORCE_AS_ON &&
    !aspath_loopfree(state.aspath.aspath, peer->conf.local_as))
	state.aspath.flags |= F_ATTR_LOOP0x00200;

rde_reflector(peer, &state.aspath);

/* Cache aspa lookup for all updates from ebgp sessions. */
if (state.aspath.flags & F_ATTR_ASPATH0x00002 && peer->conf.ebgp) {
	aspa_validation(rde_aspa, state.aspath.aspath,
	    &state.aspath.aspa_state);
	state.aspath.aspa_generation = rde_aspa_generation;
}
}

p = imsg->data;
len = withdrawn_len;
p += 2;

/* withdraw prefix */
if (len > 0) {
if (peer->capa.mp[AID_INET1] == 0) {
	log_peer_warnx(&peer->conf,
	    "bad withdraw, %s disabled", aid2str(AID_INET1));
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_OPTATTR,
	    NULL((void *)0), 0);
	goto done;
}
}
while (len > 0) {
if (peer_has_add_path(peer, AID_INET1, CAPA_AP_RECV0x01)) {
	if (len <= sizeof(pathid)) {
		log_peer_warnx(&peer->conf,
		    "bad withdraw prefix");
		rde_update_err(peer, ERR_UPDATE,
		    ERR_UPD_NETWORK, NULL((void *)0), 0);
		goto done;
	}
	memcpy(&pathid, p, sizeof(pathid));
	pathid = ntohl(pathid)(__uint32_t)(__builtin_constant_p(pathid) ? (__uint32_t)(((__uint32_t
)(pathid) & 0xff) << 24 | ((__uint32_t)(pathid) &
 0xff00) << 8 | ((__uint32_t)(pathid) & 0xff0000) >>
| ((__uint32_t)(pathid) & 0xff000000) >> 24) : __swap32md
(pathid));
	p += sizeof(pathid);
	len -= sizeof(pathid);
} else
	pathid = 0;

if ((pos = nlri_get_prefix(p, len, &prefix,
    &prefixlen)) == -1) {
	/*
	 * the RFC does not mention what we should do in
	 * this case. Let's do the same as in the NLRI case.
	 */
	log_peer_warnx(&peer->conf, "bad withdraw prefix");
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_NETWORK,
	    NULL((void *)0), 0);
	goto done;
}
p += pos;
len -= pos;

rde_update_withdraw(peer, pathid, &prefix, prefixlen);
}

/* withdraw MP_UNREACH_NLRI if available */
if (mpa.unreach_len != 0) {
mpp = mpa.unreach;
mplen = mpa.unreach_len;
memcpy(&afi, mpp, 2);
mpp += 2;
mplen -= 2;
afi = ntohs(afi)(__uint16_t)(__builtin_constant_p(afi) ? (__uint16_t)(((__uint16_t
)(afi) & 0xffU) << 8 | ((__uint16_t)(afi) & 0xff00U
) >> 8) : __swap16md(afi));
safi = *mpp++;
mplen--;

if (afi2aid(afi, safi, &aid) == -1) {
	log_peer_warnx(&peer->conf,
	    "bad AFI/SAFI pair in withdraw");
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_OPTATTR,
	    NULL((void *)0), 0);
	goto done;
}

if (peer->capa.mp[aid] == 0) {
	log_peer_warnx(&peer->conf,
	    "bad withdraw, %s disabled", aid2str(aid));
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_OPTATTR,
	    NULL((void *)0), 0);
	goto done;
}

if ((state.aspath.flags & ~F_ATTR_MP_UNREACH0x00080) == 0 &&
    mplen == 0) {
	/* EoR marker */
	rde_peer_recv_eor(peer, aid);
}

while (mplen > 0) {
	if (peer_has_add_path(peer, aid, CAPA_AP_RECV0x01)) {
		if (mplen <= sizeof(pathid)) {
			log_peer_warnx(&peer->conf,
			    "bad %s withdraw prefix",
			    aid2str(aid));
			rde_update_err(peer, ERR_UPDATE,
			    ERR_UPD_OPTATTR,
			    mpa.unreach, mpa.unreach_len);
			goto done;
		}
		memcpy(&pathid, mpp, sizeof(pathid));
		pathid = ntohl(pathid)(__uint32_t)(__builtin_constant_p(pathid) ? (__uint32_t)(((__uint32_t
)(pathid) & 0xff) << 24 | ((__uint32_t)(pathid) &
 0xff00) << 8 | ((__uint32_t)(pathid) & 0xff0000) >>
| ((__uint32_t)(pathid) & 0xff000000) >> 24) : __swap32md
(pathid));
		mpp += sizeof(pathid);
		mplen -= sizeof(pathid);
	} else
		pathid = 0;

	switch (aid) {
	case AID_INET62:
		if ((pos = nlri_get_prefix6(mpp, mplen,
		    &prefix, &prefixlen)) == -1) {
			log_peer_warnx(&peer->conf,
			    "bad IPv6 withdraw prefix");
			rde_update_err(peer, ERR_UPDATE,
			    ERR_UPD_OPTATTR,
			    mpa.unreach, mpa.unreach_len);
			goto done;
		}
		break;
	case AID_VPN_IPv43:
		if ((pos = nlri_get_vpn4(mpp, mplen,
		    &prefix, &prefixlen, 1)) == -1) {
			log_peer_warnx(&peer->conf,
			    "bad VPNv4 withdraw prefix");
			rde_update_err(peer, ERR_UPDATE,
			    ERR_UPD_OPTATTR,
			    mpa.unreach, mpa.unreach_len);
			goto done;
		}
		break;
	case AID_VPN_IPv64:
		if ((pos = nlri_get_vpn6(mpp, mplen,
		    &prefix, &prefixlen, 1)) == -1) {
			log_peer_warnx(&peer->conf,
			    "bad VPNv6 withdraw prefix");
			rde_update_err(peer, ERR_UPDATE,
			    ERR_UPD_OPTATTR, mpa.unreach,
			    mpa.unreach_len);
			goto done;
		}
		break;
	case AID_FLOWSPECv45:
	case AID_FLOWSPECv66:
		/* ignore flowspec for now */
	default:
		/* ignore unsupported multiprotocol AF */
		mpp += mplen;
		mplen = 0;
		continue;
	}

	mpp += pos;
	mplen -= pos;

	rde_update_withdraw(peer, pathid, &prefix, prefixlen);
}

if ((state.aspath.flags & ~F_ATTR_MP_UNREACH0x00080) == 0)
	goto done;
}

/* shift to NLRI information */
p += 2 + attrpath_len;

/* parse nlri prefix */
if (nlri_len > 0) {
if (peer->capa.mp[AID_INET1] == 0) {
	log_peer_warnx(&peer->conf,
	    "bad update, %s disabled", aid2str(AID_INET1));
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_OPTATTR,
	    NULL((void *)0), 0);
	goto done;
}

/* inject open policy OTC attribute if needed */
if ((state.aspath.flags & F_ATTR_OTC0x01000) == 0) {
	uint32_t tmp;
	switch (peer->role) {
	case ROLE_CUSTOMER:
	case ROLE_RS_CLIENT:
	case ROLE_PEER:
		tmp = htonl(peer->conf.remote_as)(__uint32_t)(__builtin_constant_p(peer->conf.remote_as) ? (
__uint32_t)(((__uint32_t)(peer->conf.remote_as) & 0xff
) << 24 | ((__uint32_t)(peer->conf.remote_as) & 0xff00
) << 8 | ((__uint32_t)(peer->conf.remote_as) & 0xff0000
) >> 8 | ((__uint32_t)(peer->conf.remote_as) & 0xff000000
) >> 24) : __swap32md(peer->conf.remote_as));
		if (attr_optadd(&state.aspath,
		    ATTR_OPTIONAL0x80|ATTR_TRANSITIVE0x40, ATTR_OTC,
		    &tmp, sizeof(tmp)) == -1) {
			rde_update_err(peer, ERR_UPDATE,
			    ERR_UPD_ATTRLIST, NULL((void *)0), 0);
			goto done;
		}
		state.aspath.flags |= F_ATTR_OTC0x01000;
		break;
	default:
		break;
	}
}
}
while (nlri_len > 0) {
if (peer_has_add_path(peer, AID_INET1, CAPA_AP_RECV0x01)) {
	if (nlri_len <= sizeof(pathid)) {
		log_peer_warnx(&peer->conf,
		    "bad nlri prefix");
		rde_update_err(peer, ERR_UPDATE,
		    ERR_UPD_NETWORK, NULL((void *)0), 0);
		goto done;
	}
	memcpy(&pathid, p, sizeof(pathid));
	pathid = ntohl(pathid)(__uint32_t)(__builtin_constant_p(pathid) ? (__uint32_t)(((__uint32_t
)(pathid) & 0xff) << 24 | ((__uint32_t)(pathid) &
 0xff00) << 8 | ((__uint32_t)(pathid) & 0xff0000) >>
| ((__uint32_t)(pathid) & 0xff000000) >> 24) : __swap32md
(pathid));
	p += sizeof(pathid);
	nlri_len -= sizeof(pathid);
} else
	pathid = 0;

if ((pos = nlri_get_prefix(p, nlri_len, &prefix,
    &prefixlen)) == -1) {
	log_peer_warnx(&peer->conf, "bad nlri prefix");
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_NETWORK,
	    NULL((void *)0), 0);
	goto done;
}
p += pos;
nlri_len -= pos;

if (rde_update_update(peer, pathid, &state,
    &prefix, prefixlen) == -1)
	goto done;

}

/* add MP_REACH_NLRI if available */
if (mpa.reach_len != 0) {
mpp = mpa.reach;
mplen = mpa.reach_len;
memcpy(&afi, mpp, 2);
mpp += 2;
mplen -= 2;
afi = ntohs(afi)(__uint16_t)(__builtin_constant_p(afi) ? (__uint16_t)(((__uint16_t
)(afi) & 0xffU) << 8 | ((__uint16_t)(afi) & 0xff00U
) >> 8) : __swap16md(afi));
safi = *mpp++;
mplen--;

if (afi2aid(afi, safi, &aid) == -1) {
	log_peer_warnx(&peer->conf,
	    "bad AFI/SAFI pair in update");
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_OPTATTR,
	    NULL((void *)0), 0);
	goto done;
}

if (peer->capa.mp[aid] == 0) {
	log_peer_warnx(&peer->conf,
	    "bad update, %s disabled", aid2str(aid));
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_OPTATTR,
	    NULL((void *)0), 0);
	goto done;
}

if (aid == AID_INET62) {
	/* inject open policy OTC attribute if needed */
	if ((state.aspath.flags & F_ATTR_OTC0x01000) == 0) {
		uint32_t tmp;
		switch (peer->role) {
		case ROLE_CUSTOMER:
		case ROLE_RS_CLIENT:
		case ROLE_PEER:
			tmp = htonl(peer->conf.remote_as)(__uint32_t)(__builtin_constant_p(peer->conf.remote_as) ? (
__uint32_t)(((__uint32_t)(peer->conf.remote_as) & 0xff
) << 24 | ((__uint32_t)(peer->conf.remote_as) & 0xff00
) << 8 | ((__uint32_t)(peer->conf.remote_as) & 0xff0000
) >> 8 | ((__uint32_t)(peer->conf.remote_as) & 0xff000000
) >> 24) : __swap32md(peer->conf.remote_as));
			if (attr_optadd(&state.aspath,
			    ATTR_OPTIONAL0x80|ATTR_TRANSITIVE0x40,
			    ATTR_OTC, &tmp,
			    sizeof(tmp)) == -1) {
				rde_update_err(peer, ERR_UPDATE,
				    ERR_UPD_ATTRLIST, NULL((void *)0), 0);
				goto done;
			}
			state.aspath.flags |= F_ATTR_OTC0x01000;
			break;
		default:
			break;
		}
	}
} else {
	/* Only IPv4 and IPv6 unicast do OTC handling */
	state.aspath.flags &= ~F_ATTR_OTC_LEAK0x02000;
}

/* unlock the previously locked nexthop, it is no longer used */
nexthop_unref(state.nexthop);
state.nexthop = NULL((void *)0);
if ((pos = rde_get_mp_nexthop(mpp, mplen, aid, peer,
    &state)) == -1) {
	log_peer_warnx(&peer->conf, "bad nlri nexthop");
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_OPTATTR,
	    mpa.reach, mpa.reach_len);
	goto done;
}
mpp += pos;
mplen -= pos;

while (mplen > 0) {
	if (peer_has_add_path(peer, aid, CAPA_AP_RECV0x01)) {
		if (mplen <= sizeof(pathid)) {
			log_peer_warnx(&peer->conf,
			    "bad %s nlri prefix", aid2str(aid));
			rde_update_err(peer, ERR_UPDATE,
			    ERR_UPD_OPTATTR,
			    mpa.reach, mpa.reach_len);
			goto done;
		}
		memcpy(&pathid, mpp, sizeof(pathid));
		pathid = ntohl(pathid)(__uint32_t)(__builtin_constant_p(pathid) ? (__uint32_t)(((__uint32_t
)(pathid) & 0xff) << 24 | ((__uint32_t)(pathid) &
 0xff00) << 8 | ((__uint32_t)(pathid) & 0xff0000) >>
| ((__uint32_t)(pathid) & 0xff000000) >> 24) : __swap32md
(pathid));
		mpp += sizeof(pathid);
		mplen -= sizeof(pathid);
	} else
		pathid = 0;

	switch (aid) {
	case AID_INET62:
		if ((pos = nlri_get_prefix6(mpp, mplen,
		    &prefix, &prefixlen)) == -1) {
			log_peer_warnx(&peer->conf,
			    "bad IPv6 nlri prefix");
			rde_update_err(peer, ERR_UPDATE,
			    ERR_UPD_OPTATTR,
			    mpa.reach, mpa.reach_len);
			goto done;
		}
		break;
	case AID_VPN_IPv43:
		if ((pos = nlri_get_vpn4(mpp, mplen,
		    &prefix, &prefixlen, 0)) == -1) {
			log_peer_warnx(&peer->conf,
			    "bad VPNv4 nlri prefix");
			rde_update_err(peer, ERR_UPDATE,
			    ERR_UPD_OPTATTR,
			    mpa.reach, mpa.reach_len);
			goto done;
		}
		break;
	case AID_VPN_IPv64:
		if ((pos = nlri_get_vpn6(mpp, mplen,
		    &prefix, &prefixlen, 0)) == -1) {
			log_peer_warnx(&peer->conf,
			    "bad VPNv6 nlri prefix");
			rde_update_err(peer, ERR_UPDATE,
			    ERR_UPD_OPTATTR,
			    mpa.reach, mpa.reach_len);
			goto done;
		}
		break;
	case AID_FLOWSPECv45:
	case AID_FLOWSPECv66:
		/* ignore flowspec for now */
	default:
		/* ignore unsupported multiprotocol AF */
		mpp += mplen;
		mplen = 0;
		continue;
	}

	mpp += pos;
	mplen -= pos;

	if (rde_update_update(peer, pathid, &state,
	    &prefix, prefixlen) == -1)
		goto done;
}
}

1880done:
rde_filterstate_clean(&state);
1882}

1884/*
* Check if path_id is already in use.
*/
1887static int
1888pathid_conflict(struct rib_entry *re, uint32_t pathid)
1889{
struct prefix *p;

if (re == NULL((void *)0))
return 0;

TAILQ_FOREACH(p, &re->prefix_h, entry.list.rib)for((p) = ((&re->prefix_h)->tqh_first); (p) != ((void
 *)0); (p) = ((p)->entry.list.rib.tqe_next))
if (p->path_id_tx == pathid)
	return 1;
return 0;
1899}

1901/*
* Assign a send side path_id to all paths.
*/
1904static uint32_t
1905pathid_assign(struct rde_peer *peer, uint32_t path_id,
  struct bgpd_addr *prefix, uint8_t prefixlen)
1907{
struct rib_entry *re;
uint32_t path_id_tx;

/* If peer has no add-path use the per peer path_id */
if (!peer_has_add_path(peer, prefix->aid, CAPA_AP_RECV0x01))
return peer->path_id_tx;

/* peer uses add-path, therefore new path_ids need to be assigned */
re = rib_get_addr(rib_byid(RIB_ADJ_IN0), prefix, prefixlen);
if (re != NULL((void *)0)) {
struct prefix *p;

p = prefix_bypeer(re, peer, path_id);
if (p != NULL((void *)0))
	return p->path_id_tx;
}

/*
* Assign new local path_id, must be an odd number.
* Even numbers are used by the per peer path_id_tx.
*/
do {
path_id_tx = arc4random() | 1;
} while (pathid_conflict(re, path_id_tx));

return path_id_tx;
1934}

1936int
1937rde_update_update(struct rde_peer *peer, uint32_t path_id,
  struct filterstate *in, struct bgpd_addr *prefix, uint8_t prefixlen)
1939{
struct filterstate	 state;
enum filter_actions	 action;
uint32_t		 path_id_tx;
uint16_t		 i;
uint8_t			 roa_state, aspa_state;
const char		*wmsg = "filtered, withdraw";

peer->stats.prefix_rcvd_update++;

roa_state = rde_roa_validity(&rde_roa, prefix, prefixlen,
   aspath_origin(in->aspath.aspath));
aspa_state = rde_aspa_validity(peer, &in->aspath, prefix->aid);
rde_filterstate_set_vstate(in, roa_state, aspa_state);

path_id_tx = pathid_assign(peer, path_id, prefix, prefixlen);
/* add original path to the Adj-RIB-In */
if (prefix_update(rib_byid(RIB_ADJ_IN0), peer, path_id, path_id_tx,
   in, prefix, prefixlen) == 1)
peer->stats.prefix_cnt++;

/* max prefix checker */
if (peer->conf.max_prefix &&
   peer->stats.prefix_cnt > peer->conf.max_prefix) {
log_peer_warnx(&peer->conf, "prefix limit reached (>%u/%u)",
    peer->stats.prefix_cnt, peer->conf.max_prefix);
rde_update_err(peer, ERR_CEASE, ERR_CEASE_MAX_PREFIX, NULL((void *)0), 0);
return (-1);
}

if (in->aspath.flags & F_ATTR_PARSE_ERR0x10000)
wmsg = "path invalid, withdraw";

for (i = RIB_LOC_START1; i < rib_size; i++) {
struct rib *rib = rib_byid(i);
if (rib == NULL((void *)0))
	continue;
rde_filterstate_copy(&state, in);
/* input filter */
action = rde_filter(rib->in_rules, peer, peer, prefix,
    prefixlen, &state);

if (action == ACTION_ALLOW) {
	rde_update_log("update", i, peer,
	    &state.nexthop->exit_nexthop, prefix,
	    prefixlen);
	prefix_update(rib, peer, path_id, path_id_tx, &state,
	    prefix, prefixlen);
} else if (prefix_withdraw(rib, peer, path_id, prefix,
    prefixlen)) {
	rde_update_log(wmsg, i, peer,
	    NULL((void *)0), prefix, prefixlen);
}

rde_filterstate_clean(&state);
}
return (0);
1996}

1998void
1999rde_update_withdraw(struct rde_peer *peer, uint32_t path_id,
  struct bgpd_addr *prefix, uint8_t prefixlen)
2001{
uint16_t i;

for (i = RIB_LOC_START1; i < rib_size; i++) {
struct rib *rib = rib_byid(i);
if (rib == NULL((void *)0))
	continue;
if (prefix_withdraw(rib, peer, path_id, prefix, prefixlen))
	rde_update_log("withdraw", i, peer, NULL((void *)0), prefix,
	    prefixlen);
}

/* remove original path form the Adj-RIB-In */
if (prefix_withdraw(rib_byid(RIB_ADJ_IN0), peer, path_id,
   prefix, prefixlen))
peer->stats.prefix_cnt--;

peer->stats.prefix_rcvd_withdraw++;
2019}

2021/*
* BGP UPDATE parser functions
*/

2025/* attribute parser specific macros */
2026#define UPD_READ(t, p, plen, n) \
do { \
memcpy(t, p, n); \
p += n; \
plen += n; \
} while (0)

2033#define CHECK_FLAGS(s, t, m)	\
(((s) & ~(ATTR_DEFMASK(0x0f | 0x10) | (m))) == (t))

2036int
2037rde_attr_parse(u_char *p, uint16_t len, struct rde_peer *peer,
  struct filterstate *state, struct mpattr *mpa)
2039{
struct bgpd_addr nexthop;
struct rde_aspath *a = &state->aspath;
u_char		*op = p, *npath;
uint32_t	 tmp32, zero = 0;
int		 error;
uint16_t	 attr_len, nlen;
uint16_t	 plen = 0;
uint8_t		 flags, type, tmp8;

if (len < 3) {
2050bad_len:
rde_update_err(peer, ERR_UPDATE, ERR_UPD_ATTRLEN, op, len);
return (-1);
}

UPD_READ(&flags, p, plen, 1);
UPD_READ(&type, p, plen, 1);

if (flags & ATTR_EXTLEN0x10) {
if (len - plen < 2)
	goto bad_len;
UPD_READ(&attr_len, p, plen, 2);
attr_len = ntohs(attr_len)(__uint16_t)(__builtin_constant_p(attr_len) ? (__uint16_t)(((
__uint16_t)(attr_len) & 0xffU) << 8 | ((__uint16_t)
(attr_len) & 0xff00U) >> 8) : __swap16md(attr_len));
} else {
UPD_READ(&tmp8, p, plen, 1);
attr_len = tmp8;
}

if (len - plen < attr_len)
goto bad_len;

/* adjust len to the actual attribute size including header */
len = plen + attr_len;

switch (type) {
case ATTR_UNDEF:
/* ignore and drop path attributes with a type code of 0 */
plen += attr_len;
break;
case ATTR_ORIGIN:
if (attr_len != 1)
	goto bad_len;

if (!CHECK_FLAGS(flags, ATTR_WELL_KNOWN0x40, 0)) {
2084bad_flags:
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_ATTRFLAGS,
	    op, len);
	return (-1);
}

UPD_READ(&a->origin, p, plen, 1);
if (a->origin > ORIGIN_INCOMPLETE2) {
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_ORIGIN,
	    op, len);
	return (-1);
}
if (a->flags & F_ATTR_ORIGIN0x00001)
	goto bad_list;
a->flags |= F_ATTR_ORIGIN0x00001;
break;
case ATTR_ASPATH:
if (!CHECK_FLAGS(flags, ATTR_WELL_KNOWN0x40, 0))
	goto bad_flags;
error = aspath_verify(p, attr_len, peer_has_as4byte(peer),
    peer_accept_no_as_set(peer));
if (error == AS_ERR_SOFT-4) {
	/*
	 * soft errors like unexpected segment types are
	 * not considered fatal and the path is just
	 * marked invalid.
	 */
	a->flags |= F_ATTR_PARSE_ERR0x10000;
} else if (error != 0) {
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_ASPATH,
	    NULL((void *)0), 0);
	return (-1);
}
if (a->flags & F_ATTR_ASPATH0x00002)
	goto bad_list;
if (peer_has_as4byte(peer)) {
	npath = p;
	nlen = attr_len;
} else {
	npath = aspath_inflate(p, attr_len, &nlen);
	if (npath == NULL((void *)0))
		fatal("aspath_inflate");
}
if (error == AS_ERR_SOFT-4) {
	char *str;

	aspath_asprint(&str, npath, nlen);
	log_peer_warnx(&peer->conf, "bad ASPATH %s, "
	    "path invalidated and prefix withdrawn",
	    str ? str : "(bad aspath)");
	free(str);
}
a->flags |= F_ATTR_ASPATH0x00002;
a->aspath = aspath_get(npath, nlen);
if (npath != p)
	free(npath);
plen += attr_len;
break;
case ATTR_NEXTHOP:
if (attr_len != 4)
	goto bad_len;
if (!CHECK_FLAGS(flags, ATTR_WELL_KNOWN0x40, 0))
	goto bad_flags;
if (a->flags & F_ATTR_NEXTHOP0x00004)
	goto bad_list;
a->flags |= F_ATTR_NEXTHOP0x00004;

memset(&nexthop, 0, sizeof(nexthop));
nexthop.aid = AID_INET1;
UPD_READ(&nexthop.v4ba.v4.s_addr, p, plen, 4);
/*
 * Check if the nexthop is a valid IP address. We consider
 * multicast addresses as invalid.
 */
tmp32 = ntohl(nexthop.v4.s_addr)(__uint32_t)(__builtin_constant_p(nexthop.ba.v4.s_addr) ? (__uint32_t
)(((__uint32_t)(nexthop.ba.v4.s_addr) & 0xff) << 24
 | ((__uint32_t)(nexthop.ba.v4.s_addr) & 0xff00) <<
| ((__uint32_t)(nexthop.ba.v4.s_addr) & 0xff0000) >>
| ((__uint32_t)(nexthop.ba.v4.s_addr) & 0xff000000) >>
 24) : __swap32md(nexthop.ba.v4.s_addr));
if (IN_MULTICAST(tmp32)(((u_int32_t)(tmp32) & ((u_int32_t)(0xf0000000))) == ((u_int32_t
)(0xe0000000)))) {
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_NEXTHOP,
	    op, len);
	return (-1);
}
nexthop_unref(state->nexthop);	/* just to be sure */
state->nexthop = nexthop_get(&nexthop);
break;
case ATTR_MED:
if (attr_len != 4)
	goto bad_len;
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80, 0))
	goto bad_flags;
if (a->flags & F_ATTR_MED0x00010)
	goto bad_list;
a->flags |= F_ATTR_MED0x00010;

UPD_READ(&tmp32, p, plen, 4);
a->med = ntohl(tmp32)(__uint32_t)(__builtin_constant_p(tmp32) ? (__uint32_t)(((__uint32_t
)(tmp32) & 0xff) << 24 | ((__uint32_t)(tmp32) &
 0xff00) << 8 | ((__uint32_t)(tmp32) & 0xff0000) >>
| ((__uint32_t)(tmp32) & 0xff000000) >> 24) : __swap32md
(tmp32));
break;
case ATTR_LOCALPREF:
if (attr_len != 4)
	goto bad_len;
if (!CHECK_FLAGS(flags, ATTR_WELL_KNOWN0x40, 0))
	goto bad_flags;
if (peer->conf.ebgp) {
	/* ignore local-pref attr on non ibgp peers */
	plen += attr_len;
	break;
}
if (a->flags & F_ATTR_LOCALPREF0x00008)
	goto bad_list;
a->flags |= F_ATTR_LOCALPREF0x00008;

UPD_READ(&tmp32, p, plen, 4);
a->lpref = ntohl(tmp32)(__uint32_t)(__builtin_constant_p(tmp32) ? (__uint32_t)(((__uint32_t
)(tmp32) & 0xff) << 24 | ((__uint32_t)(tmp32) &
 0xff00) << 8 | ((__uint32_t)(tmp32) & 0xff0000) >>
| ((__uint32_t)(tmp32) & 0xff000000) >> 24) : __swap32md
(tmp32));
break;
case ATTR_ATOMIC_AGGREGATE:
if (attr_len != 0)
	goto bad_len;
if (!CHECK_FLAGS(flags, ATTR_WELL_KNOWN0x40, 0))
	goto bad_flags;
goto optattr;
case ATTR_AGGREGATOR:
if ((!peer_has_as4byte(peer) && attr_len != 6) ||
    (peer_has_as4byte(peer) && attr_len != 8)) {
	/*
	 * ignore attribute in case of error as per
	 * RFC 7606
	 */
	log_peer_warnx(&peer->conf, "bad AGGREGATOR, "
	    "attribute discarded");
	plen += attr_len;
	break;
}
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80|ATTR_TRANSITIVE0x40,
    ATTR_PARTIAL0x20))
	goto bad_flags;
if (!peer_has_as4byte(peer)) {
	/* need to inflate aggregator AS to 4-byte */
	u_char	t[8];
	t[0] = t[1] = 0;
	UPD_READ(&t[2], p, plen, 2);
	UPD_READ(&t[4], p, plen, 4);
	if (memcmp(t, &zero, sizeof(uint32_t)) == 0) {
		/* As per RFC7606 use "attribute discard". */
		log_peer_warnx(&peer->conf, "bad AGGREGATOR, "
		    "AS 0 not allowed, attribute discarded");
		break;
	}
	if (attr_optadd(a, flags, type, t,
	    sizeof(t)) == -1)
		goto bad_list;
	break;
}
/* 4-byte ready server take the default route */
if (memcmp(p, &zero, sizeof(uint32_t)) == 0) {
	/* As per RFC7606 use "attribute discard" here. */
	char *pfmt = log_fmt_peer(&peer->conf);
	log_debug("%s: bad AGGREGATOR, "
	    "AS 0 not allowed, attribute discarded", pfmt);
	free(pfmt);
	plen += attr_len;
	break;
}
goto optattr;
case ATTR_COMMUNITIES:
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80|ATTR_TRANSITIVE0x40,
    ATTR_PARTIAL0x20))
	goto bad_flags;
if (community_add(&state->communities, flags, p,
    attr_len) == -1) {
	/*
	 * mark update as bad and withdraw all routes as per
	 * RFC 7606
	 */
	a->flags |= F_ATTR_PARSE_ERR0x10000;
	log_peer_warnx(&peer->conf, "bad COMMUNITIES, "
	    "path invalidated and prefix withdrawn");
}
plen += attr_len;
break;
case ATTR_LARGE_COMMUNITIES:
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80|ATTR_TRANSITIVE0x40,
    ATTR_PARTIAL0x20))
	goto bad_flags;
if (community_large_add(&state->communities, flags, p,
    attr_len) == -1) {
	/*
	 * mark update as bad and withdraw all routes as per
	 * RFC 7606
	 */
	a->flags |= F_ATTR_PARSE_ERR0x10000;
	log_peer_warnx(&peer->conf, "bad LARGE COMMUNITIES, "
	    "path invalidated and prefix withdrawn");
}
plen += attr_len;
break;
case ATTR_EXT_COMMUNITIES:
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80|ATTR_TRANSITIVE0x40,
    ATTR_PARTIAL0x20))
	goto bad_flags;
if (community_ext_add(&state->communities, flags,
    peer->conf.ebgp, p, attr_len) == -1) {
	/*
	 * mark update as bad and withdraw all routes as per
	 * RFC 7606
	 */
	a->flags |= F_ATTR_PARSE_ERR0x10000;
	log_peer_warnx(&peer->conf, "bad EXT_COMMUNITIES, "
	    "path invalidated and prefix withdrawn");
}
plen += attr_len;
break;
case ATTR_ORIGINATOR_ID:
if (attr_len != 4)
	goto bad_len;
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80, 0))
	goto bad_flags;
goto optattr;
case ATTR_CLUSTER_LIST:
if (attr_len % 4 != 0)
	goto bad_len;
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80, 0))
	goto bad_flags;
goto optattr;
case ATTR_MP_REACH_NLRI:
if (attr_len < 5)
	goto bad_len;
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80, 0))
	goto bad_flags;
/* the validity is checked in rde_update_dispatch() */
if (a->flags & F_ATTR_MP_REACH0x00040)
	goto bad_list;
a->flags |= F_ATTR_MP_REACH0x00040;

mpa->reach = p;
mpa->reach_len = attr_len;
plen += attr_len;
break;
case ATTR_MP_UNREACH_NLRI:
if (attr_len < 3)
	goto bad_len;
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80, 0))
	goto bad_flags;
/* the validity is checked in rde_update_dispatch() */
if (a->flags & F_ATTR_MP_UNREACH0x00080)
	goto bad_list;
a->flags |= F_ATTR_MP_UNREACH0x00080;

mpa->unreach = p;
mpa->unreach_len = attr_len;
plen += attr_len;
break;
case ATTR_AS4_AGGREGATOR:
if (attr_len != 8) {
	/* see ATTR_AGGREGATOR ... */
	log_peer_warnx(&peer->conf, "bad AS4_AGGREGATOR, "
	    "attribute discarded");
	plen += attr_len;
	break;
}
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80|ATTR_TRANSITIVE0x40,
    ATTR_PARTIAL0x20))
	goto bad_flags;
if (memcmp(p, &zero, sizeof(uint32_t)) == 0) {
	/* As per RFC6793 use "attribute discard" here. */
	log_peer_warnx(&peer->conf, "bad AS4_AGGREGATOR, "
	    "AS 0 not allowed, attribute discarded");
	plen += attr_len;
	break;
}
a->flags |= F_ATTR_AS4BYTE_NEW0x00100;
goto optattr;
case ATTR_AS4_PATH:
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80|ATTR_TRANSITIVE0x40,
    ATTR_PARTIAL0x20))
	goto bad_flags;
if ((error = aspath_verify(p, attr_len, 1,
    peer_accept_no_as_set(peer))) != 0) {
	/* As per RFC6793 use "attribute discard" here. */
	log_peer_warnx(&peer->conf, "bad AS4_PATH, "
	    "attribute discarded");
	plen += attr_len;
	break;
}
a->flags |= F_ATTR_AS4BYTE_NEW0x00100;
goto optattr;
case ATTR_OTC:
if (attr_len != 4) {
	/* treat-as-withdraw */
	a->flags |= F_ATTR_PARSE_ERR0x10000;
	log_peer_warnx(&peer->conf, "bad OTC, "
	    "path invalidated and prefix withdrawn");
	plen += attr_len;
	break;
}
if (!CHECK_FLAGS(flags, ATTR_OPTIONAL0x80|ATTR_TRANSITIVE0x40,
    ATTR_PARTIAL0x20))
	goto bad_flags;
switch (peer->role) {
case ROLE_PROVIDER:
case ROLE_RS:
	a->flags |= F_ATTR_OTC_LEAK0x02000;
	break;
case ROLE_PEER:
	memcpy(&tmp32, p, sizeof(tmp32));
	tmp32 = ntohl(tmp32)(__uint32_t)(__builtin_constant_p(tmp32) ? (__uint32_t)(((__uint32_t
)(tmp32) & 0xff) << 24 | ((__uint32_t)(tmp32) &
 0xff00) << 8 | ((__uint32_t)(tmp32) & 0xff0000) >>
| ((__uint32_t)(tmp32) & 0xff000000) >> 24) : __swap32md
(tmp32));
	if (tmp32 != peer->conf.remote_as)
		a->flags |= F_ATTR_OTC_LEAK0x02000;
	break;
default:
	break;
}
a->flags |= F_ATTR_OTC0x01000;
goto optattr;
default:
if ((flags & ATTR_OPTIONAL0x80) == 0) {
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_UNKNWN_WK_ATTR,
	    op, len);
	return (-1);
}
2401optattr:
if (attr_optadd(a, flags, type, p, attr_len) == -1) {
2403bad_list:
	rde_update_err(peer, ERR_UPDATE, ERR_UPD_ATTRLIST,
	    NULL((void *)0), 0);
	return (-1);
}

plen += attr_len;
break;
}

return (plen);
2414}

2416int
2417rde_attr_add(struct filterstate *state, u_char *p, uint16_t len)
2418{
uint16_t	 attr_len;
uint16_t	 plen = 0;
uint8_t		 flags;
uint8_t		 type;
uint8_t		 tmp8;

if (len < 3)
return (-1);

UPD_READ(&flags, p, plen, 1);
UPD_READ(&type, p, plen, 1);

if (flags & ATTR_EXTLEN0x10) {
if (len - plen < 2)
	return (-1);
UPD_READ(&attr_len, p, plen, 2);
attr_len = ntohs(attr_len)(__uint16_t)(__builtin_constant_p(attr_len) ? (__uint16_t)(((
__uint16_t)(attr_len) & 0xffU) << 8 | ((__uint16_t)
(attr_len) & 0xff00U) >> 8) : __swap16md(attr_len));
} else {
UPD_READ(&tmp8, p, plen, 1);
attr_len = tmp8;
}

if (len - plen < attr_len)
return (-1);

switch (type) {
case ATTR_COMMUNITIES:
return community_add(&state->communities, flags, p, attr_len);
case ATTR_LARGE_COMMUNITIES:
return community_large_add(&state->communities, flags, p,
    attr_len);
case ATTR_EXT_COMMUNITIES:
return community_ext_add(&state->communities, flags, 0,
    p, attr_len);
}

if (attr_optadd(&state->aspath, flags, type, p, attr_len) == -1)
return (-1);
return (0);
2458}

2460#undef UPD_READ
2461#undef CHECK_FLAGS

2463uint8_t
2464rde_attr_missing(struct rde_aspath *a, int ebgp, uint16_t nlrilen)
2465{
/* ATTR_MP_UNREACH_NLRI may be sent alone */
if (nlrilen == 0 && a->flags & F_ATTR_MP_UNREACH0x00080 &&
   (a->flags & F_ATTR_MP_REACH0x00040) == 0)
return (0);

if ((a->flags & F_ATTR_ORIGIN0x00001) == 0)
return (ATTR_ORIGIN);
if ((a->flags & F_ATTR_ASPATH0x00002) == 0)
return (ATTR_ASPATH);
if ((a->flags & F_ATTR_MP_REACH0x00040) == 0 &&
   (a->flags & F_ATTR_NEXTHOP0x00004) == 0)
return (ATTR_NEXTHOP);
if (!ebgp)
if ((a->flags & F_ATTR_LOCALPREF0x00008) == 0)
	return (ATTR_LOCALPREF);
return (0);
2482}

2484int
2485rde_get_mp_nexthop(u_char *data, uint16_t len, uint8_t aid,
  struct rde_peer *peer, struct filterstate *state)
2487{
struct bgpd_addr	nexthop;
uint8_t			totlen, nhlen;

if (len == 0)
return (-1);

nhlen = *data++;
totlen = 1;
len--;

if (nhlen + 1 > len)
return (-1);

memset(&nexthop, 0, sizeof(nexthop));
switch (aid) {
case AID_INET62:
/*
 * RFC2545 describes that there may be a link-local
 * address carried in nexthop. Yikes!
 * This is not only silly, it is wrong and we just ignore
 * this link-local nexthop. The bgpd session doesn't run
 * over the link-local address so why should all other
 * traffic.
 */
if (nhlen != 16 && nhlen != 32) {
	log_peer_warnx(&peer->conf, "bad %s nexthop, "
	    "bad size %d", aid2str(aid), nhlen);
	return (-1);
}
memcpy(&nexthop.v6ba.v6.s6_addr__u6_addr.__u6_addr8, data, 16);
nexthop.aid = AID_INET62;
if (IN6_IS_ADDR_LINKLOCAL(&nexthop.v6)(((&nexthop.ba.v6)->__u6_addr.__u6_addr8[0] == 0xfe) &&
 (((&nexthop.ba.v6)->__u6_addr.__u6_addr8[1] & 0xc0
) == 0x80))) {
	if (peer->local_if_scope != 0) {
		nexthop.scope_id = peer->local_if_scope;
	} else {
		log_peer_warnx(&peer->conf,
		    "unexpected link-local nexthop: %s",
		    log_addr(&nexthop));
		return (-1);
	}
}
break;
case AID_VPN_IPv43:
/*
 * Neither RFC4364 nor RFC3107 specify the format of the
 * nexthop in an explicit way. The quality of RFC went down
 * the toilet the larger the number got.
 * RFC4364 is very confusing about VPN-IPv4 address and the
 * VPN-IPv4 prefix that carries also a MPLS label.
 * So the nexthop is a 12-byte address with a 64bit RD and
 * an IPv4 address following. In the nexthop case the RD can
 * be ignored.
 * Since the nexthop has to be in the main IPv4 table just
 * create an AID_INET nexthop. So we don't need to handle
 * AID_VPN_IPv4 in nexthop and kroute.
 */
if (nhlen != 12) {
	log_peer_warnx(&peer->conf, "bad %s nexthop, "
	    "bad size %d", aid2str(aid), nhlen);
	return (-1);
}
nexthop.aid = AID_INET1;
memcpy(&nexthop.v4ba.v4, data + sizeof(uint64_t),
    sizeof(nexthop.v4ba.v4));
break;
case AID_VPN_IPv64:
if (nhlen != 24) {
	log_peer_warnx(&peer->conf, "bad %s nexthop, "
	    "bad size %d", aid2str(aid), nhlen);
	return (-1);
}
memcpy(&nexthop.v6ba.v6, data + sizeof(uint64_t),
    sizeof(nexthop.v6ba.v6));
nexthop.aid = AID_INET62;
if (IN6_IS_ADDR_LINKLOCAL(&nexthop.v6)(((&nexthop.ba.v6)->__u6_addr.__u6_addr8[0] == 0xfe) &&
 (((&nexthop.ba.v6)->__u6_addr.__u6_addr8[1] & 0xc0
) == 0x80))) {
	if (peer->local_if_scope != 0) {
		nexthop.scope_id = peer->local_if_scope;
	} else {
		log_peer_warnx(&peer->conf,
		    "unexpected link-local nexthop: %s",
		    log_addr(&nexthop));
		return (-1);
	}
}
break;
case AID_FLOWSPECv45:
case AID_FLOWSPECv66:
/* nexthop must be 0 and ignored for flowspec */
if (nhlen != 0) {
	log_peer_warnx(&peer->conf, "bad %s nexthop, "
	    "bad size %d", aid2str(aid), nhlen);
	return (-1);
}
/* also ignore reserved (old SNPA) field as per RFC4760 */
return (totlen + 1);
default:
log_peer_warnx(&peer->conf, "bad multiprotocol nexthop, "
    "bad AID");
return (-1);
}

state->nexthop = nexthop_get(&nexthop);

/* ignore reserved (old SNPA) field as per RFC4760 */
totlen += nhlen + 1;

return (totlen);
2595}

2597void
2598rde_update_err(struct rde_peer *peer, uint8_t error, uint8_t suberr,
  void *data, uint16_t size)
2600{
struct ibuf	*wbuf;

if ((wbuf = imsg_create(ibuf_se, IMSG_UPDATE_ERR, peer->conf.id, 0,
   size + sizeof(error) + sizeof(suberr))) == NULL((void *)0))
fatal("%s %d imsg_create error", __func__, __LINE__2605);
if (imsg_add(wbuf, &error, sizeof(error)) == -1 ||
   imsg_add(wbuf, &suberr, sizeof(suberr)) == -1 ||
   imsg_add(wbuf, data, size) == -1)
fatal("%s %d imsg_add error", __func__, __LINE__2609);
imsg_close(ibuf_se, wbuf);
peer->state = PEER_ERR;
2612}

2614void
2615rde_update_log(const char *message, uint16_t rid,
  const struct rde_peer *peer, const struct bgpd_addr *next,
  const struct bgpd_addr *prefix, uint8_t prefixlen)
2618{
char		*l = NULL((void *)0);
char		*n = NULL((void *)0);
char		*p = NULL((void *)0);

if (!((conf->log & BGPD_LOG_UPDATES0x0001) ||
   (peer->flags & PEERFLAG_LOG_UPDATES0x02)))
return;

if (next != NULL((void *)0))
if (asprintf(&n, " via %s", log_addr(next)) == -1)
	n = NULL((void *)0);
if (asprintf(&p, "%s/%u", log_addr(prefix), prefixlen) == -1)
p = NULL((void *)0);
l = log_fmt_peer(&peer->conf);
log_info("Rib %s: %s AS%s: %s %s%s", rib_byid(rid)->name,
   l, log_as(peer->conf.remote_as), message,
   p ? p : "out of memory", n ? n : "");

free(l);
free(n);
free(p);
2640}

2642/*
* 4-Byte ASN helper function.
* Two scenarios need to be considered:
* - NEW session with NEW attributes present -> just remove the attributes
* - OLD session with NEW attributes present -> try to merge them
*/
2648void
2649rde_as4byte_fixup(struct rde_peer *peer, struct rde_aspath *a)
2650{
struct attr	*nasp, *naggr, *oaggr;
uint32_t	 as;

/*
* if either ATTR_AS4_AGGREGATOR or ATTR_AS4_PATH is present
* try to fixup the attributes.
* Do not fixup if F_ATTR_PARSE_ERR is set.
*/
if (!(a->flags & F_ATTR_AS4BYTE_NEW0x00100) || a->flags & F_ATTR_PARSE_ERR0x10000)
return;

/* first get the attributes */
nasp = attr_optget(a, ATTR_AS4_PATH);
naggr = attr_optget(a, ATTR_AS4_AGGREGATOR);

if (peer_has_as4byte(peer)) {
/* NEW session using 4-byte ASNs */
if (nasp) {
	log_peer_warnx(&peer->conf, "uses 4-byte ASN "
	    "but sent AS4_PATH attribute.");
	attr_free(a, nasp);
}
if (naggr) {
	log_peer_warnx(&peer->conf, "uses 4-byte ASN "
	    "but sent AS4_AGGREGATOR attribute.");
	attr_free(a, naggr);
}
return;
}
/* OLD session using 2-byte ASNs */
/* try to merge the new attributes into the old ones */
if ((oaggr = attr_optget(a, ATTR_AGGREGATOR))) {
memcpy(&as, oaggr->data, sizeof(as));
if (ntohl(as)(__uint32_t)(__builtin_constant_p(as) ? (__uint32_t)(((__uint32_t
)(as) & 0xff) << 24 | ((__uint32_t)(as) & 0xff00
) << 8 | ((__uint32_t)(as) & 0xff0000) >> 8 |
 ((__uint32_t)(as) & 0xff000000) >> 24) : __swap32md
(as)) != AS_TRANS23456) {
	/* per RFC ignore AS4_PATH and AS4_AGGREGATOR */
	if (nasp)
		attr_free(a, nasp);
	if (naggr)
		attr_free(a, naggr);
	return;
}
if (naggr) {
	/* switch over to new AGGREGATOR */
	attr_free(a, oaggr);
	if (attr_optadd(a, ATTR_OPTIONAL0x80 | ATTR_TRANSITIVE0x40,
	    ATTR_AGGREGATOR, naggr->data, naggr->len))
		fatalx("attr_optadd failed but impossible");
}
}
/* there is no need for AS4_AGGREGATOR any more */
if (naggr)
attr_free(a, naggr);

/* merge AS4_PATH with ASPATH */
if (nasp)
aspath_merge(a, nasp);
2707}


2710uint8_t
2711rde_aspa_validity(struct rde_peer *peer, struct rde_aspath *asp, uint8_t aid)
2712{
if (!peer->conf.ebgp)	/* ASPA is only performed on ebgp sessions */
return ASPA_NEVER_KNOWN0x08;
if (aid != AID_INET1 && aid != AID_INET62) /* skip uncovered aids */
return ASPA_NEVER_KNOWN0x08;

2718#ifdef MAYBE
/*
* By default enforce neighbor-as is set for all ebgp sessions.
* So if a admin disables this check should we really "reenable"
* it here in such a dubious way?
* This just fails the ASPA validation for these paths so maybe
* this can be helpful. But it is not transparent to the admin.
*/

/* skip neighbor-as check for transparent RS sessions */
if (peer->role != ROLE_RS_CLIENT &&
   peer->conf.enforce_as != ENFORCE_AS_ON) {
uint32_t fas;

fas = aspath_neighbor(asp->aspath);
if (peer->conf.remote_as != fas)
	return ASPA_INVALID0x01;
}
2736#endif

/* if no role is set, the outcome is unknown */
if (peer->role == ROLE_NONE)
return ASPA_UNKNOWN0x00;

if (peer->role == ROLE_CUSTOMER)
return asp->aspa_state.downup;
else
return asp->aspa_state.onlyup;
2746}

2748/*
* route reflector helper function
*/
2751void
2752rde_reflector(struct rde_peer *peer, struct rde_aspath *asp)
2753{
struct attr	*a;
uint8_t		*p;
uint16_t	 len;
uint32_t	 id;

/* do not consider updates with parse errors */
if (asp->flags & F_ATTR_PARSE_ERR0x10000)
return;

/* check for originator id if eq router_id drop */
if ((a = attr_optget(asp, ATTR_ORIGINATOR_ID)) != NULL((void *)0)) {
if (memcmp(&conf->bgpid, a->data, sizeof(conf->bgpid)) == 0) {
	/* this is coming from myself */
	asp->flags |= F_ATTR_LOOP0x00200;
	return;
}
} else if (conf->flags & BGPD_FLAG_REFLECTOR0x0004) {
if (peer->conf.ebgp)
	id = conf->bgpid;
else
	id = htonl(peer->remote_bgpid)(__uint32_t)(__builtin_constant_p(peer->remote_bgpid) ? (__uint32_t
)(((__uint32_t)(peer->remote_bgpid) & 0xff) << 24
 | ((__uint32_t)(peer->remote_bgpid) & 0xff00) <<
| ((__uint32_t)(peer->remote_bgpid) & 0xff0000) >>
| ((__uint32_t)(peer->remote_bgpid) & 0xff000000) >>
 24) : __swap32md(peer->remote_bgpid));
if (attr_optadd(asp, ATTR_OPTIONAL0x80, ATTR_ORIGINATOR_ID,
    &id, sizeof(uint32_t)) == -1)
	fatalx("attr_optadd failed but impossible");
}

/* check for own id in the cluster list */
if (conf->flags & BGPD_FLAG_REFLECTOR0x0004) {
if ((a = attr_optget(asp, ATTR_CLUSTER_LIST)) != NULL((void *)0)) {
	for (len = 0; len < a->len;
	    len += sizeof(conf->clusterid))
		/* check if coming from my cluster */
		if (memcmp(&conf->clusterid, a->data + len,
		    sizeof(conf->clusterid)) == 0) {
			asp->flags |= F_ATTR_LOOP0x00200;
			return;
		}

	/* prepend own clusterid by replacing attribute */
	len = a->len + sizeof(conf->clusterid);
	if (len < a->len)
		fatalx("rde_reflector: cluster-list overflow");
	if ((p = malloc(len)) == NULL((void *)0))
		fatal("rde_reflector");
	memcpy(p, &conf->clusterid, sizeof(conf->clusterid));
	memcpy(p + sizeof(conf->clusterid), a->data, a->len);
	attr_free(asp, a);
	if (attr_optadd(asp, ATTR_OPTIONAL0x80, ATTR_CLUSTER_LIST,
	    p, len) == -1)
		fatalx("attr_optadd failed but impossible");
	free(p);
} else if (attr_optadd(asp, ATTR_OPTIONAL0x80, ATTR_CLUSTER_LIST,
    &conf->clusterid, sizeof(conf->clusterid)) == -1)
	fatalx("attr_optadd failed but impossible");
}
2809}

2811/*
* control specific functions
*/
2814static void
2815rde_dump_rib_as(struct prefix *p, struct rde_aspath *asp, pid_t pid, int flags,
  int adjout)
2817{
struct ctl_show_rib	 rib;
struct ibuf		*wbuf;
struct attr		*a;
struct nexthop		*nexthop;
struct rib_entry	*re;
struct prefix		*xp;
struct rde_peer		*peer;
time_t			 staletime;
size_t			 aslen;
uint8_t			 l;

nexthop = prefix_nexthop(p);
peer = prefix_peer(p);
memset(&rib, 0, sizeof(rib));
rib.age = getmonotime() - p->lastchange;
rib.local_pref = asp->lpref;
rib.med = asp->med;
rib.weight = asp->weight;
strlcpy(rib.descr, peer->conf.descr, sizeof(rib.descr));
memcpy(&rib.remote_addr, &peer->remote_addr,
   sizeof(rib.remote_addr));
rib.remote_id = peer->remote_bgpid;
if (nexthop != NULL((void *)0)) {
rib.exit_nexthop = nexthop->exit_nexthop;
rib.true_nexthop = nexthop->true_nexthop;
} else {
/* announced network can have a NULL nexthop */
rib.exit_nexthop.aid = p->pt->aid;
rib.true_nexthop.aid = p->pt->aid;
}
pt_getaddr(p->pt, &rib.prefix);
rib.prefixlen = p->pt->prefixlen;
rib.origin = asp->origin;
rib.roa_validation_state = prefix_roa_vstate(p);
rib.aspa_validation_state = prefix_aspa_vstate(p);
rib.dmetric = p->dmetric;
rib.flags = 0;
if (!adjout) {
re = prefix_re(p);
TAILQ_FOREACH(xp, &re->prefix_h, entry.list.rib)for((xp) = ((&re->prefix_h)->tqh_first); (xp) != ((
void *)0); (xp) = ((xp)->entry.list.rib.tqe_next)) {
	switch (xp->dmetric) {
	case PREFIX_DMETRIC_BEST5:
		if (xp == p)
			rib.flags |= F_PREF_BEST0x002;
		break;
	case PREFIX_DMETRIC_ECMP4:
		if (xp == p)
			rib.flags |= F_PREF_ECMP0x100;
		break;
	case PREFIX_DMETRIC_AS_WIDE3:
		if (xp == p)
			rib.flags |= F_PREF_AS_WIDE0x200;
		break;
	default:
		xp = NULL((void *)0);	/* stop loop */
		break;
	}
	if (xp == NULL((void *)0) || xp == p)
		break;
}
}
if (!peer->conf.ebgp)
rib.flags |= F_PREF_INTERNAL0x004;
if (asp->flags & F_PREFIX_ANNOUNCED0x00400)
rib.flags |= F_PREF_ANNOUNCE0x008;
if (prefix_eligible(p))
rib.flags |= F_PREF_ELIGIBLE0x001;
/* otc loop includes parse err so skip the latter if the first is set */
if (asp->flags & F_ATTR_OTC_LEAK0x02000)
rib.flags |= F_PREF_OTC_LEAK0x080;
else if (asp->flags & F_ATTR_PARSE_ERR0x10000)
rib.flags |= F_PREF_INVALID0x020;
staletime = peer->staletime[p->pt->aid];
if (staletime && p->lastchange <= staletime)
rib.flags |= F_PREF_STALE0x010;
if (!adjout) {
if (peer_has_add_path(peer, p->pt->aid, CAPA_AP_RECV0x01)) {
	rib.path_id = p->path_id;
	rib.flags |= F_PREF_PATH_ID0x040;
}
} else {
if (peer_has_add_path(peer, p->pt->aid, CAPA_AP_SEND0x02)) {
	rib.path_id = p->path_id_tx;
	rib.flags |= F_PREF_PATH_ID0x040;
}
}
aslen = aspath_length(asp->aspath);

if ((wbuf = imsg_create(ibuf_se_ctl, IMSG_CTL_SHOW_RIB, 0, pid,
   sizeof(rib) + aslen)) == NULL((void *)0))
return;
if (imsg_add(wbuf, &rib, sizeof(rib)) == -1 ||
   imsg_add(wbuf, aspath_dump(asp->aspath), aslen) == -1)
return;
imsg_close(ibuf_se_ctl, wbuf);

if (flags & F_CTL_DETAIL0x1000) {
struct rde_community *comm = prefix_communities(p);
size_t len = comm->nentries * sizeof(struct community);
if (comm->nentries > 0) {
	if (imsg_compose(ibuf_se_ctl,
	    IMSG_CTL_SHOW_RIB_COMMUNITIES, 0, pid, -1,
	    comm->communities, len) == -1)
		return;
}
for (l = 0; l < asp->others_len; l++) {
	if ((a = asp->others[l]) == NULL((void *)0))
		break;
	if ((wbuf = imsg_create(ibuf_se_ctl,
	    IMSG_CTL_SHOW_RIB_ATTR, 0, pid, 0)) == NULL((void *)0))
		return;
	if (attr_writebuf(wbuf, a->flags, a->type, a->data,
	    a->len) == -1) {
		ibuf_free(wbuf);
		return;
	}
	imsg_close(ibuf_se_ctl, wbuf);
}
}
2937}

2939int
2940rde_match_peer(struct rde_peer *p, struct ctl_neighbor *n)
2941{
char *s;

if (n && n->addr.aid) {
if (memcmp(&p->conf.remote_addr, &n->addr,
    sizeof(p->conf.remote_addr)))
	return 0;
} else if (n && n->descr[0]) {
s = n->is_group ? p->conf.group : p->conf.descr;
/* cannot trust n->descr to be properly terminated */
if (strncmp(s, n->descr, sizeof(n->descr)))
	return 0;
}
return 1;
2955}

2957static void
2958rde_dump_filter(struct prefix *p, struct ctl_show_rib_request *req, int adjout)
2959{
struct rde_aspath	*asp;

if (!rde_match_peer(prefix_peer(p), &req->neighbor))
return;

asp = prefix_aspath(p);
if ((req->flags & F_CTL_BEST0x8000) && p->dmetric != PREFIX_DMETRIC_BEST5)
return;
if ((req->flags & F_CTL_INVALID0x40000) &&
   (asp->flags & F_ATTR_PARSE_ERR0x10000) == 0)
return;
if ((req->flags & F_CTL_INELIGIBLE0x10000) && prefix_eligible(p))
return;
if ((req->flags & F_CTL_LEAKED0x20000) &&
   (asp->flags & F_ATTR_OTC_LEAK0x02000) == 0)
return;
if ((req->flags & F_CTL_HAS_PATHID0x800000)) {
/* Match against the transmit path id if adjout is used.  */
if (adjout) {
	if (req->path_id != p->path_id_tx)
		return;
} else {
	if (req->path_id != p->path_id)
		return;
}
}
if (req->as.type != AS_UNDEF &&
   !aspath_match(asp->aspath, &req->as, 0))
return;
if (req->community.flags != 0) {
if (!community_match(prefix_communities(p), &req->community,
    NULL((void *)0)))
	return;
}
if (!ovs_match(p, req->flags))
return;
if (!avs_match(p, req->flags))
return;
rde_dump_rib_as(p, asp, req->pid, req->flags, adjout);
2999}

3001static void
3002rde_dump_upcall(struct rib_entry *re, void *ptr)
3003{
struct rde_dump_ctx	*ctx = ptr;
struct prefix		*p;

if (re == NULL((void *)0))
return;
TAILQ_FOREACH(p, &re->prefix_h, entry.list.rib)for((p) = ((&re->prefix_h)->tqh_first); (p) != ((void
 *)0); (p) = ((p)->entry.list.rib.tqe_next))
rde_dump_filter(p, &ctx->req, 0);
3011}

3013static void
3014rde_dump_adjout_upcall(struct prefix *p, void *ptr)
3015{
struct rde_dump_ctx	*ctx = ptr;

if ((p->flags & PREFIX_FLAG_ADJOUT0x10) == 0)
fatalx("%s: prefix without PREFIX_FLAG_ADJOUT hit", __func__);
if (p->flags & (PREFIX_FLAG_WITHDRAW0x01 | PREFIX_FLAG_DEAD0x04))
return;
rde_dump_filter(p, &ctx->req, 1);
3023}

3025static int
3026rde_dump_throttled(void *arg)
3027{
struct rde_dump_ctx	*ctx = arg;

return (ctx->throttled != 0);
3031}

3033static void
3034rde_dump_done(void *arg, uint8_t aid)
3035{
struct rde_dump_ctx	*ctx = arg;
struct rde_peer		*peer;
u_int			 error;

if (ctx->req.flags & F_CTL_ADJ_OUT0x4000) {
peer = peer_match(&ctx->req.neighbor, ctx->peerid);
if (peer == NULL((void *)0))
	goto done;
ctx->peerid = peer->conf.id;
switch (ctx->req.type) {
case IMSG_CTL_SHOW_RIB:
	if (prefix_dump_new(peer, ctx->req.aid,
	    CTL_MSG_HIGH_MARK500, ctx, rde_dump_adjout_upcall,
	    rde_dump_done, rde_dump_throttled) == -1)
		goto nomem;
	break;
case IMSG_CTL_SHOW_RIB_PREFIX:
	if (prefix_dump_subtree(peer, &ctx->req.prefix,
	    ctx->req.prefixlen, CTL_MSG_HIGH_MARK500, ctx,
	    rde_dump_adjout_upcall, rde_dump_done,
	    rde_dump_throttled) == -1)
		goto nomem;
	break;
default:
	fatalx("%s: unsupported imsg type", __func__);
}
return;
}
3064done:
imsg_compose(ibuf_se_ctl, IMSG_CTL_END, 0, ctx->req.pid, -1, NULL((void *)0), 0);
LIST_REMOVE(ctx, entry)do { if ((ctx)->entry.le_next != ((void *)0)) (ctx)->entry
.le_next->entry.le_prev = (ctx)->entry.le_prev; *(ctx)->
entry.le_prev = (ctx)->entry.le_next; ; ; } while (0);
free(ctx);
return;

3070nomem:
log_warn(__func__);
error = CTL_RES_NOMEM;
imsg_compose(ibuf_se_ctl, IMSG_CTL_RESULT, 0, ctx->req.pid, -1, &error,
   sizeof(error));
return;
3076}

3078void
3079rde_dump_ctx_new(struct ctl_show_rib_request *req, pid_t pid,
  enum imsg_type type)
3081{
struct rde_dump_ctx	*ctx;
struct rib_entry	*re;
struct prefix		*p;
u_int			 error;
uint8_t			 hostplen, plen;
uint16_t		 rid;

if ((ctx = calloc(1, sizeof(*ctx))) == NULL((void *)0)) {
nomem:
log_warn(__func__);
error = CTL_RES_NOMEM;
imsg_compose(ibuf_se_ctl, IMSG_CTL_RESULT, 0, pid, -1, &error,
    sizeof(error));
free(ctx);
return;
}

memcpy(&ctx->req, req, sizeof(struct ctl_show_rib_request));
ctx->req.pid = pid;
ctx->req.type = type;

if (req->flags & (F_CTL_ADJ_IN0x2000 | F_CTL_INVALID0x40000)) {
rid = RIB_ADJ_IN0;
} else if (req->flags & F_CTL_ADJ_OUT0x4000) {
struct rde_peer *peer;

peer = peer_match(&req->neighbor, 0);
if (peer == NULL((void *)0)) {
	error = CTL_RES_NOSUCHPEER;
	imsg_compose(ibuf_se_ctl, IMSG_CTL_RESULT, 0, pid, -1,
	    &error, sizeof(error));
	free(ctx);
	return;
}
ctx->peerid = peer->conf.id;
switch (ctx->req.type) {
case IMSG_CTL_SHOW_RIB:
	if (prefix_dump_new(peer, ctx->req.aid,
	    CTL_MSG_HIGH_MARK500, ctx, rde_dump_adjout_upcall,
	    rde_dump_done, rde_dump_throttled) == -1)
		goto nomem;
	break;
case IMSG_CTL_SHOW_RIB_PREFIX:
	if (req->flags & F_LONGER0x0200) {
		if (prefix_dump_subtree(peer, &req->prefix,
		    req->prefixlen, CTL_MSG_HIGH_MARK500, ctx,
		    rde_dump_adjout_upcall,
		    rde_dump_done, rde_dump_throttled) == -1)
			goto nomem;
		break;
	}
	switch (req->prefix.aid) {
	case AID_INET1:
	case AID_VPN_IPv43:
		hostplen = 32;
		break;
	case AID_INET62:
	case AID_VPN_IPv64:
		hostplen = 128;
		break;
	default:
		fatalx("%s: unknown af", __func__);
	}

	do {
		if (req->flags & F_SHORTER0x0400) {
			for (plen = 0; plen <= req->prefixlen;
			    plen++) {
				p = prefix_adjout_lookup(peer,
				    &req->prefix, plen);
				/* dump all matching paths */
				while (p != NULL((void *)0)) {
					rde_dump_adjout_upcall(
					    p, ctx);
					p = prefix_adjout_next(
					    peer, p);
				}
			}
			p = NULL((void *)0);
		} else if (req->prefixlen == hostplen) {
			p = prefix_adjout_match(peer,
			    &req->prefix);
		} else {
			p = prefix_adjout_lookup(peer,
			    &req->prefix, req->prefixlen);
		}
		/* dump all matching paths */
		while (p != NULL((void *)0)) {
			rde_dump_adjout_upcall(p, ctx);
			p = prefix_adjout_next(peer, p);
		}
	} while ((peer = peer_match(&req->neighbor,
	    peer->conf.id)));

	imsg_compose(ibuf_se_ctl, IMSG_CTL_END, 0, ctx->req.pid,
	    -1, NULL((void *)0), 0);
	free(ctx);
	return;
default:
	fatalx("%s: unsupported imsg type", __func__);
}

LIST_INSERT_HEAD(&rde_dump_h, ctx, entry)do { if (((ctx)->entry.le_next = (&rde_dump_h)->lh_first
) != ((void *)0)) (&rde_dump_h)->lh_first->entry.le_prev
 = &(ctx)->entry.le_next; (&rde_dump_h)->lh_first
 = (ctx); (ctx)->entry.le_prev = &(&rde_dump_h)->
lh_first; } while (0);
return;
} else if ((rid = rib_find(req->rib)) == RIB_NOTFOUND0xffff) {
log_warnx("%s: no such rib %s", __func__, req->rib);
error = CTL_RES_NOSUCHRIB;
imsg_compose(ibuf_se_ctl, IMSG_CTL_RESULT, 0, pid, -1, &error,
    sizeof(error));
free(ctx);
return;
}

switch (ctx->req.type) {
case IMSG_CTL_SHOW_NETWORK:
if (rib_dump_new(rid, ctx->req.aid, CTL_MSG_HIGH_MARK500, ctx,
    network_dump_upcall, rde_dump_done,
    rde_dump_throttled) == -1)
	goto nomem;
break;
case IMSG_CTL_SHOW_RIB:
if (rib_dump_new(rid, ctx->req.aid, CTL_MSG_HIGH_MARK500, ctx,
    rde_dump_upcall, rde_dump_done, rde_dump_throttled) == -1)
	goto nomem;
break;
case IMSG_CTL_SHOW_RIB_PREFIX:
if (req->flags & F_LONGER0x0200) {
	if (rib_dump_subtree(rid, &req->prefix, req->prefixlen,
	    CTL_MSG_HIGH_MARK500, ctx, rde_dump_upcall,
	    rde_dump_done, rde_dump_throttled) == -1)
		goto nomem;
	break;
}
switch (req->prefix.aid) {
case AID_INET1:
case AID_VPN_IPv43:
	hostplen = 32;
	break;
case AID_INET62:
case AID_VPN_IPv64:
	hostplen = 128;
	break;
default:
	fatalx("%s: unknown af", __func__);
}

if (req->flags & F_SHORTER0x0400) {
	for (plen = 0; plen <= req->prefixlen; plen++) {
		re = rib_get_addr(rib_byid(rid), &req->prefix,
		    plen);
		rde_dump_upcall(re, ctx);
	}
} else if (req->prefixlen == hostplen) {
	re = rib_match(rib_byid(rid), &req->prefix);
	rde_dump_upcall(re, ctx);
} else {
	re = rib_get_addr(rib_byid(rid), &req->prefix,
	    req->prefixlen);
	rde_dump_upcall(re, ctx);
}
imsg_compose(ibuf_se_ctl, IMSG_CTL_END, 0, ctx->req.pid,
    -1, NULL((void *)0), 0);
free(ctx);
return;
default:
fatalx("%s: unsupported imsg type", __func__);
}
LIST_INSERT_HEAD(&rde_dump_h, ctx, entry)do { if (((ctx)->entry.le_next = (&rde_dump_h)->lh_first
) != ((void *)0)) (&rde_dump_h)->lh_first->entry.le_prev
 = &(ctx)->entry.le_next; (&rde_dump_h)->lh_first
 = (ctx); (ctx)->entry.le_prev = &(&rde_dump_h)->
lh_first; } while (0);
3250}

3252void
3253rde_dump_ctx_throttle(pid_t pid, int throttle)
3254{
struct rde_dump_ctx	*ctx;

LIST_FOREACH(ctx, &rde_dump_h, entry)for((ctx) = ((&rde_dump_h)->lh_first); (ctx)!= ((void *
)0); (ctx) = ((ctx)->entry.le_next)) {
if (ctx->req.pid == pid) {
	ctx->throttled = throttle;
	return;
}
}
3263}

3265void
3266rde_dump_ctx_terminate(pid_t pid)
3267{
struct rde_dump_ctx	*ctx;

LIST_FOREACH(ctx, &rde_dump_h, entry)for((ctx) = ((&rde_dump_h)->lh_first); (ctx)!= ((void *
)0); (ctx) = ((ctx)->entry.le_next)) {
if (ctx->req.pid == pid) {
	rib_dump_terminate(ctx);
	return;
}
}
3276}

3278static int
3279rde_mrt_throttled(void *arg)
3280{
struct mrt	*mrt = arg;

return (mrt->wbuf.queued > SESS_MSG_LOW_MARK500);
3284}

3286static void
3287rde_mrt_done(void *ptr, uint8_t aid)
3288{
mrt_done(ptr);
3290}

3292void
3293rde_dump_mrt_new(struct mrt *mrt, pid_t pid, int fd)
3294{
struct rde_mrt_ctx *ctx;
uint16_t rid;

if ((ctx = calloc(1, sizeof(*ctx))) == NULL((void *)0)) {
log_warn("rde_dump_mrt_new");
return;
}
memcpy(&ctx->mrt, mrt, sizeof(struct mrt));
TAILQ_INIT(&ctx->mrt.wbuf.bufs)do { (&ctx->mrt.wbuf.bufs)->tqh_first = ((void *)0)
; (&ctx->mrt.wbuf.bufs)->tqh_last = &(&ctx->
mrt.wbuf.bufs)->tqh_first; } while (0);
ctx->mrt.wbuf.fd = fd;
ctx->mrt.state = MRT_STATE_RUNNING;
rid = rib_find(ctx->mrt.rib);
if (rid == RIB_NOTFOUND0xffff) {
log_warnx("non existing RIB %s for mrt dump", ctx->mrt.rib);
free(ctx);
return;
}

if (ctx->mrt.type == MRT_TABLE_DUMP_V2)
mrt_dump_v2_hdr(&ctx->mrt, conf);

if (rib_dump_new(rid, AID_UNSPEC0, CTL_MSG_HIGH_MARK500, &ctx->mrt,
   mrt_dump_upcall, rde_mrt_done, rde_mrt_throttled) == -1)
fatal("%s: rib_dump_new", __func__);

LIST_INSERT_HEAD(&rde_mrts, ctx, entry)do { if (((ctx)->entry.le_next = (&rde_mrts)->lh_first
) != ((void *)0)) (&rde_mrts)->lh_first->entry.le_prev
 = &(ctx)->entry.le_next; (&rde_mrts)->lh_first
 = (ctx); (ctx)->entry.le_prev = &(&rde_mrts)->
lh_first; } while (0);
rde_mrt_cnt++;
3322}

3324/*
* kroute specific functions
*/
3327int
3328rde_l3vpn_import(struct rde_community *comm, struct l3vpn *rd)
3329{
struct filter_set	*s;

TAILQ_FOREACH(s, &rd->import, entry)for((s) = ((&rd->import)->tqh_first); (s) != ((void
 *)0); (s) = ((s)->entry.tqe_next)) {
if (community_match(comm, &s->action.community, 0))
	return (1);
}
return (0);
3337}

3339void
3340rde_send_kroute_flush(struct rib *rib)
3341{
if (imsg_compose(ibuf_main, IMSG_KROUTE_FLUSH, rib->rtableid, 0, -1,
   NULL((void *)0), 0) == -1)
fatal("%s %d imsg_compose error", __func__, __LINE__3344);
3345}

3347void
3348rde_send_kroute(struct rib *rib, struct prefix *new, struct prefix *old)
3349{
struct kroute_full	 kf;
struct prefix		*p;
struct l3vpn		*vpn;
enum imsg_type		 type;

/*
* Make sure that self announce prefixes are not committed to the
* FIB. If both prefixes are unreachable no update is needed.
*/
if ((old == NULL((void *)0) || prefix_aspath(old)->flags & F_PREFIX_ANNOUNCED0x00400) &&
   (new == NULL((void *)0) || prefix_aspath(new)->flags & F_PREFIX_ANNOUNCED0x00400))
return;

if (new == NULL((void *)0) || prefix_aspath(new)->flags & F_PREFIX_ANNOUNCED0x00400) {
type = IMSG_KROUTE_DELETE;
p = old;
} else {
type = IMSG_KROUTE_CHANGE;
p = new;
}

memset(&kf, 0, sizeof(kf));
pt_getaddr(p->pt, &kf.prefix);
kf.prefixlen = p->pt->prefixlen;
if (type == IMSG_KROUTE_CHANGE) {
if (prefix_nhflags(p) == NEXTHOP_REJECT0x02)
	kf.flags |= F_REJECT0x0020;
if (prefix_nhflags(p) == NEXTHOP_BLACKHOLE0x04)
	kf.flags |= F_BLACKHOLE0x0040;
kf.nexthop = prefix_nexthop(p)->exit_nexthop;
strlcpy(kf.label, rtlabel_id2name(prefix_aspath(p)->rtlabelid),
    sizeof(kf.label));
}

switch (kf.prefix.aid) {
case AID_VPN_IPv43:
case AID_VPN_IPv64:
if (!(rib->flags & F_RIB_LOCAL0x0001))
	/* not Loc-RIB, no update for VPNs */
	break;

SIMPLEQ_FOREACH(vpn, &conf->l3vpns, entry)for((vpn) = ((&conf->l3vpns)->sqh_first); (vpn) != (
(void *)0); (vpn) = ((vpn)->entry.sqe_next)) {
	if (!rde_l3vpn_import(prefix_communities(p), vpn))
		continue;
	/* XXX not ideal but this will change */
	kf.ifindex = if_nametoindex(vpn->ifmpe);
	if (imsg_compose(ibuf_main, type, vpn->rtableid, 0, -1,
	    &kf, sizeof(kf)) == -1)
		fatal("%s %d imsg_compose error", __func__,
		    __LINE__3399);
}
break;
default:
if (imsg_compose(ibuf_main, type, rib->rtableid, 0, -1,
    &kf, sizeof(kf)) == -1)
	fatal("%s %d imsg_compose error", __func__, __LINE__3405);
break;
}
3408}

3410/*
* update specific functions
*/
3413int
3414rde_evaluate_all(void)
3415{
return rde_eval_all;
3417}

3419/* flush Adj-RIB-Out by withdrawing all prefixes */
3420static void
3421rde_up_flush_upcall(struct prefix *p, void *ptr)
3422{
prefix_adjout_withdraw(p);
3424}

3426u_char	queue_buf[4096];

3428int
3429rde_update_queue_pending(void)
3430{
struct rde_peer *peer;
uint8_t aid;

if (ibuf_se && ibuf_se->w.queued >= SESS_MSG_HIGH_MARK2000)
return 0;

RB_FOREACH(peer, peer_tree, &peertable)for ((peer) = peer_tree_RB_MINMAX(&peertable, -1); (peer)
 != ((void *)0); (peer) = peer_tree_RB_NEXT(peer)) {
if (peer->conf.id == 0)
	continue;
if (peer->state != PEER_UP)
	continue;
if (peer->throttled)
	continue;
for (aid = 0; aid < AID_MAX7; aid++) {
	if (!RB_EMPTY(&peer->updates[aid])((&peer->updates[aid])->rbh_root == ((void *)0)) ||
	    !RB_EMPTY(&peer->withdraws[aid])((&peer->withdraws[aid])->rbh_root == ((void *)0)))
		return 1;
}
}
return 0;
3451}

3453void
3454rde_update_queue_runner(uint8_t aid)
3455{
struct rde_peer		*peer;
struct ibuf		*buf;
int			 sent, max = RDE_RUNNER_ROUNDS100;

/* first withdraws ... */
do {
sent = 0;
RB_FOREACH(peer, peer_tree, &peertable)for ((peer) = peer_tree_RB_MINMAX(&peertable, -1); (peer)
 != ((void *)0); (peer) = peer_tree_RB_NEXT(peer)) {
	if (peer->conf.id == 0)
		continue;
	if (peer->state != PEER_UP)
		continue;
	if (peer->throttled)
		continue;
	if (RB_EMPTY(&peer->withdraws[aid])((&peer->withdraws[aid])->rbh_root == ((void *)0)))
		continue;

	if ((buf = ibuf_dynamic(4, 4096 - MSGSIZE_HEADER19)) ==
	    NULL((void *)0))
		fatal("%s", __func__);
	if (up_dump_withdraws(buf, peer, aid) == -1) {
		ibuf_free(buf);
		continue;
	}
	if (imsg_compose_ibuf(ibuf_se, IMSG_UPDATE,
	    peer->conf.id, 0, buf) == -1)
		fatal("%s: imsg_create error", __func__);
	sent++;
}
max -= sent;
} while (sent != 0 && max > 0);

/* ... then updates */
max = RDE_RUNNER_ROUNDS100;
do {
sent = 0;
RB_FOREACH(peer, peer_tree, &peertable)for ((peer) = peer_tree_RB_MINMAX(&peertable, -1); (peer)
 != ((void *)0); (peer) = peer_tree_RB_NEXT(peer)) {
	if (peer->conf.id == 0)
		continue;
	if (peer->state != PEER_UP)
		continue;
	if (peer->throttled)
		continue;
	if (RB_EMPTY(&peer->updates[aid])((&peer->updates[aid])->rbh_root == ((void *)0)))
		continue;

	if (up_is_eor(peer, aid)) {
		int sent_eor = peer->sent_eor & (1 << aid);
		if (peer->capa.grestart.restart && !sent_eor)
			rde_peer_send_eor(peer, aid);
		if (peer->capa.enhanced_rr && sent_eor)
			rde_peer_send_rrefresh(peer, aid,
			    ROUTE_REFRESH_END_RR2);
		continue;
	}

	if ((buf = ibuf_dynamic(4, 4096 - MSGSIZE_HEADER19)) ==
	    NULL((void *)0))
		fatal("%s", __func__);
	if (up_dump_update(buf, peer, aid) == -1) {
		ibuf_free(buf);
		continue;
	}
	if (imsg_compose_ibuf(ibuf_se, IMSG_UPDATE,
	    peer->conf.id, 0, buf) == -1)
		fatal("%s: imsg_compose_ibuf error", __func__);
	sent++;
}
max -= sent;
} while (sent != 0 && max > 0);
3526}

3528/*
* pf table specific functions
*/
3531struct rde_pftable_node {
RB_ENTRY(rde_pftable_node)struct { struct rde_pftable_node *rbe_left; struct rde_pftable_node
 *rbe_right; struct rde_pftable_node *rbe_parent; int rbe_color
; }	 entry;
struct pt_entry			*prefix;
int				 refcnt;
uint16_t			 id;
3536};
3537RB_HEAD(rde_pftable_tree, rde_pftable_node)struct rde_pftable_tree { struct rde_pftable_node *rbh_root; };

3539static inline int
3540rde_pftable_cmp(struct rde_pftable_node *a, struct rde_pftable_node *b)
3541{
if (a->prefix > b->prefix)
return 1;
if (a->prefix < b->prefix)
return -1;
return (a->id - b->id);
3547}

3549RB_GENERATE_STATIC(rde_pftable_tree, rde_pftable_node, entry, rde_pftable_cmp)__attribute__((__unused__)) static void rde_pftable_tree_RB_INSERT_COLOR
(struct rde_pftable_tree *head, struct rde_pftable_node *elm)
 { struct rde_pftable_node *parent, *gparent, *tmp; while ((parent
 = (elm)->entry.rbe_parent) && (parent)->entry.
rbe_color == 1) { gparent = (parent)->entry.rbe_parent; if
 (parent == (gparent)->entry.rbe_left) { tmp = (gparent)->
entry.rbe_right; if (tmp && (tmp)->entry.rbe_color
 == 1) { (tmp)->entry.rbe_color = 0; do { (parent)->entry
.rbe_color = 0; (gparent)->entry.rbe_color = 1; } while (0
); elm = gparent; continue; } if ((parent)->entry.rbe_right
 == elm) { do { (tmp) = (parent)->entry.rbe_right; if (((parent
)->entry.rbe_right = (tmp)->entry.rbe_left)) { ((tmp)->
entry.rbe_left)->entry.rbe_parent = (parent); } do {} while
 (0); if (((tmp)->entry.rbe_parent = (parent)->entry.rbe_parent
)) { if ((parent) == ((parent)->entry.rbe_parent)->entry
.rbe_left) ((parent)->entry.rbe_parent)->entry.rbe_left
 = (tmp); else ((parent)->entry.rbe_parent)->entry.rbe_right
 = (tmp); } else (head)->rbh_root = (tmp); (tmp)->entry
.rbe_left = (parent); (parent)->entry.rbe_parent = (tmp); do
 {} while (0); if (((tmp)->entry.rbe_parent)) do {} while (
0); } while (0); tmp = parent; parent = elm; elm = tmp; } do {
 (parent)->entry.rbe_color = 0; (gparent)->entry.rbe_color
 = 1; } while (0); do { (tmp) = (gparent)->entry.rbe_left;
 if (((gparent)->entry.rbe_left = (tmp)->entry.rbe_right
)) { ((tmp)->entry.rbe_right)->entry.rbe_parent = (gparent
); } do {} while (0); if (((tmp)->entry.rbe_parent = (gparent
)->entry.rbe_parent)) { if ((gparent) == ((gparent)->entry
.rbe_parent)->entry.rbe_left) ((gparent)->entry.rbe_parent
)->entry.rbe_left = (tmp); else ((gparent)->entry.rbe_parent
)->entry.rbe_right = (tmp); } else (head)->rbh_root = (
tmp); (tmp)->entry.rbe_right = (gparent); (gparent)->entry
.rbe_parent = (tmp); do {} while (0); if (((tmp)->entry.rbe_parent
)) do {} while (0); } while (0); } else { tmp = (gparent)->
entry.rbe_left; if (tmp && (tmp)->entry.rbe_color ==
 1) { (tmp)->entry.rbe_color = 0; do { (parent)->entry.
rbe_color = 0; (gparent)->entry.rbe_color = 1; } while (0)
; elm = gparent; continue; } if ((parent)->entry.rbe_left ==
 elm) { do { (tmp) = (parent)->entry.rbe_left; if (((parent
)->entry.rbe_left = (tmp)->entry.rbe_right)) { ((tmp)->
entry.rbe_right)->entry.rbe_parent = (parent); } do {} while
 (0); if (((tmp)->entry.rbe_parent = (parent)->entry.rbe_parent
)) { if ((parent) == ((parent)->entry.rbe_parent)->entry
.rbe_left) ((parent)->entry.rbe_parent)->entry.rbe_left
 = (tmp); else ((parent)->entry.rbe_parent)->entry.rbe_right
 = (tmp); } else (head)->rbh_root = (tmp); (tmp)->entry
.rbe_right = (parent); (parent)->entry.rbe_parent = (tmp);
 do {} while (0); if (((tmp)->entry.rbe_parent)) do {} while
 (0); } while (0); tmp = parent; parent = elm; elm = tmp; } do
 { (parent)->entry.rbe_color = 0; (gparent)->entry.rbe_color
 = 1; } while (0); do { (tmp) = (gparent)->entry.rbe_right
; if (((gparent)->entry.rbe_right = (tmp)->entry.rbe_left
)) { ((tmp)->entry.rbe_left)->entry.rbe_parent = (gparent
); } do {} while (0); if (((tmp)->entry.rbe_parent = (gparent
)->entry.rbe_parent)) { if ((gparent) == ((gparent)->entry
.rbe_parent)->entry.rbe_left) ((gparent)->entry.rbe_parent
)->entry.rbe_left = (tmp); else ((gparent)->entry.rbe_parent
)->entry.rbe_right = (tmp); } else (head)->rbh_root = (
tmp); (tmp)->entry.rbe_left = (gparent); (gparent)->entry
.rbe_parent = (tmp); do {} while (0); if (((tmp)->entry.rbe_parent
)) do {} while (0); } while (0); } } (head->rbh_root)->
entry.rbe_color = 0; } __attribute__((__unused__)) static void
 rde_pftable_tree_RB_REMOVE_COLOR(struct rde_pftable_tree *head
, struct rde_pftable_node *parent, struct rde_pftable_node *elm
) { struct rde_pftable_node *tmp; while ((elm == ((void *)0) ||
 (elm)->entry.rbe_color == 0) && elm != (head)->
rbh_root) { if ((parent)->entry.rbe_left == elm) { tmp = (
parent)->entry.rbe_right; if ((tmp)->entry.rbe_color ==
 1) { do { (tmp)->entry.rbe_color = 0; (parent)->entry.
rbe_color = 1; } while (0); do { (tmp) = (parent)->entry.rbe_right
; if (((parent)->entry.rbe_right = (tmp)->entry.rbe_left
)) { ((tmp)->entry.rbe_left)->entry.rbe_parent = (parent
); } do {} while (0); if (((tmp)->entry.rbe_parent = (parent
)->entry.rbe_parent)) { if ((parent) == ((parent)->entry
.rbe_parent)->entry.rbe_left) ((parent)->entry.rbe_parent
)->entry.rbe_left = (tmp); else ((parent)->entry.rbe_parent
)->entry.rbe_right = (tmp); } else (head)->rbh_root = (
tmp); (tmp)->entry.rbe_left = (parent); (parent)->entry
.rbe_parent = (tmp); do {} while (0); if (((tmp)->entry.rbe_parent
)) do {} while (0); } while (0); tmp = (parent)->entry.rbe_right
; } if (((tmp)->entry.rbe_left == ((void *)0) || ((tmp)->
entry.rbe_left)->entry.rbe_color == 0) && ((tmp)->
entry.rbe_right == ((void *)0) || ((tmp)->entry.rbe_right)
->entry.rbe_color == 0)) { (tmp)->entry.rbe_color = 1; elm
 = parent; parent = (elm)->entry.rbe_parent; } else { if (
(tmp)->entry.rbe_right == ((void *)0) || ((tmp)->entry.
rbe_right)->entry.rbe_color == 0) { struct rde_pftable_node
 *oleft; if ((oleft = (tmp)->entry.rbe_left)) (oleft)->
entry.rbe_color = 0; (tmp)->entry.rbe_color = 1; do { (oleft
) = (tmp)->entry.rbe_left; if (((tmp)->entry.rbe_left =
 (oleft)->entry.rbe_right)) { ((oleft)->entry.rbe_right
)->entry.rbe_parent = (tmp); } do {} while (0); if (((oleft
)->entry.rbe_parent = (tmp)->entry.rbe_parent)) { if ((
tmp) == ((tmp)->entry.rbe_parent)->entry.rbe_left) ((tmp
)->entry.rbe_parent)->entry.rbe_left = (oleft); else ((
tmp)->entry.rbe_parent)->entry.rbe_right = (oleft); } else
 (head)->rbh_root = (oleft); (oleft)->entry.rbe_right =
 (tmp); (tmp)->entry.rbe_parent = (oleft); do {} while (0)
; if (((oleft)->entry.rbe_parent)) do {} while (0); } while
 (0); tmp = (parent)->entry.rbe_right; } (tmp)->entry.rbe_color
 = (parent)->entry.rbe_color; (parent)->entry.rbe_color
 = 0; if ((tmp)->entry.rbe_right) ((tmp)->entry.rbe_right
)->entry.rbe_color = 0; do { (tmp) = (parent)->entry.rbe_right
; if (((parent)->entry.rbe_right = (tmp)->entry.rbe_left
)) { ((tmp)->entry.rbe_left)->entry.rbe_parent = (parent
); } do {} while (0); if (((tmp)->entry.rbe_parent = (parent
)->entry.rbe_parent)) { if ((parent) == ((parent)->entry
.rbe_parent)->entry.rbe_left) ((parent)->entry.rbe_parent
)->entry.rbe_left = (tmp); else ((parent)->entry.rbe_parent
)->entry.rbe_right = (tmp); } else (head)->rbh_root = (
tmp); (tmp)->entry.rbe_left = (parent); (parent)->entry
.rbe_parent = (tmp); do {} while (0); if (((tmp)->entry.rbe_parent
)) do {} while (0); } while (0); elm = (head)->rbh_root; break
; } } else { tmp = (parent)->entry.rbe_left; if ((tmp)->
entry.rbe_color == 1) { do { (tmp)->entry.rbe_color = 0; (
parent)->entry.rbe_color = 1; } while (0); do { (tmp) = (parent
)->entry.rbe_left; if (((parent)->entry.rbe_left = (tmp
)->entry.rbe_right)) { ((tmp)->entry.rbe_right)->entry
.rbe_parent = (parent); } do {} while (0); if (((tmp)->entry
.rbe_parent = (parent)->entry.rbe_parent)) { if ((parent) ==
 ((parent)->entry.rbe_parent)->entry.rbe_left) ((parent
)->entry.rbe_parent)->entry.rbe_left = (tmp); else ((parent
)->entry.rbe_parent)->entry.rbe_right = (tmp); } else (
head)->rbh_root = (tmp); (tmp)->entry.rbe_right = (parent
); (parent)->entry.rbe_parent = (tmp); do {} while (0); if
 (((tmp)->entry.rbe_parent)) do {} while (0); } while (0);
 tmp = (parent)->entry.rbe_left; } if (((tmp)->entry.rbe_left
 == ((void *)0) || ((tmp)->entry.rbe_left)->entry.rbe_color
 == 0) && ((tmp)->entry.rbe_right == ((void *)0) ||
 ((tmp)->entry.rbe_right)->entry.rbe_color == 0)) { (tmp
)->entry.rbe_color = 1; elm = parent; parent = (elm)->entry
.rbe_parent; } else { if ((tmp)->entry.rbe_left == ((void *
)0) || ((tmp)->entry.rbe_left)->entry.rbe_color == 0) {
 struct rde_pftable_node *oright; if ((oright = (tmp)->entry
.rbe_right)) (oright)->entry.rbe_color = 0; (tmp)->entry
.rbe_color = 1; do { (oright) = (tmp)->entry.rbe_right; if
 (((tmp)->entry.rbe_right = (oright)->entry.rbe_left)) {
 ((oright)->entry.rbe_left)->entry.rbe_parent = (tmp); }
 do {} while (0); if (((oright)->entry.rbe_parent = (tmp)->
entry.rbe_parent)) { if ((tmp) == ((tmp)->entry.rbe_parent
)->entry.rbe_left) ((tmp)->entry.rbe_parent)->entry.
rbe_left = (oright); else ((tmp)->entry.rbe_parent)->entry
.rbe_right = (oright); } else (head)->rbh_root = (oright);
 (oright)->entry.rbe_left = (tmp); (tmp)->entry.rbe_parent
 = (oright); do {} while (0); if (((oright)->entry.rbe_parent
)) do {} while (0); } while (0); tmp = (parent)->entry.rbe_left
; } (tmp)->entry.rbe_color = (parent)->entry.rbe_color;
 (parent)->entry.rbe_color = 0; if ((tmp)->entry.rbe_left
) ((tmp)->entry.rbe_left)->entry.rbe_color = 0; do { (tmp
) = (parent)->entry.rbe_left; if (((parent)->entry.rbe_left
 = (tmp)->entry.rbe_right)) { ((tmp)->entry.rbe_right)->
entry.rbe_parent = (parent); } do {} while (0); if (((tmp)->
entry.rbe_parent = (parent)->entry.rbe_parent)) { if ((parent
) == ((parent)->entry.rbe_parent)->entry.rbe_left) ((parent
)->entry.rbe_parent)->entry.rbe_left = (tmp); else ((parent
)->entry.rbe_parent)->entry.rbe_right = (tmp); } else (
head)->rbh_root = (tmp); (tmp)->entry.rbe_right = (parent
); (parent)->entry.rbe_parent = (tmp); do {} while (0); if
 (((tmp)->entry.rbe_parent)) do {} while (0); } while (0);
 elm = (head)->rbh_root; break; } } } if (elm) (elm)->entry
.rbe_color = 0; } __attribute__((__unused__)) static struct rde_pftable_node
 * rde_pftable_tree_RB_REMOVE(struct rde_pftable_tree *head, struct
 rde_pftable_node *elm) { struct rde_pftable_node *child, *parent
, *old = elm; int color; if ((elm)->entry.rbe_left == ((void
 *)0)) child = (elm)->entry.rbe_right; else if ((elm)->
entry.rbe_right == ((void *)0)) child = (elm)->entry.rbe_left
; else { struct rde_pftable_node *left; elm = (elm)->entry
.rbe_right; while ((left = (elm)->entry.rbe_left)) elm = left
; child = (elm)->entry.rbe_right; parent = (elm)->entry
.rbe_parent; color = (elm)->entry.rbe_color; if (child) (child
)->entry.rbe_parent = parent; if (parent) { if ((parent)->
entry.rbe_left == elm) (parent)->entry.rbe_left = child; else
 (parent)->entry.rbe_right = child; do {} while (0); } else
 (head)->rbh_root = child; if ((elm)->entry.rbe_parent ==
 old) parent = elm; (elm)->entry = (old)->entry; if ((old
)->entry.rbe_parent) { if (((old)->entry.rbe_parent)->
entry.rbe_left == old) ((old)->entry.rbe_parent)->entry
.rbe_left = elm; else ((old)->entry.rbe_parent)->entry.
rbe_right = elm; do {} while (0); } else (head)->rbh_root =
 elm; ((old)->entry.rbe_left)->entry.rbe_parent = elm; if
 ((old)->entry.rbe_right) ((old)->entry.rbe_right)->
entry.rbe_parent = elm; if (parent) { left = parent; do { do {
} while (0); } while ((left = (left)->entry.rbe_parent)); }
 goto color; } parent = (elm)->entry.rbe_parent; color = (
elm)->entry.rbe_color; if (child) (child)->entry.rbe_parent
 = parent; if (parent) { if ((parent)->entry.rbe_left == elm
) (parent)->entry.rbe_left = child; else (parent)->entry
.rbe_right = child; do {} while (0); } else (head)->rbh_root
 = child; color: if (color == 0) rde_pftable_tree_RB_REMOVE_COLOR
(head, parent, child); return (old); } __attribute__((__unused__
)) static struct rde_pftable_node * rde_pftable_tree_RB_INSERT
(struct rde_pftable_tree *head, struct rde_pftable_node *elm)
 { struct rde_pftable_node *tmp; struct rde_pftable_node *parent
 = ((void *)0); int comp = 0; tmp = (head)->rbh_root; while
 (tmp) { parent = tmp; comp = (rde_pftable_cmp)(elm, parent);
 if (comp < 0) tmp = (tmp)->entry.rbe_left; else if (comp
 > 0) tmp = (tmp)->entry.rbe_right; else return (tmp); }
 do { (elm)->entry.rbe_parent = parent; (elm)->entry.rbe_left
 = (elm)->entry.rbe_right = ((void *)0); (elm)->entry.rbe_color
 = 1; } while (0); if (parent != ((void *)0)) { if (comp <
 0) (parent)->entry.rbe_left = elm; else (parent)->entry
.rbe_right = elm; do {} while (0); } else (head)->rbh_root
 = elm; rde_pftable_tree_RB_INSERT_COLOR(head, elm); return (
((void *)0)); } __attribute__((__unused__)) static struct rde_pftable_node
 * rde_pftable_tree_RB_FIND(struct rde_pftable_tree *head, struct
 rde_pftable_node *elm) { struct rde_pftable_node *tmp = (head
)->rbh_root; int comp; while (tmp) { comp = rde_pftable_cmp
(elm, tmp); if (comp < 0) tmp = (tmp)->entry.rbe_left; else
 if (comp > 0) tmp = (tmp)->entry.rbe_right; else return
 (tmp); } return (((void *)0)); } __attribute__((__unused__))
 static struct rde_pftable_node * rde_pftable_tree_RB_NFIND(struct
 rde_pftable_tree *head, struct rde_pftable_node *elm) { struct
 rde_pftable_node *tmp = (head)->rbh_root; struct rde_pftable_node
 *res = ((void *)0); int comp; while (tmp) { comp = rde_pftable_cmp
(elm, tmp); if (comp < 0) { res = tmp; tmp = (tmp)->entry
.rbe_left; } else if (comp > 0) tmp = (tmp)->entry.rbe_right
; else return (tmp); } return (res); } __attribute__((__unused__
)) static struct rde_pftable_node * rde_pftable_tree_RB_NEXT(
struct rde_pftable_node *elm) { if ((elm)->entry.rbe_right
) { elm = (elm)->entry.rbe_right; while ((elm)->entry.rbe_left
) elm = (elm)->entry.rbe_left; } else { if ((elm)->entry
.rbe_parent && (elm == ((elm)->entry.rbe_parent)->
entry.rbe_left)) elm = (elm)->entry.rbe_parent; else { while
 ((elm)->entry.rbe_parent && (elm == ((elm)->entry
.rbe_parent)->entry.rbe_right)) elm = (elm)->entry.rbe_parent
; elm = (elm)->entry.rbe_parent; } } return (elm); } __attribute__
((__unused__)) static struct rde_pftable_node * rde_pftable_tree_RB_PREV
(struct rde_pftable_node *elm) { if ((elm)->entry.rbe_left
) { elm = (elm)->entry.rbe_left; while ((elm)->entry.rbe_right
) elm = (elm)->entry.rbe_right; } else { if ((elm)->entry
.rbe_parent && (elm == ((elm)->entry.rbe_parent)->
entry.rbe_right)) elm = (elm)->entry.rbe_parent; else { while
 ((elm)->entry.rbe_parent && (elm == ((elm)->entry
.rbe_parent)->entry.rbe_left)) elm = (elm)->entry.rbe_parent
; elm = (elm)->entry.rbe_parent; } } return (elm); } __attribute__
((__unused__)) static struct rde_pftable_node * rde_pftable_tree_RB_MINMAX
(struct rde_pftable_tree *head, int val) { struct rde_pftable_node
 *tmp = (head)->rbh_root; struct rde_pftable_node *parent =
 ((void *)0); while (tmp) { parent = tmp; if (val < 0) tmp
 = (tmp)->entry.rbe_left; else tmp = (tmp)->entry.rbe_right
; } return (parent); };

3551struct rde_pftable_tree pftable_tree = RB_INITIALIZER(&pftable_tree){ ((void *)0) };
3552int need_commit;

3554static void
3555rde_pftable_send(uint16_t id, struct pt_entry *pt, int del)
3556{
struct pftable_msg pfm;

if (id == 0)
return;

/* do not run while cleaning up */
if (rde_quit)
return;

memset(&pfm, 0, sizeof(pfm));
strlcpy(pfm.pftable, pftable_id2name(id), sizeof(pfm.pftable));
pt_getaddr(pt, &pfm.addr);
pfm.len = pt->prefixlen;

if (imsg_compose(ibuf_main,
   del ? IMSG_PFTABLE_REMOVE : IMSG_PFTABLE_ADD,
   0, 0, -1, &pfm, sizeof(pfm)) == -1)
fatal("%s %d imsg_compose error", __func__, __LINE__3574);

need_commit = 1;
3577}

3579void
3580rde_pftable_add(uint16_t id, struct prefix *p)
3581{
struct rde_pftable_node *pfn, node;

memset(&node, 0, sizeof(node));
node.prefix = p->pt;
node.id = id;

pfn = RB_FIND(rde_pftable_tree, &pftable_tree, &node)rde_pftable_tree_RB_FIND(&pftable_tree, &node);
if (pfn == NULL((void *)0)) {
if ((pfn = calloc(1, sizeof(*pfn))) == NULL((void *)0))
	fatal("%s", __func__);
pfn->prefix = pt_ref(p->pt);
pfn->id = id;

if (RB_INSERT(rde_pftable_tree, &pftable_tree, pfn)rde_pftable_tree_RB_INSERT(&pftable_tree, pfn) != NULL((void *)0))
	fatalx("%s: tree corrupt", __func__);

rde_pftable_send(id, p->pt, 0);
}
pfn->refcnt++;
3601}

3603void
3604rde_pftable_del(uint16_t id, struct prefix *p)
3605{
struct rde_pftable_node *pfn, node;

memset(&node, 0, sizeof(node));
node.prefix = p->pt;
node.id = id;

pfn = RB_FIND(rde_pftable_tree, &pftable_tree, &node)rde_pftable_tree_RB_FIND(&pftable_tree, &node);
if (pfn == NULL((void *)0))
return;

if (--pfn->refcnt <= 0) {
rde_pftable_send(id, p->pt, 1);

if (RB_REMOVE(rde_pftable_tree, &pftable_tree, pfn)rde_pftable_tree_RB_REMOVE(&pftable_tree, pfn) == NULL((void *)0))
	fatalx("%s: tree corrupt", __func__);

pt_unref(pfn->prefix);
free(pfn);
}
3625}

3627void
3628rde_commit_pftable(void)
3629{
/* do not run while cleaning up */
if (rde_quit)
return;

if (!need_commit)
return;

if (imsg_compose(ibuf_main, IMSG_PFTABLE_COMMIT, 0, 0, -1, NULL((void *)0), 0) ==
   -1)
fatal("%s %d imsg_compose error", __func__, __LINE__3639);

need_commit = 0;
3642}

3644/*
* nexthop specific functions
*/
3647void
3648rde_send_nexthop(struct bgpd_addr *next, int insert)
3649{
int			 type;

if (insert)
type = IMSG_NEXTHOP_ADD;
else
type = IMSG_NEXTHOP_REMOVE;

if (imsg_compose(ibuf_main, type, 0, 0, -1, next,
   sizeof(struct bgpd_addr)) == -1)
fatal("%s %d imsg_compose error", __func__, __LINE__3659);
3660}

3662/*
* soft reconfig specific functions
*/
3665void
3666rde_reload_done(void)
3667{
struct rde_peer		*peer;
struct filter_head	*fh;
struct rde_prefixset_head prefixsets_old;
struct rde_prefixset_head originsets_old;
struct as_set_head	 as_sets_old;
uint16_t		 rid;
int			 reload = 0;

softreconfig = 0;

SIMPLEQ_INIT(&prefixsets_old)do { (&prefixsets_old)->sqh_first = ((void *)0); (&
prefixsets_old)->sqh_last = &(&prefixsets_old)->
sqh_first; } while (0);
SIMPLEQ_INIT(&originsets_old)do { (&originsets_old)->sqh_first = ((void *)0); (&
originsets_old)->sqh_last = &(&originsets_old)->
sqh_first; } while (0);
SIMPLEQ_INIT(&as_sets_old)do { (&as_sets_old)->sqh_first = ((void *)0); (&as_sets_old
)->sqh_last = &(&as_sets_old)->sqh_first; } while
 (0);
SIMPLEQ_CONCAT(&prefixsets_old, &conf->rde_prefixsets)do { if (!((((&conf->rde_prefixsets))->sqh_first) ==
 ((void *)0))) { *(&prefixsets_old)->sqh_last = (&
conf->rde_prefixsets)->sqh_first; (&prefixsets_old)
->sqh_last = (&conf->rde_prefixsets)->sqh_last; do
 { ((&conf->rde_prefixsets))->sqh_first = ((void *)
0); ((&conf->rde_prefixsets))->sqh_last = &((&
conf->rde_prefixsets))->sqh_first; } while (0); } } while
 (0);
SIMPLEQ_CONCAT(&originsets_old, &conf->rde_originsets)do { if (!((((&conf->rde_originsets))->sqh_first) ==
 ((void *)0))) { *(&originsets_old)->sqh_last = (&
conf->rde_originsets)->sqh_first; (&originsets_old)
->sqh_last = (&conf->rde_originsets)->sqh_last; do
 { ((&conf->rde_originsets))->sqh_first = ((void *)
0); ((&conf->rde_originsets))->sqh_last = &((&
conf->rde_originsets))->sqh_first; } while (0); } } while
 (0);
SIMPLEQ_CONCAT(&as_sets_old, &conf->as_sets)do { if (!((((&conf->as_sets))->sqh_first) == ((void
 *)0))) { *(&as_sets_old)->sqh_last = (&conf->as_sets
)->sqh_first; (&as_sets_old)->sqh_last = (&conf
->as_sets)->sqh_last; do { ((&conf->as_sets))->
sqh_first = ((void *)0); ((&conf->as_sets))->sqh_last
 = &((&conf->as_sets))->sqh_first; } while (0);
 } } while (0);

/* merge the main config */
copy_config(conf, nconf);

/* need to copy the sets and roa table and clear them in nconf */
SIMPLEQ_CONCAT(&conf->rde_prefixsets, &nconf->rde_prefixsets)do { if (!((((&nconf->rde_prefixsets))->sqh_first) ==
 ((void *)0))) { *(&conf->rde_prefixsets)->sqh_last
 = (&nconf->rde_prefixsets)->sqh_first; (&conf->
rde_prefixsets)->sqh_last = (&nconf->rde_prefixsets
)->sqh_last; do { ((&nconf->rde_prefixsets))->sqh_first
 = ((void *)0); ((&nconf->rde_prefixsets))->sqh_last
 = &((&nconf->rde_prefixsets))->sqh_first; } while
 (0); } } while (0);
SIMPLEQ_CONCAT(&conf->rde_originsets, &nconf->rde_originsets)do { if (!((((&nconf->rde_originsets))->sqh_first) ==
 ((void *)0))) { *(&conf->rde_originsets)->sqh_last
 = (&nconf->rde_originsets)->sqh_first; (&conf->
rde_originsets)->sqh_last = (&nconf->rde_originsets
)->sqh_last; do { ((&nconf->rde_originsets))->sqh_first
 = ((void *)0); ((&nconf->rde_originsets))->sqh_last
 = &((&nconf->rde_originsets))->sqh_first; } while
 (0); } } while (0);
SIMPLEQ_CONCAT(&conf->as_sets, &nconf->as_sets)do { if (!((((&nconf->as_sets))->sqh_first) == ((void
 *)0))) { *(&conf->as_sets)->sqh_last = (&nconf
->as_sets)->sqh_first; (&conf->as_sets)->sqh_last
 = (&nconf->as_sets)->sqh_last; do { ((&nconf->
as_sets))->sqh_first = ((void *)0); ((&nconf->as_sets
))->sqh_last = &((&nconf->as_sets))->sqh_first
; } while (0); } } while (0);

/* apply new set of l3vpn, sync will be done later */
free_l3vpns(&conf->l3vpns);
SIMPLEQ_CONCAT(&conf->l3vpns, &nconf->l3vpns)do { if (!((((&nconf->l3vpns))->sqh_first) == ((void
 *)0))) { *(&conf->l3vpns)->sqh_last = (&nconf->
l3vpns)->sqh_first; (&conf->l3vpns)->sqh_last = (
&nconf->l3vpns)->sqh_last; do { ((&nconf->l3vpns
))->sqh_first = ((void *)0); ((&nconf->l3vpns))->
sqh_last = &((&nconf->l3vpns))->sqh_first; } while
 (0); } } while (0);
/* XXX WHERE IS THE SYNC ??? */

free_config(nconf);
nconf = NULL((void *)0);

/* sync peerself with conf */
peerself->remote_bgpid = ntohl(conf->bgpid)(__uint32_t)(__builtin_constant_p(conf->bgpid) ? (__uint32_t
)(((__uint32_t)(conf->bgpid) & 0xff) << 24 | ((__uint32_t
)(conf->bgpid) & 0xff00) << 8 | ((__uint32_t)(conf
->bgpid) & 0xff0000) >> 8 | ((__uint32_t)(conf->
bgpid) & 0xff000000) >> 24) : __swap32md(conf->bgpid
));
peerself->conf.local_as = conf->as;
peerself->conf.remote_as = conf->as;
peerself->conf.remote_addr.aid = AID_INET1;
peerself->conf.remote_addr.v4ba.v4.s_addr = conf->bgpid;
peerself->conf.remote_masklen = 32;
peerself->short_as = conf->short_as;

rde_mark_prefixsets_dirty(&prefixsets_old, &conf->rde_prefixsets);
rde_mark_prefixsets_dirty(&originsets_old, &conf->rde_originsets);
as_sets_mark_dirty(&as_sets_old, &conf->as_sets);


/* make sure that rde_eval_all is correctly set after a config change */
rde_eval_all = 0;

/* Make the new outbound filter rules the active one. */
filterlist_free(out_rules);
out_rules = out_rules_tmp;
out_rules_tmp = NULL((void *)0);

/* check if filter changed */
RB_FOREACH(peer, peer_tree, &peertable)for ((peer) = peer_tree_RB_MINMAX(&peertable, -1); (peer)
 != ((void *)0); (peer) = peer_tree_RB_NEXT(peer)) {
if (peer->conf.id == 0)	/* ignore peerself */
	continue;
peer->reconf_out = 0;
peer->reconf_rib = 0;
if (peer->export_type != peer->conf.export_type) {
	log_peer_info(&peer->conf, "export type change, "
	    "reloading");
	peer->reconf_rib = 1;
}
if ((peer->flags & PEERFLAG_EVALUATE_ALL0x04) !=
    (peer->conf.flags & PEERFLAG_EVALUATE_ALL0x04)) {
	log_peer_info(&peer->conf, "rde evaluate change, "
	    "reloading");
	peer->reconf_rib = 1;
}
if ((peer->flags & PEERFLAG_TRANS_AS0x01) !=
    (peer->conf.flags & PEERFLAG_TRANS_AS0x01)) {
	log_peer_info(&peer->conf, "transparent-as change, "
	    "reloading");
	peer->reconf_rib = 1;
}
if (peer->loc_rib_id != rib_find(peer->conf.rib)) {
	log_peer_info(&peer->conf, "rib change, reloading");
	peer->loc_rib_id = rib_find(peer->conf.rib);
	if (peer->loc_rib_id == RIB_NOTFOUND0xffff)
		fatalx("King Bula's peer met an unknown RIB");
	peer->reconf_rib = 1;
}
/*
 * Update add-path settings but only if the session is
 * running with add-path and the config uses add-path
 * as well.
 */
if (peer_has_add_path(peer, AID_UNSPEC0, CAPA_AP_SEND0x02)) {
	if (peer->conf.eval.mode != ADDPATH_EVAL_NONE &&
	    memcmp(&peer->eval, &peer->conf.eval,
	    sizeof(peer->eval)) != 0) {
		log_peer_info(&peer->conf,
		    "addpath eval change, reloading");
		peer->reconf_out = 1;
		peer->eval = peer->conf.eval;
	}
	/* add-path send needs rde_eval_all */
	rde_eval_all = 1;
}
if (peer->role != peer->conf.role) {
	if (reload == 0)
		log_debug("peer role change: "
		    "reloading Adj-RIB-In");
	peer->role = peer->conf.role;
	reload++;
}
peer->export_type = peer->conf.export_type;
peer->flags = peer->conf.flags;
if (peer->flags & PEERFLAG_EVALUATE_ALL0x04)
	rde_eval_all = 1;

if (peer->reconf_rib) {
	if (prefix_dump_new(peer, AID_UNSPEC0,
	    RDE_RUNNER_ROUNDS100, NULL((void *)0), rde_up_flush_upcall,
	    rde_softreconfig_in_done, NULL((void *)0)) == -1)
		fatal("%s: prefix_dump_new", __func__);
	log_peer_info(&peer->conf, "flushing Adj-RIB-Out");
	softreconfig++;	/* account for the running flush */
	continue;
}

/* reapply outbound filters for this peer */
fh = peer_apply_out_filter(peer, out_rules);

if (!rde_filter_equal(peer->out_rules, fh)) {
	char *p = log_fmt_peer(&peer->conf);
	log_debug("out filter change: reloading peer %s", p);
	free(p);
	peer->reconf_out = 1;
}
filterlist_free(fh);
}

/* bring ribs in sync */
for (rid = 0; rid < rib_size; rid++) {
struct rib *rib = rib_byid(rid);
if (rib == NULL((void *)0))
	continue;
rde_filter_calc_skip_steps(rib->in_rules_tmp);

/* flip rules, make new active */
fh = rib->in_rules;
rib->in_rules = rib->in_rules_tmp;
rib->in_rules_tmp = fh;

switch (rib->state) {
case RECONF_DELETE:
	rib_free(rib);
	break;
case RECONF_RELOAD:
	if (rib_update(rib)) {
		RB_FOREACH(peer, peer_tree, &peertable)for ((peer) = peer_tree_RB_MINMAX(&peertable, -1); (peer)
 != ((void *)0); (peer) = peer_tree_RB_NEXT(peer)) {
			/* ignore peerself */
			if (peer->conf.id == 0)
				continue;
			/* skip peers using a different rib */
			if (peer->loc_rib_id != rib->id)
				continue;
			/* peer rib is already being flushed */
			if (peer->reconf_rib)
				continue;

			if (prefix_dump_new(peer, AID_UNSPEC0,
			    RDE_RUNNER_ROUNDS100, NULL((void *)0),
			    rde_up_flush_upcall,
			    rde_softreconfig_in_done,
			    NULL((void *)0)) == -1)
				fatal("%s: prefix_dump_new",
				    __func__);

			log_peer_info(&peer->conf,
			    "flushing Adj-RIB-Out");
			/* account for the running flush */
			softreconfig++;
		}
	}

	rib->state = RECONF_KEEP;
	/* FALLTHROUGH */
case RECONF_KEEP:
	if (rde_filter_equal(rib->in_rules, rib->in_rules_tmp))
		/* rib is in sync */
		break;
	log_debug("in filter change: reloading RIB %s",
	    rib->name);
	rib->state = RECONF_RELOAD;
	reload++;
	break;
case RECONF_REINIT:
	/* new rib */
	rib->state = RECONF_RELOAD;
	reload++;
	break;
case RECONF_NONE:
	break;
}
filterlist_free(rib->in_rules_tmp);
rib->in_rules_tmp = NULL((void *)0);
}

/* old filters removed, free all sets */
free_rde_prefixsets(&prefixsets_old);
free_rde_prefixsets(&originsets_old);
as_sets_free(&as_sets_old);

log_info("RDE reconfigured");

softreconfig++;
if (reload > 0) {
if (rib_dump_new(RIB_ADJ_IN0, AID_UNSPEC0, RDE_RUNNER_ROUNDS100,
    NULL((void *)0), rde_softreconfig_in, rde_softreconfig_in_done,
    NULL((void *)0)) == -1)
	fatal("%s: rib_dump_new", __func__);
log_info("running softreconfig in");
} else {
rde_softreconfig_in_done((void *)1, AID_UNSPEC0);
}
3888}

3890static void
3891rde_softreconfig_in_done(void *arg, uint8_t dummy)
3892{
struct rde_peer	*peer;
uint16_t	 i;

softreconfig--;
/* one guy done but other dumps are still running */
if (softreconfig > 0)
return;

if (arg == NULL((void *)0))
log_info("softreconfig in done");

/* now do the Adj-RIB-Out sync and a possible FIB sync */
softreconfig = 0;
for (i = 0; i < rib_size; i++) {
struct rib *rib = rib_byid(i);
if (rib == NULL((void *)0))
	continue;
rib->state = RECONF_NONE;
if (rib->fibstate == RECONF_RELOAD) {
	if (rib_dump_new(i, AID_UNSPEC0, RDE_RUNNER_ROUNDS100,
	    rib, rde_softreconfig_sync_fib,
	    rde_softreconfig_sync_done, NULL((void *)0)) == -1)
		fatal("%s: rib_dump_new", __func__);
	softreconfig++;
	log_info("starting fib sync for rib %s",
	    rib->name);
} else if (rib->fibstate == RECONF_REINIT) {
	if (rib_dump_new(i, AID_UNSPEC0, RDE_RUNNER_ROUNDS100,
	    rib, rde_softreconfig_sync_reeval,
	    rde_softreconfig_sync_done, NULL((void *)0)) == -1)
		fatal("%s: rib_dump_new", __func__);
	softreconfig++;
	log_info("starting re-evaluation of rib %s",
	    rib->name);
}
}

RB_FOREACH(peer, peer_tree, &peertable)for ((peer) = peer_tree_RB_MINMAX(&peertable, -1); (peer)
 != ((void *)0); (peer) = peer_tree_RB_NEXT(peer)) {
uint8_t aid;

if (peer->reconf_out) {
	if (peer->export_type == EXPORT_NONE) {
		/* nothing to do here */
		peer->reconf_out = 0;
	} else if (peer->export_type == EXPORT_DEFAULT_ROUTE) {
		/* just resend the default route */
		for (aid = 0; aid < AID_MAX7; aid++) {
			if (peer->capa.mp[aid])
				up_generate_default(peer, aid);
		}
		peer->reconf_out = 0;
	} else
		rib_byid(peer->loc_rib_id)->state =
		    RECONF_RELOAD;
} else if (peer->reconf_rib) {
	/* dump the full table to neighbors that changed rib */
	for (aid = 0; aid < AID_MAX7; aid++) {
		if (peer->capa.mp[aid])
			peer_dump(peer, aid);
	}
}
}

for (i = 0; i < rib_size; i++) {
struct rib *rib = rib_byid(i);
if (rib == NULL((void *)0))
	continue;
if (rib->state == RECONF_RELOAD) {
	if (rib_dump_new(i, AID_UNSPEC0, RDE_RUNNER_ROUNDS100,
	    rib, rde_softreconfig_out,
	    rde_softreconfig_out_done, NULL((void *)0)) == -1)
		fatal("%s: rib_dump_new", __func__);
	softreconfig++;
	log_info("starting softreconfig out for rib %s",
	    rib->name);
}
}

/* if nothing to do move to last stage */
if (softreconfig == 0)
rde_softreconfig_done();
3974}

3976static void
3977rde_softreconfig_out_done(void *arg, uint8_t aid)
3978{
struct rib	*rib = arg;

/* this RIB dump is done */
log_info("softreconfig out done for %s", rib->name);

/* check if other dumps are still running */
if (--softreconfig == 0)
rde_softreconfig_done();
3987}

3989static void
3990rde_softreconfig_done(void)
3991{
uint16_t	i;

for (i = 0; i < rib_size; i++) {
struct rib *rib = rib_byid(i);
if (rib == NULL((void *)0))
	continue;
rib->state = RECONF_NONE;
}

log_info("RDE soft reconfiguration done");
imsg_compose(ibuf_main, IMSG_RECONF_DONE, 0, 0,
   -1, NULL((void *)0), 0);
4004}

4006static void
4007rde_softreconfig_in(struct rib_entry *re, void *bula)
4008{
struct filterstate	 state;
struct rib		*rib;
struct prefix		*p;
struct pt_entry		*pt;
struct rde_peer		*peer;
struct rde_aspath	*asp;
enum filter_actions	 action;
struct bgpd_addr	 prefix;
uint16_t		 i;
uint8_t			 aspa_vstate;

pt = re->prefix;
pt_getaddr(pt, &prefix);
TAILQ_FOREACH(p, &re->prefix_h, entry.list.rib)for((p) = ((&re->prefix_h)->tqh_first); (p) != ((void
 *)0); (p) = ((p)->entry.list.rib.tqe_next)) {
asp = prefix_aspath(p);
peer = prefix_peer(p);

/* possible role change update ASPA validation state */
if (prefix_aspa_vstate(p) == ASPA_NEVER_KNOWN0x08)
	aspa_vstate = ASPA_NEVER_KNOWN0x08;
else
	aspa_vstate = rde_aspa_validity(peer, asp, pt->aid);
prefix_set_vstate(p, prefix_roa_vstate(p), aspa_vstate);

/* skip announced networks, they are never filtered */
if (asp->flags & F_PREFIX_ANNOUNCED0x00400)
	continue;

for (i = RIB_LOC_START1; i < rib_size; i++) {
	rib = rib_byid(i);
	if (rib == NULL((void *)0))
		continue;

	if (rib->state != RECONF_RELOAD)
		continue;

	rde_filterstate_prep(&state, p);
	action = rde_filter(rib->in_rules, peer, peer, &prefix,
	    pt->prefixlen, &state);

	if (action == ACTION_ALLOW) {
		/* update Local-RIB */
		prefix_update(rib, peer, p->path_id,
		    p->path_id_tx, &state,
		    &prefix, pt->prefixlen);
	} else if (action == ACTION_DENY) {
		/* remove from Local-RIB */
		prefix_withdraw(rib, peer, p->path_id, &prefix,
		    pt->prefixlen);
	}

	rde_filterstate_clean(&state);
}
}
4063}

4065static void
4066rde_softreconfig_out(struct rib_entry *re, void *arg)
4067{
if (prefix_best(re) == NULL((void *)0))
/* no valid path for prefix */
return;

rde_generate_updates(re, NULL((void *)0), NULL((void *)0), EVAL_RECONF);
4073}

4075static void
4076rde_softreconfig_sync_reeval(struct rib_entry *re, void *arg)
4077{
struct prefix_queue	prefixes = TAILQ_HEAD_INITIALIZER(prefixes){ ((void *)0), &(prefixes).tqh_first };
struct prefix		*p, *next;
struct rib		*rib = arg;

if (rib->flags & F_RIB_NOEVALUATE0x0002) {
/*
 * evaluation process is turned off
 * all dependent adj-rib-out were already flushed
 * unlink nexthop if it was linked
 */
TAILQ_FOREACH(p, &re->prefix_h, entry.list.rib)for((p) = ((&re->prefix_h)->tqh_first); (p) != ((void
 *)0); (p) = ((p)->entry.list.rib.tqe_next)) {
	if (p->flags & PREFIX_NEXTHOP_LINKED0x40)
		nexthop_unlink(p);
	p->dmetric = PREFIX_DMETRIC_INVALID1;
}
return;
}

/* evaluation process is turned on, so evaluate all prefixes again */
TAILQ_CONCAT(&prefixes, &re->prefix_h, entry.list.rib)do { if (!(((&re->prefix_h)->tqh_first) == ((void *
)0))) { *(&prefixes)->tqh_last = (&re->prefix_h
)->tqh_first; (&re->prefix_h)->tqh_first->entry
.list.rib.tqe_prev = (&prefixes)->tqh_last; (&prefixes
)->tqh_last = (&re->prefix_h)->tqh_last; do { ((
&re->prefix_h))->tqh_first = ((void *)0); ((&re
->prefix_h))->tqh_last = &((&re->prefix_h))->
tqh_first; } while (0); } } while (0);

/*
* TODO: this code works but is not optimal. prefix_evaluate()
* does a lot of extra work in the worst case. Would be better
* to resort the list once and then call rde_generate_updates()
* and rde_send_kroute() once.
*/
TAILQ_FOREACH_SAFE(p, &prefixes, entry.list.rib, next)for ((p) = ((&prefixes)->tqh_first); (p) != ((void *)0
) && ((next) = ((p)->entry.list.rib.tqe_next), 1);
 (p) = (next)) {
/* need to re-link the nexthop if not already linked */
TAILQ_REMOVE(&prefixes, p, entry.list.rib)do { if (((p)->entry.list.rib.tqe_next) != ((void *)0)) (p
)->entry.list.rib.tqe_next->entry.list.rib.tqe_prev = (
p)->entry.list.rib.tqe_prev; else (&prefixes)->tqh_last
 = (p)->entry.list.rib.tqe_prev; *(p)->entry.list.rib.tqe_prev
 = (p)->entry.list.rib.tqe_next; ; ; } while (0);
if ((p->flags & PREFIX_NEXTHOP_LINKED0x40) == 0)
	nexthop_link(p);
prefix_evaluate(re, p, NULL((void *)0));
}
4112}

4114static void
4115rde_softreconfig_sync_fib(struct rib_entry *re, void *bula)
4116{
struct prefix *p;

if ((p = prefix_best(re)) != NULL((void *)0))
rde_send_kroute(re_rib(re), p, NULL((void *)0));
4121}

4123static void
4124rde_softreconfig_sync_done(void *arg, uint8_t aid)
4125{
struct rib *rib = arg;

/* this RIB dump is done */
if (rib->fibstate == RECONF_RELOAD)
log_info("fib sync done for %s", rib->name);
else
log_info("re-evaluation done for %s", rib->name);
rib->fibstate = RECONF_NONE;

/* check if other dumps are still running */
if (--softreconfig == 0)
rde_softreconfig_done();
4138}

4140/*
* ROA specific functions. The roa set is updated independent of the config
* so this runs outside of the softreconfig handlers.
*/
4144static void
4145rde_rpki_softreload(struct rib_entry *re, void *bula)
4146{
struct filterstate	 state;
struct rib		*rib;
struct prefix		*p;
struct pt_entry		*pt;
struct rde_peer		*peer;
struct rde_aspath	*asp;
enum filter_actions	 action;
struct bgpd_addr	 prefix;
uint8_t			 roa_vstate, aspa_vstate;
uint16_t		 i;

pt = re->prefix;
pt_getaddr(pt, &prefix);
TAILQ_FOREACH(p, &re->prefix_h, entry.list.rib)for((p) = ((&re->prefix_h)->tqh_first); (p) != ((void
 *)0); (p) = ((p)->entry.list.rib.tqe_next)) {
asp = prefix_aspath(p);
peer = prefix_peer(p);

/* ROA validation state update */
roa_vstate = rde_roa_validity(&rde_roa,
    &prefix, pt->prefixlen, aspath_origin(asp->aspath));

/* ASPA validation state update (if needed) */
if (prefix_aspa_vstate(p) == ASPA_NEVER_KNOWN0x08) {
	aspa_vstate = ASPA_NEVER_KNOWN0x08;
} else {
	if (asp->aspa_generation != rde_aspa_generation) {
		asp->aspa_generation = rde_aspa_generation;
		aspa_validation(rde_aspa, asp->aspath,
		    &asp->aspa_state);
	}
	aspa_vstate = rde_aspa_validity(peer, asp, pt->aid);
}

if (roa_vstate == prefix_roa_vstate(p) &&
    aspa_vstate == prefix_aspa_vstate(p))
	continue;

prefix_set_vstate(p, roa_vstate, aspa_vstate);
/* skip announced networks, they are never filtered */
if (asp->flags & F_PREFIX_ANNOUNCED0x00400)
	continue;

for (i = RIB_LOC_START1; i < rib_size; i++) {
	rib = rib_byid(i);
	if (rib == NULL((void *)0))
		continue;

	rde_filterstate_prep(&state, p);
	action = rde_filter(rib->in_rules, peer, peer, &prefix,
	    pt->prefixlen, &state);

	if (action == ACTION_ALLOW) {
		/* update Local-RIB */
		prefix_update(rib, peer, p->path_id,
		    p->path_id_tx, &state,
		    &prefix, pt->prefixlen);
	} else if (action == ACTION_DENY) {
		/* remove from Local-RIB */
		prefix_withdraw(rib, peer, p->path_id, &prefix,
		    pt->prefixlen);
	}

	rde_filterstate_clean(&state);
}
}
4212}

4214static int rpki_update_pending;

4216static void
4217rde_rpki_softreload_done(void *arg, uint8_t aid)
4218{
/* the roa update is done */
log_info("RPKI softreload done");
rpki_update_pending = 0;
4222}

4224static void
4225rde_rpki_reload(void)
4226{
if (rpki_update_pending) {
log_info("RPKI softreload skipped, old still running");
return;
}

rpki_update_pending = 1;
if (rib_dump_new(RIB_ADJ_IN0, AID_UNSPEC0, RDE_RUNNER_ROUNDS100,
   rib_byid(RIB_ADJ_IN0), rde_rpki_softreload,
   rde_rpki_softreload_done, NULL((void *)0)) == -1)
fatal("%s: rib_dump_new", __func__);
4237}

4239static int
4240rde_roa_reload(void)
4241{
struct rde_prefixset roa_old;

if (rpki_update_pending) {
trie_free(&roa_new.th);	/* can't use new roa table */
return 1;		/* force call to rde_rpki_reload */
}

roa_old = rde_roa;
rde_roa = roa_new;
memset(&roa_new, 0, sizeof(roa_new));

/* check if roa changed */
if (trie_equal(&rde_roa.th, &roa_old.th)) {
rde_roa.lastchange = roa_old.lastchange;
trie_free(&roa_old.th);	/* old roa no longer needed */
return 0;
}

rde_roa.lastchange = getmonotime();
trie_free(&roa_old.th);		/* old roa no longer needed */

log_debug("ROA change: reloading Adj-RIB-In");
return 1;
4265}

4267static int
4268rde_aspa_reload(void)
4269{
struct rde_aspa *aspa_old;

if (rpki_update_pending) {
aspa_table_free(aspa_new);	/* can't use new aspa table */
aspa_new = NULL((void *)0);
return 1;			/* rpki_client_relaod warns */
}

aspa_old = rde_aspa;
rde_aspa = aspa_new;
aspa_new = NULL((void *)0);

/* check if aspa changed */
if (aspa_table_equal(rde_aspa, aspa_old)) {
aspa_table_unchanged(rde_aspa, aspa_old);
aspa_table_free(aspa_old);	/* old aspa no longer needed */
return 0;
}

aspa_table_free(aspa_old);		/* old aspa no longer needed */
log_debug("ASPA change: reloading Adj-RIB-In");
rde_aspa_generation++;
return 1;
4293}

4295/*
* generic helper function
*/
4298uint32_t
4299rde_local_as(void)
4300{
return (conf->as);
4302}

4304int
4305rde_decisionflags(void)
4306{
return (conf->flags & BGPD_FLAG_DECISION_MASK0x0f00);
4308}

4310/* End-of-RIB marker, RFC 4724 */
4311static void
4312rde_peer_recv_eor(struct rde_peer *peer, uint8_t aid)
4313{
peer->stats.prefix_rcvd_eor++;
peer->recv_eor |= 1 << aid;

/*
* First notify SE to avert a possible race with the restart timeout.
* If the timeout fires before this imsg is processed by the SE it will
* result in the same operation since the timeout issues a FLUSH which
* does the same as the RESTARTED action (flushing stale routes).
* The logic in the SE is so that only one of FLUSH or RESTARTED will
* be sent back to the RDE and so peer_flush is only called once.
*/
if (imsg_compose(ibuf_se, IMSG_SESSION_RESTARTED, peer->conf.id,
   0, -1, &aid, sizeof(aid)) == -1)
fatal("imsg_compose error while receiving EoR");

log_peer_info(&peer->conf, "received %s EOR marker",
   aid2str(aid));
4331}

4333static void
4334rde_peer_send_eor(struct rde_peer *peer, uint8_t aid)
4335{
uint16_t	afi;
uint8_t		safi;

peer->stats.prefix_sent_eor++;
peer->sent_eor |= 1 << aid;

if (aid == AID_INET1) {
u_char null[4];

memset(&null, 0, 4);
if (imsg_compose(ibuf_se, IMSG_UPDATE, peer->conf.id,
    0, -1, &null, 4) == -1)
	fatal("imsg_compose error while sending EoR");
} else {
uint16_t	i;
u_char		buf[10];

if (aid2afi(aid, &afi, &safi) == -1)
	fatalx("peer_send_eor: bad AID");

i = 0;	/* v4 withdrawn len */
memcpy(&buf[0], &i, sizeof(i));
i = htons(6)(__uint16_t)(__builtin_constant_p(6) ? (__uint16_t)(((__uint16_t
)(6) & 0xffU) << 8 | ((__uint16_t)(6) & 0xff00U
) >> 8) : __swap16md(6));	/* path attr len */
memcpy(&buf[2], &i, sizeof(i));
buf[4] = ATTR_OPTIONAL0x80;
buf[5] = ATTR_MP_UNREACH_NLRI;
buf[6] = 3;	/* withdrawn len */
i = htons(afi)(__uint16_t)(__builtin_constant_p(afi) ? (__uint16_t)(((__uint16_t
)(afi) & 0xffU) << 8 | ((__uint16_t)(afi) & 0xff00U
) >> 8) : __swap16md(afi));
memcpy(&buf[7], &i, sizeof(i));
buf[9] = safi;

if (imsg_compose(ibuf_se, IMSG_UPDATE, peer->conf.id,
    0, -1, &buf, 10) == -1)
	fatal("%s %d imsg_compose error in peer_send_eor",
	    __func__, __LINE__4370);
}

log_peer_info(&peer->conf, "sending %s EOR marker",
   aid2str(aid));
4375}

4377void
4378rde_peer_send_rrefresh(struct rde_peer *peer, uint8_t aid, uint8_t subtype)
4379{
struct route_refresh rr;

/* not strickly needed, the SE checks as well */
if (peer->capa.enhanced_rr == 0)
return;

switch (subtype) {
case ROUTE_REFRESH_END_RR2:
case ROUTE_REFRESH_BEGIN_RR1:
break;
default:
fatalx("%s unexpected subtype %d", __func__, subtype);
}

rr.aid = aid;
rr.subtype = subtype;

if (imsg_compose(ibuf_se, IMSG_REFRESH, peer->conf.id, 0, -1,
   &rr, sizeof(rr)) == -1)

log_peer_info(&peer->conf, "sending %s %s marker",
   aid2str(aid), subtype == ROUTE_REFRESH_END_RR2 ? "EoRR" : "BoRR");
4402}

4404/*
* network announcement stuff
*/
4407void
4408network_add(struct network_config *nc, struct filterstate *state)
4409{
struct l3vpn		*vpn;
struct filter_set_head	*vpnset = NULL((void *)0);
struct in_addr		 prefix4;
struct in6_addr		 prefix6;
uint32_t		 path_id_tx;
uint16_t		 i;
uint8_t			 vstate;

if (nc->rd != 0) {
SIMPLEQ_FOREACH(vpn, &conf->l3vpns, entry)for((vpn) = ((&conf->l3vpns)->sqh_first); (vpn) != (
(void *)0); (vpn) = ((vpn)->entry.sqe_next)) {
	if (vpn->rd != nc->rd)
		continue;
	switch (nc->prefix.aid) {
	case AID_INET1:
		prefix4 = nc->prefix.v4ba.v4;
		memset(&nc->prefix, 0, sizeof(nc->prefix));
		nc->prefix.aid = AID_VPN_IPv43;
		nc->prefix.rd = vpn->rd;
		nc->prefix.v4ba.v4 = prefix4;
		nc->prefix.labellen = 3;
		nc->prefix.labelstack[0] =
		    (vpn->label >> 12) & 0xff;
		nc->prefix.labelstack[1] =
		    (vpn->label >> 4) & 0xff;
		nc->prefix.labelstack[2] =
		    (vpn->label << 4) & 0xf0;
		nc->prefix.labelstack[2] |= BGP_MPLS_BOS0x01;
		vpnset = &vpn->export;
		break;
	case AID_INET62:
		prefix6 = nc->prefix.v6ba.v6;
		memset(&nc->prefix, 0, sizeof(nc->prefix));
		nc->prefix.aid = AID_VPN_IPv64;
		nc->prefix.rd = vpn->rd;
		nc->prefix.v6ba.v6 = prefix6;
		nc->prefix.labellen = 3;
		nc->prefix.labelstack[0] =
		    (vpn->label >> 12) & 0xff;
		nc->prefix.labelstack[1] =
		    (vpn->label >> 4) & 0xff;
		nc->prefix.labelstack[2] =
		    (vpn->label << 4) & 0xf0;
		nc->prefix.labelstack[2] |= BGP_MPLS_BOS0x01;
		vpnset = &vpn->export;
		break;
	default:
		log_warnx("unable to VPNize prefix");
		filterset_free(&nc->attrset);
		return;
	}
	break;
}
if (vpn == NULL((void *)0)) {
	log_warnx("network_add: "
	    "prefix %s/%u in non-existing l3vpn %s",
	    log_addr(&nc->prefix), nc->prefixlen,
	    log_rd(nc->rd));
	return;
}
}

rde_apply_set(&nc->attrset, peerself, peerself, state, nc->prefix.aid);
if (vpnset)
rde_apply_set(vpnset, peerself, peerself, state,
    nc->prefix.aid);

vstate = rde_roa_validity(&rde_roa, &nc->prefix, nc->prefixlen,
   aspath_origin(state->aspath.aspath));
rde_filterstate_set_vstate(state, vstate, ASPA_NEVER_KNOWN0x08);

path_id_tx = pathid_assign(peerself, 0, &nc->prefix, nc->prefixlen);
if (prefix_update(rib_byid(RIB_ADJ_IN0), peerself, 0, path_id_tx,
   state, &nc->prefix, nc->prefixlen) == 1)
peerself->stats.prefix_cnt++;
for (i = RIB_LOC_START1; i < rib_size; i++) {
struct rib *rib = rib_byid(i);
if (rib == NULL((void *)0))
	continue;
rde_update_log("announce", i, peerself,
    state->nexthop ? &state->nexthop->exit_nexthop : NULL((void *)0),
    &nc->prefix, nc->prefixlen);
prefix_update(rib, peerself, 0, path_id_tx, state, &nc->prefix,
    nc->prefixlen);
}
filterset_free(&nc->attrset);
4495}

4497void
4498network_delete(struct network_config *nc)
4499{
struct l3vpn	*vpn;
struct in_addr	 prefix4;
struct in6_addr	 prefix6;
uint32_t	 i;

if (nc->rd) {
SIMPLEQ_FOREACH(vpn, &conf->l3vpns, entry)for((vpn) = ((&conf->l3vpns)->sqh_first); (vpn) != (
(void *)0); (vpn) = ((vpn)->entry.sqe_next)) {
	if (vpn->rd != nc->rd)
		continue;
	switch (nc->prefix.aid) {
	case AID_INET1:
		prefix4 = nc->prefix.v4ba.v4;
		memset(&nc->prefix, 0, sizeof(nc->prefix));
		nc->prefix.aid = AID_VPN_IPv43;
		nc->prefix.rd = vpn->rd;
		nc->prefix.v4ba.v4 = prefix4;
		nc->prefix.labellen = 3;
		nc->prefix.labelstack[0] =
		    (vpn->label >> 12) & 0xff;
		nc->prefix.labelstack[1] =
		    (vpn->label >> 4) & 0xff;
		nc->prefix.labelstack[2] =
		    (vpn->label << 4) & 0xf0;
		nc->prefix.labelstack[2] |= BGP_MPLS_BOS0x01;
		break;
	case AID_INET62:
		prefix6 = nc->prefix.v6ba.v6;
		memset(&nc->prefix, 0, sizeof(nc->prefix));
		nc->prefix.aid = AID_VPN_IPv64;
		nc->prefix.rd = vpn->rd;
		nc->prefix.v6ba.v6 = prefix6;
		nc->prefix.labellen = 3;
		nc->prefix.labelstack[0] =
		    (vpn->label >> 12) & 0xff;
		nc->prefix.labelstack[1] =
		    (vpn->label >> 4) & 0xff;
		nc->prefix.labelstack[2] =
		    (vpn->label << 4) & 0xf0;
		nc->prefix.labelstack[2] |= BGP_MPLS_BOS0x01;
		break;
	default:
		log_warnx("unable to VPNize prefix");
		return;
	}
}
}

for (i = RIB_LOC_START1; i < rib_size; i++) {
struct rib *rib = rib_byid(i);
if (rib == NULL((void *)0))
	continue;
if (prefix_withdraw(rib, peerself, 0, &nc->prefix,
    nc->prefixlen))
	rde_update_log("withdraw announce", i, peerself,
	    NULL((void *)0), &nc->prefix, nc->prefixlen);
}
if (prefix_withdraw(rib_byid(RIB_ADJ_IN0), peerself, 0, &nc->prefix,
   nc->prefixlen))
peerself->stats.prefix_cnt--;
4559}

4561static void
4562network_dump_upcall(struct rib_entry *re, void *ptr)
4563{
struct prefix		*p;
struct rde_aspath	*asp;
struct kroute_full	 kf;
struct bgpd_addr	 addr;
struct rde_dump_ctx	*ctx = ptr;

TAILQ_FOREACH(p, &re->prefix_h, entry.list.rib)for((p) = ((&re->prefix_h)->tqh_first); (p) != ((void
 *)0); (p) = ((p)->entry.list.rib.tqe_next)) {
asp = prefix_aspath(p);
if (!(asp->flags & F_PREFIX_ANNOUNCED0x00400))
	continue;
pt_getaddr(p->pt, &addr);

memset(&kf, 0, sizeof(kf));
kf.prefix = addr;
kf.prefixlen = p->pt->prefixlen;
if (prefix_nhvalid(p) && prefix_nexthop(p) != NULL((void *)0))
	kf.nexthop = prefix_nexthop(p)->true_nexthop;
else
	kf.nexthop.aid = kf.prefix.aid;
if ((asp->flags & F_ANN_DYNAMIC0x00800) == 0)
	kf.flags = F_STATIC0x0008;
if (imsg_compose(ibuf_se_ctl, IMSG_CTL_SHOW_NETWORK, 0,
    ctx->req.pid, -1, &kf, sizeof(kf)) == -1)
	log_warnx("%s: imsg_compose error", __func__);
}
4589}

4591static void
4592network_flush_upcall(struct rib_entry *re, void *ptr)
4593{
struct bgpd_addr addr;
struct prefix *p;
uint32_t i;
uint8_t prefixlen;

p = prefix_bypeer(re, peerself, 0);
if (p == NULL((void *)0))
return;
if ((prefix_aspath(p)->flags & F_ANN_DYNAMIC0x00800) != F_ANN_DYNAMIC0x00800)
return;

pt_getaddr(re->prefix, &addr);
prefixlen = re->prefix->prefixlen;

for (i = RIB_LOC_START1; i < rib_size; i++) {
struct rib *rib = rib_byid(i);
if (rib == NULL((void *)0))
	continue;
if (prefix_withdraw(rib, peerself, 0, &addr, prefixlen) == 1)
	rde_update_log("flush announce", i, peerself,
	    NULL((void *)0), &addr, prefixlen);
}

if (prefix_withdraw(rib_byid(RIB_ADJ_IN0), peerself, 0, &addr,
   prefixlen) == 1)
peerself->stats.prefix_cnt--;
4620}

4622/*
* flowspec announcement stuff
*/
4625void
4626flowspec_add(struct flowspec *f, struct filterstate *state,
  struct filter_set_head *attrset)
4628{
struct pt_entry *pte;
uint32_t path_id_tx;

rde_apply_set(attrset, peerself, peerself, state, f->aid);
rde_filterstate_set_vstate(state, ROA_NOTFOUND0x0, ASPA_NEVER_KNOWN0x08);
path_id_tx = peerself->path_id_tx; /* XXX should use pathid_assign() */

pte = pt_get_flow(f);
if (pte == NULL((void *)0))
pte = pt_add_flow(f);

if (prefix_flowspec_update(peerself, state, pte, path_id_tx) == 1)
peerself->stats.prefix_cnt++;
4642}

4644void
4645flowspec_delete(struct flowspec *f)
4646{
struct pt_entry *pte;

pte = pt_get_flow(f);
if (pte == NULL((void *)0))
return;

if (prefix_flowspec_withdraw(peerself, pte) == 1)
peerself->stats.prefix_cnt--;
4655}

4657static void
4658flowspec_flush_upcall(struct rib_entry *re, void *ptr)
4659{
struct prefix *p;

p = prefix_bypeer(re, peerself, 0);
if (p == NULL((void *)0))
return;
if ((prefix_aspath(p)->flags & F_ANN_DYNAMIC0x00800) != F_ANN_DYNAMIC0x00800)
return;
if (prefix_flowspec_withdraw(peerself, re->prefix) == 1)
peerself->stats.prefix_cnt--;
4669}

4671static void
4672flowspec_dump_upcall(struct rib_entry *re, void *ptr)
4673{
pid_t *pid = ptr;
struct prefix		*p;
struct rde_aspath	*asp;
struct rde_community	*comm;
struct flowspec		ff;
struct ibuf		*ibuf;
uint8_t			*flow;
int			len;

TAILQ_FOREACH(p, &re->prefix_h, entry.list.rib)for((p) = ((&re->prefix_h)->tqh_first); (p) != ((void
 *)0); (p) = ((p)->entry.list.rib.tqe_next)) {
asp = prefix_aspath(p);
if (!(asp->flags & F_PREFIX_ANNOUNCED0x00400))
	continue;
comm = prefix_communities(p);

len = pt_getflowspec(p->pt, &flow);

memset(&ff, 0, sizeof(ff));
ff.aid = p->pt->aid;
ff.len = len;
if ((asp->flags & F_ANN_DYNAMIC0x00800) == 0)
	ff.flags = F_STATIC0x0008;
if ((ibuf = imsg_create(ibuf_se_ctl, IMSG_CTL_SHOW_FLOWSPEC, 0,
    *pid, FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data)) + len)) == NULL((void *)0))
		continue;
if (imsg_add(ibuf, &ff, FLOWSPEC_SIZE(__builtin_offsetof(struct flowspec, data))) == -1 ||
    imsg_add(ibuf, flow, len) == -1)
	continue;
imsg_close(ibuf_se_ctl, ibuf);
if (comm->nentries > 0) {
	if (imsg_compose(ibuf_se_ctl,
	    IMSG_CTL_SHOW_RIB_COMMUNITIES, 0, *pid, -1,
	    comm->communities,
	    comm->nentries * sizeof(struct community)) == -1)
		continue;
}
}
4711}

4713static void
4714flowspec_dump_done(void *ptr, uint8_t aid)
4715{
pid_t *pid = ptr;

imsg_compose(ibuf_se_ctl, IMSG_CTL_END, 0, *pid, -1, NULL((void *)0), 0);
4719}


4722/* clean up */
4723void
4724rde_shutdown(void)
4725{
/*
* the decision process is turned off if rde_quit = 1 and
* rde_shutdown depends on this.
*/

/* First all peers go down */
peer_foreach(peer_down, NULL((void *)0));

/* free filters */
filterlist_free(out_rules);
filterlist_free(out_rules_tmp);

/* kill the VPN configs */
free_l3vpns(&conf->l3vpns);

/* now check everything */
rib_shutdown();
nexthop_shutdown();
path_shutdown();
attr_shutdown();
pt_shutdown();
peer_shutdown();
4748}

4750struct rde_prefixset *
4751rde_find_prefixset(char *name, struct rde_prefixset_head *p)
4752{
struct rde_prefixset *ps;

SIMPLEQ_FOREACH(ps, p, entry)for((ps) = ((p)->sqh_first); (ps) != ((void *)0); (ps) = (
(ps)->entry.sqe_next)) {
if (!strcmp(ps->name, name))
	return (ps);
}
return (NULL((void *)0));
4760}

4762void
4763rde_mark_prefixsets_dirty(struct rde_prefixset_head *psold,
  struct rde_prefixset_head *psnew)
4765{
struct rde_prefixset *new, *old;

SIMPLEQ_FOREACH(new, psnew, entry)for((new) = ((psnew)->sqh_first); (new) != ((void *)0); (new
) = ((new)->entry.sqe_next)) {
if ((psold == NULL((void *)0)) ||
    (old = rde_find_prefixset(new->name, psold)) == NULL((void *)0)) {
	new->dirty = 1;
	new->lastchange = getmonotime();
} else {
	if (trie_equal(&new->th, &old->th) == 0) {
		new->dirty = 1;
		new->lastchange = getmonotime();
	} else
		new->lastchange = old->lastchange;
}
}
4781}

4783uint8_t
4784rde_roa_validity(struct rde_prefixset *ps, struct bgpd_addr *prefix,
  uint8_t plen, uint32_t as)
4786{
int r;

r = trie_roa_check(&ps->th, prefix, plen, as);
return (r & ROA_MASK0x3);
4791}

4793static int
4794ovs_match(struct prefix *p, uint32_t flag)
4795{
if (flag & (F_CTL_OVS_VALID0x80000|F_CTL_OVS_INVALID0x100000|F_CTL_OVS_NOTFOUND0x200000)) {
switch (prefix_roa_vstate(p)) {
case ROA_VALID0x2:
	if (!(flag & F_CTL_OVS_VALID0x80000))
		return 0;
	break;
case ROA_INVALID0x1:
	if (!(flag & F_CTL_OVS_INVALID0x100000))
		return 0;
	break;
case ROA_NOTFOUND0x0:
	if (!(flag & F_CTL_OVS_NOTFOUND0x200000))
		return 0;
	break;
default:
	break;
}
}

return 1;
4816}

4818static int
4819avs_match(struct prefix *p, uint32_t flag)
4820{
if (flag & (F_CTL_AVS_VALID0x1000000|F_CTL_AVS_INVALID0x2000000|F_CTL_AVS_UNKNOWN0x4000000)) {
switch (prefix_aspa_vstate(p) & ASPA_MASK0x03) {
case ASPA_VALID0x02:
	if (!(flag & F_CTL_AVS_VALID0x1000000))
		return 0;
	break;
case ASPA_INVALID0x01:
	if (!(flag & F_CTL_AVS_INVALID0x2000000))
		return 0;
	break;
case ASPA_UNKNOWN0x00:
	if (!(flag & F_CTL_AVS_UNKNOWN0x4000000))
		return 0;
	break;
default:
	break;
}
}

return 1;
4841}