bgpd.c revision 1.137 
1/*	$OpenBSD: bgpd.c,v 1.137 2006/05/27 21:24:36 claudio Exp $ */
2
3/*
4 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19#include <sys/types.h>
20#include <sys/socket.h>
21#include <sys/wait.h>
22#include <netinet/in.h>
23#include <arpa/inet.h>
24#include <err.h>
25#include <errno.h>
26#include <fcntl.h>
27#include <poll.h>
28#include <pwd.h>
29#include <signal.h>
30#include <stdio.h>
31#include <stdlib.h>
32#include <string.h>
33#include <unistd.h>
34
35#include "mrt.h"
36#include "bgpd.h"
37#include "session.h"
38
39void		sighdlr(int);
40__dead void	usage(void);
41int		main(int, char *[]);
42int		check_child(pid_t, const char *);
43int		send_filterset(struct imsgbuf *, struct filter_set_head *);
44int		reconfigure(char *, struct bgpd_config *, struct mrt_head *,
45		    struct peer **, struct filter_head *);
46int		dispatch_imsg(struct imsgbuf *, int);
47
48int			 rfd = -1;
49int			 cflags = 0;
50struct filter_set_head	*connectset;
51struct filter_set_head	*connectset6;
52struct filter_set_head	*staticset;
53struct filter_set_head	*staticset6;
54volatile sig_atomic_t	 mrtdump = 0;
55volatile sig_atomic_t	 quit = 0;
56volatile sig_atomic_t	 sigchld = 0;
57volatile sig_atomic_t	 reconfig = 0;
58pid_t			 reconfpid = 0;
59struct imsgbuf		*ibuf_se;
60struct imsgbuf		*ibuf_rde;
61
62void
63sighdlr(int sig)
64{
65	switch (sig) {
66	case SIGTERM:
67	case SIGINT:
68		quit = 1;
69		break;
70	case SIGCHLD:
71		sigchld = 1;
72		break;
73	case SIGHUP:
74		reconfig = 1;
75		break;
76	case SIGALRM:
77	case SIGUSR1:
78		mrtdump = 1;
79		break;
80	}
81}
82
83__dead void
84usage(void)
85{
86	extern char *__progname;
87
88	fprintf(stderr, "usage: %s [-dnv] ", __progname);
89	fprintf(stderr, "[-D macro=value] [-f file] [-r path] [-s path]\n");
90	exit(1);
91}
92
93#define PFD_PIPE_SESSION	0
94#define PFD_PIPE_ROUTE		1
95#define PFD_SOCK_ROUTE		2
96#define POLL_MAX		3
97#define MAX_TIMEOUT		3600
98
99int
100main(int argc, char *argv[])
101{
102	struct bgpd_config	 conf;
103	struct peer		*peer_l, *p;
104	struct mrt_head		 mrt_l;
105	struct network_head	 net_l;
106	struct filter_head	*rules_l;
107	struct network		*net;
108	struct filter_rule	*r;
109	struct mrt		*m;
110	struct listen_addr	*la;
111	struct pollfd		 pfd[POLL_MAX];
112	pid_t			 io_pid = 0, rde_pid = 0, pid;
113	char			*conffile;
114	int			 debug = 0;
115	int			 ch, timeout, nfds;
116	int			 pipe_m2s[2];
117	int			 pipe_m2r[2];
118	int			 pipe_s2r[2];
119
120	conffile = CONFFILE;
121	bgpd_process = PROC_MAIN;
122
123	log_init(1);		/* log to stderr until daemonized */
124
125	if ((rules_l = calloc(1, sizeof(struct filter_head))) == NULL)
126		err(1, NULL);
127
128	bzero(&conf, sizeof(conf));
129	LIST_INIT(&mrt_l);
130	TAILQ_INIT(&net_l);
131	TAILQ_INIT(rules_l);
132	peer_l = NULL;
133	conf.csock = SOCKET_NAME;
134
135	while ((ch = getopt(argc, argv, "dD:f:nr:s:v")) != -1) {
136		switch (ch) {
137		case 'd':
138			debug = 1;
139			break;
140		case 'D':
141			if (cmdline_symset(optarg) < 0)
142				log_warnx("could not parse macro definition %s",
143				    optarg);
144			break;
145		case 'f':
146			conffile = optarg;
147			break;
148		case 'n':
149			conf.opts |= BGPD_OPT_NOACTION;
150			break;
151		case 'v':
152			if (conf.opts & BGPD_OPT_VERBOSE)
153				conf.opts |= BGPD_OPT_VERBOSE2;
154			conf.opts |= BGPD_OPT_VERBOSE;
155			break;
156		case 'r':
157			conf.rcsock = optarg;
158			break;
159		case 's':
160			conf.csock = optarg;
161			break;
162		default:
163			usage();
164			/* NOTREACHED */
165		}
166	}
167
168	if (parse_config(conffile, &conf, &mrt_l, &peer_l, &net_l, rules_l)) {
169		free(rules_l);
170		exit(1);
171	}
172
173	if (conf.opts & BGPD_OPT_NOACTION) {
174		if (conf.opts & BGPD_OPT_VERBOSE)
175			print_config(&conf, &net_l, peer_l, rules_l, &mrt_l);
176		else
177			fprintf(stderr, "configuration OK\n");
178		exit(0);
179	}
180	cflags = conf.flags;
181	connectset = &conf.connectset;
182	staticset = &conf.staticset;
183	connectset6 = &conf.connectset6;
184	staticset6 = &conf.staticset6;
185
186	if (geteuid())
187		errx(1, "need root privileges");
188
189	if (getpwnam(BGPD_USER) == NULL)
190		errx(1, "unknown user %s", BGPD_USER);
191
192	log_init(debug);
193
194	if (!debug)
195		daemon(1, 0);
196
197	log_info("startup");
198
199	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_m2s) == -1)
200		fatal("socketpair");
201	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_m2r) == -1)
202		fatal("socketpair");
203	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_s2r) == -1)
204		fatal("socketpair");
205	session_socket_blockmode(pipe_m2s[0], BM_NONBLOCK);
206	session_socket_blockmode(pipe_m2s[1], BM_NONBLOCK);
207	session_socket_blockmode(pipe_m2r[0], BM_NONBLOCK);
208	session_socket_blockmode(pipe_m2r[1], BM_NONBLOCK);
209	session_socket_blockmode(pipe_s2r[0], BM_NONBLOCK);
210	session_socket_blockmode(pipe_s2r[1], BM_NONBLOCK);
211
212	prepare_listeners(&conf);
213
214	/* fork children */
215	rde_pid = rde_main(&conf, peer_l, &net_l, rules_l, &mrt_l,
216	    pipe_m2r, pipe_s2r, pipe_m2s);
217	io_pid = session_main(&conf, peer_l, &net_l, rules_l, &mrt_l,
218	    pipe_m2s, pipe_s2r, pipe_m2r);
219
220	setproctitle("parent");
221
222	signal(SIGTERM, sighdlr);
223	signal(SIGINT, sighdlr);
224	signal(SIGCHLD, sighdlr);
225	signal(SIGHUP, sighdlr);
226	signal(SIGALRM, sighdlr);
227	signal(SIGUSR1, sighdlr);
228
229	close(pipe_m2s[1]);
230	close(pipe_m2r[1]);
231	close(pipe_s2r[0]);
232	close(pipe_s2r[1]);
233
234	if ((ibuf_se = malloc(sizeof(struct imsgbuf))) == NULL ||
235	    (ibuf_rde = malloc(sizeof(struct imsgbuf))) == NULL)
236		fatal(NULL);
237	imsg_init(ibuf_se, pipe_m2s[0]);
238	imsg_init(ibuf_rde, pipe_m2r[0]);
239	mrt_init(ibuf_rde, ibuf_se);
240	if ((rfd = kr_init(!(conf.flags & BGPD_FLAG_NO_FIB_UPDATE))) == -1)
241		quit = 1;
242	if (pftable_clear_all() != 0)
243		quit = 1;
244
245	while ((net = TAILQ_FIRST(&net_l)) != NULL) {
246		TAILQ_REMOVE(&net_l, net, entry);
247		filterset_free(&net->net.attrset);
248		free(net);
249	}
250
251	while ((r = TAILQ_FIRST(rules_l)) != NULL) {
252		TAILQ_REMOVE(rules_l, r, entry);
253		free(r);
254	}
255	TAILQ_FOREACH(la, conf.listen_addrs, entry) {
256		close(la->fd);
257		la->fd = -1;
258	}
259
260	mrt_reconfigure(&mrt_l);
261
262	while (quit == 0) {
263		bzero(pfd, sizeof(pfd));
264		pfd[PFD_PIPE_SESSION].fd = ibuf_se->fd;
265		pfd[PFD_PIPE_SESSION].events = POLLIN;
266		if (ibuf_se->w.queued)
267			pfd[PFD_PIPE_SESSION].events |= POLLOUT;
268		pfd[PFD_PIPE_ROUTE].fd = ibuf_rde->fd;
269		pfd[PFD_PIPE_ROUTE].events = POLLIN;
270		if (ibuf_rde->w.queued)
271			pfd[PFD_PIPE_ROUTE].events |= POLLOUT;
272		pfd[PFD_SOCK_ROUTE].fd = rfd;
273		pfd[PFD_SOCK_ROUTE].events = POLLIN;
274
275		timeout = mrt_timeout(&mrt_l);
276		if (timeout > MAX_TIMEOUT)
277			timeout = MAX_TIMEOUT;
278
279		if ((nfds = poll(pfd, POLL_MAX, timeout * 1000)) == -1)
280			if (errno != EINTR) {
281				log_warn("poll error");
282				quit = 1;
283			}
284
285		if (nfds > 0 && pfd[PFD_PIPE_SESSION].revents & POLLOUT)
286			if (msgbuf_write(&ibuf_se->w) < 0) {
287				log_warn("pipe write error (to SE)");
288				quit = 1;
289			}
290
291		if (nfds > 0 && pfd[PFD_PIPE_ROUTE].revents & POLLOUT)
292			if (msgbuf_write(&ibuf_rde->w) < 0) {
293				log_warn("pipe write error (to RDE)");
294				quit = 1;
295			}
296
297		if (nfds > 0 && pfd[PFD_PIPE_SESSION].revents & POLLIN) {
298			if (dispatch_imsg(ibuf_se, PFD_PIPE_SESSION) == -1)
299				quit = 1;
300		}
301
302		if (nfds > 0 && pfd[PFD_PIPE_ROUTE].revents & POLLIN) {
303			if (dispatch_imsg(ibuf_rde, PFD_PIPE_ROUTE) == -1)
304				quit = 1;
305		}
306
307		if (nfds > 0 && pfd[PFD_SOCK_ROUTE].revents & POLLIN) {
308			if (kr_dispatch_msg() == -1)
309				quit = 1;
310		}
311
312		if (reconfig) {
313			u_int	error;
314
315			reconfig = 0;
316			log_info("rereading config");
317			switch (reconfigure(conffile, &conf, &mrt_l, &peer_l,
318			    rules_l)) {
319			case -1:	/* fatal error */
320				quit = 1;
321				break;
322			case 0:		/* all OK */
323				error = 0;
324				break;
325			default:	/* parse error */
326				error = CTL_RES_PARSE_ERROR;
327				break;
328			}
329			if (reconfpid != 0) {
330				send_imsg_session(IMSG_CTL_RESULT, reconfpid,
331				    &error, sizeof(error));
332				reconfpid = 0;
333			}
334		}
335
336		if (sigchld) {
337			sigchld = 0;
338			if (check_child(io_pid, "session engine")) {
339				quit = 1;
340				io_pid = 0;
341			}
342			if (check_child(rde_pid, "route decision engine")) {
343				quit = 1;
344				rde_pid = 0;
345			}
346		}
347
348		if (mrtdump) {
349			mrtdump = 0;
350			mrt_handler(&mrt_l);
351		}
352	}
353
354	signal(SIGCHLD, SIG_IGN);
355
356	if (io_pid)
357		kill(io_pid, SIGTERM);
358
359	if (rde_pid)
360		kill(rde_pid, SIGTERM);
361
362	while ((p = peer_l) != NULL) {
363		peer_l = p->next;
364		free(p);
365	}
366	while ((m = LIST_FIRST(&mrt_l)) != NULL) {
367		LIST_REMOVE(m, entry);
368		free(m);
369	}
370	while ((la = TAILQ_FIRST(conf.listen_addrs)) != NULL) {
371		TAILQ_REMOVE(conf.listen_addrs, la, entry);
372		close(la->fd);
373		free(la);
374	}
375
376	free(rules_l);
377	control_cleanup(conf.csock);
378	control_cleanup(conf.rcsock);
379	kr_shutdown();
380	pftable_clear_all();
381	free(conf.listen_addrs);
382
383	do {
384		if ((pid = wait(NULL)) == -1 &&
385		    errno != EINTR && errno != ECHILD)
386			fatal("wait");
387	} while (pid != -1 || (pid == -1 && errno == EINTR));
388
389	msgbuf_clear(&ibuf_se->w);
390	free(ibuf_se);
391	msgbuf_clear(&ibuf_rde->w);
392	free(ibuf_rde);
393
394	log_info("Terminating");
395	return (0);
396}
397
398int
399check_child(pid_t pid, const char *pname)
400{
401	int	status;
402
403	if (waitpid(pid, &status, WNOHANG) > 0) {
404		if (WIFEXITED(status)) {
405			log_warnx("Lost child: %s exited", pname);
406			return (1);
407		}
408		if (WIFSIGNALED(status)) {
409			log_warnx("Lost child: %s terminated; signal %d",
410			    pname, WTERMSIG(status));
411			return (1);
412		}
413	}
414
415	return (0);
416}
417
418int
419send_filterset(struct imsgbuf *i, struct filter_set_head *set)
420{
421	struct filter_set	*s;
422
423	TAILQ_FOREACH(s, set, entry)
424		if (imsg_compose(i, IMSG_FILTER_SET, 0, 0, -1, s,
425		    sizeof(struct filter_set)) == -1)
426			return (-1);
427	return (0);
428}
429
430int
431reconfigure(char *conffile, struct bgpd_config *conf, struct mrt_head *mrt_l,
432    struct peer **peer_l, struct filter_head *rules_l)
433{
434	struct network_head	 net_l;
435	struct network		*n;
436	struct peer		*p;
437	struct filter_rule	*r;
438	struct listen_addr	*la;
439
440	if (parse_config(conffile, conf, mrt_l, peer_l, &net_l, rules_l)) {
441		log_warnx("config file %s has errors, not reloading",
442		    conffile);
443		return (1);
444	}
445
446	cflags = conf->flags;
447	connectset = &conf->connectset;
448	staticset = &conf->staticset;
449	connectset6 = &conf->connectset6;
450	staticset6 = &conf->staticset6;
451
452	prepare_listeners(conf);
453
454	/* start reconfiguration */
455	if (imsg_compose(ibuf_se, IMSG_RECONF_CONF, 0, 0, -1,
456	    conf, sizeof(struct bgpd_config)) == -1)
457		return (-1);
458	if (imsg_compose(ibuf_rde, IMSG_RECONF_CONF, 0, 0, -1,
459	    conf, sizeof(struct bgpd_config)) == -1)
460		return (-1);
461
462	/* send peer list and listeners to the SE */
463	for (p = *peer_l; p != NULL; p = p->next)
464		if (imsg_compose(ibuf_se, IMSG_RECONF_PEER, p->conf.id, 0, -1,
465		    &p->conf, sizeof(struct peer_config)) == -1)
466			return (-1);
467
468	TAILQ_FOREACH(la, conf->listen_addrs, entry) {
469		if (imsg_compose(ibuf_se, IMSG_RECONF_LISTENER, 0, 0, la->fd,
470		    la, sizeof(struct listen_addr)) == -1)
471			return (-1);
472		la->fd = -1;
473	}
474
475	/* networks for the RDE */
476	while ((n = TAILQ_FIRST(&net_l)) != NULL) {
477		if (imsg_compose(ibuf_rde, IMSG_NETWORK_ADD, 0, 0, -1,
478		    &n->net, sizeof(struct network_config)) == -1)
479			return (-1);
480		if (send_filterset(ibuf_rde, &n->net.attrset) == -1)
481			return (-1);
482		if (imsg_compose(ibuf_rde, IMSG_NETWORK_DONE, 0, 0, -1,
483		    NULL, 0) == -1)
484			return (-1);
485		TAILQ_REMOVE(&net_l, n, entry);
486		filterset_free(&n->net.attrset);
487		free(n);
488	}
489
490	/* redistribute list needs to be reloaded too */
491	if (kr_reload() == -1)
492		return (-1);
493
494	/* filters for the RDE */
495	while ((r = TAILQ_FIRST(rules_l)) != NULL) {
496		if (imsg_compose(ibuf_rde, IMSG_RECONF_FILTER, 0, 0, -1,
497		    r, sizeof(struct filter_rule)) == -1)
498			return (-1);
499		if (send_filterset(ibuf_rde, &r->set) == -1)
500			return (-1);
501		TAILQ_REMOVE(rules_l, r, entry);
502		filterset_free(&r->set);
503		free(r);
504	}
505
506	/* singal both childs to replace their config */
507	if (imsg_compose(ibuf_se, IMSG_RECONF_DONE, 0, 0, -1, NULL, 0) == -1 ||
508	    imsg_compose(ibuf_rde, IMSG_RECONF_DONE, 0, 0, -1, NULL, 0) == -1)
509		return (-1);
510
511	/* mrt changes can be sent out of bound */
512	mrt_reconfigure(mrt_l);
513	return (0);
514}
515
516int
517dispatch_imsg(struct imsgbuf *ibuf, int idx)
518{
519	struct imsg		 imsg;
520	int			 n;
521	int			 rv;
522
523	if ((n = imsg_read(ibuf)) == -1)
524		return (-1);
525
526	if (n == 0) {	/* connection closed */
527		log_warnx("dispatch_imsg in main: pipe closed");
528		return (-1);
529	}
530
531	rv = 0;
532	for (;;) {
533		if ((n = imsg_get(ibuf, &imsg)) == -1)
534			return (-1);
535
536		if (n == 0)
537			break;
538
539		switch (imsg.hdr.type) {
540		case IMSG_KROUTE_CHANGE:
541			if (idx != PFD_PIPE_ROUTE)
542				log_warnx("route request not from RDE");
543			else if (kr_change(imsg.data))
544				rv = -1;
545			break;
546		case IMSG_KROUTE_DELETE:
547			if (idx != PFD_PIPE_ROUTE)
548				log_warnx("route request not from RDE");
549			else if (kr_delete(imsg.data))
550				rv = -1;
551			break;
552		case IMSG_KROUTE6_CHANGE:
553			if (idx != PFD_PIPE_ROUTE)
554				log_warnx("route request not from RDE");
555			else if (kr6_change(imsg.data))
556				rv = -1;
557			break;
558		case IMSG_KROUTE6_DELETE:
559			if (idx != PFD_PIPE_ROUTE)
560				log_warnx("route request not from RDE");
561			else if (kr6_delete(imsg.data))
562				rv = -1;
563			break;
564		case IMSG_NEXTHOP_ADD:
565			if (idx != PFD_PIPE_ROUTE)
566				log_warnx("nexthop request not from RDE");
567			else
568				if (imsg.hdr.len != IMSG_HEADER_SIZE +
569				    sizeof(struct bgpd_addr))
570					log_warnx("wrong imsg len");
571				else if (kr_nexthop_add(imsg.data) == -1)
572					rv = -1;
573			break;
574		case IMSG_NEXTHOP_REMOVE:
575			if (idx != PFD_PIPE_ROUTE)
576				log_warnx("nexthop request not from RDE");
577			else
578				if (imsg.hdr.len != IMSG_HEADER_SIZE +
579				    sizeof(struct bgpd_addr))
580					log_warnx("wrong imsg len");
581				else
582					kr_nexthop_delete(imsg.data);
583			break;
584		case IMSG_PFTABLE_ADD:
585			if (idx != PFD_PIPE_ROUTE)
586				log_warnx("pftable request not from RDE");
587			else
588				if (imsg.hdr.len != IMSG_HEADER_SIZE +
589				    sizeof(struct pftable_msg))
590					log_warnx("wrong imsg len");
591				else if (pftable_addr_add(imsg.data) != 0)
592					rv = -1;
593			break;
594		case IMSG_PFTABLE_REMOVE:
595			if (idx != PFD_PIPE_ROUTE)
596				log_warnx("pftable request not from RDE");
597			else
598				if (imsg.hdr.len != IMSG_HEADER_SIZE +
599				    sizeof(struct pftable_msg))
600					log_warnx("wrong imsg len");
601				else if (pftable_addr_remove(imsg.data) != 0)
602					rv = -1;
603			break;
604		case IMSG_PFTABLE_COMMIT:
605			if (idx != PFD_PIPE_ROUTE)
606				log_warnx("pftable request not from RDE");
607			else
608				if (imsg.hdr.len != IMSG_HEADER_SIZE)
609					log_warnx("wrong imsg len");
610				else if (pftable_commit() != 0)
611					rv = -1;
612			break;
613		case IMSG_CTL_RELOAD:
614			if (idx != PFD_PIPE_SESSION)
615				log_warnx("reload request not from SE");
616			else
617				reconfig = 1;
618				reconfpid = imsg.hdr.pid;
619			break;
620		case IMSG_CTL_FIB_COUPLE:
621			if (idx != PFD_PIPE_SESSION)
622				log_warnx("couple request not from SE");
623			else
624				kr_fib_couple();
625			break;
626		case IMSG_CTL_FIB_DECOUPLE:
627			if (idx != PFD_PIPE_SESSION)
628				log_warnx("decouple request not from SE");
629			else
630				kr_fib_decouple();
631			break;
632		case IMSG_CTL_KROUTE:
633		case IMSG_CTL_KROUTE_ADDR:
634		case IMSG_CTL_SHOW_NEXTHOP:
635		case IMSG_CTL_SHOW_INTERFACE:
636			if (idx != PFD_PIPE_SESSION)
637				log_warnx("kroute request not from SE");
638			else
639				kr_show_route(&imsg);
640			break;
641		case IMSG_IFINFO:
642			if (idx != PFD_PIPE_SESSION)
643				log_warnx("IFINFO request not from SE");
644			else if (imsg.hdr.len != IMSG_HEADER_SIZE + IFNAMSIZ)
645				log_warnx("IFINFO request with wrong len");
646			else
647				kr_ifinfo(imsg.data);
648			break;
649		default:
650			break;
651		}
652		imsg_free(&imsg);
653		if (rv != 0)
654			return (rv);
655	}
656	return (0);
657}
658
659void
660send_nexthop_update(struct kroute_nexthop *msg)
661{
662	char	*gw = NULL;
663
664	if (msg->gateway.af)
665		if (asprintf(&gw, ": via %s",
666		    log_addr(&msg->gateway)) == -1) {
667			log_warn("send_nexthop_update");
668			quit = 1;
669		}
670
671	log_info("nexthop %s now %s%s%s", log_addr(&msg->nexthop),
672	    msg->valid ? "valid" : "invalid",
673	    msg->connected ? ": directly connected" : "",
674	    msg->gateway.af ? gw : "");
675
676	free(gw);
677
678	if (imsg_compose(ibuf_rde, IMSG_NEXTHOP_UPDATE, 0, 0, -1,
679	    msg, sizeof(struct kroute_nexthop)) == -1)
680		quit = 1;
681}
682
683void
684send_imsg_session(int type, pid_t pid, void *data, u_int16_t datalen)
685{
686	imsg_compose(ibuf_se, type, 0, pid, -1, data, datalen);
687}
688
689int
690bgpd_redistribute(int type, struct kroute *kr, struct kroute6 *kr6)
691{
692	struct network_config	 net;
693	struct filter_set_head	*h;
694
695	if ((cflags & BGPD_FLAG_REDIST_CONNECTED) && kr &&
696	    (kr->flags & F_CONNECTED))
697		h = connectset;
698	else if ((cflags & BGPD_FLAG_REDIST_STATIC) && kr &&
699	    (kr->flags & F_STATIC))
700		h = staticset;
701	else if ((cflags & BGPD_FLAG_REDIST6_CONNECTED) && kr6 &&
702	    (kr6->flags & F_CONNECTED))
703		h = connectset6;
704	else if ((cflags & BGPD_FLAG_REDIST6_STATIC) && kr6 &&
705	    (kr6->flags & F_STATIC))
706		h = staticset6;
707	else
708		return (0);
709
710	bzero(&net, sizeof(net));
711	if (kr && kr6)
712		fatalx("bgpd_redistribute: unable to redistribute v4 and v6"
713		    "together");
714	if (kr != NULL) {
715		net.prefix.af = AF_INET;
716		net.prefix.v4.s_addr = kr->prefix.s_addr;
717		net.prefixlen = kr->prefixlen;
718	}
719	if (kr6 != NULL) {
720		net.prefix.af = AF_INET6;
721		memcpy(&net.prefix.v6, &kr6->prefix, sizeof(struct in6_addr));
722		net.prefixlen = kr6->prefixlen;
723	}
724
725
726	if (imsg_compose(ibuf_rde, type, 0, 0, -1, &net,
727	    sizeof(struct network_config)) == -1)
728		return (-1);
729
730	/* networks that get deleted don't need to send the filter set */
731	if (type == IMSG_NETWORK_REMOVE)
732		return (1);
733
734	if (send_filterset(ibuf_rde, h) == -1)
735		return (-1);
736	if (imsg_compose(ibuf_rde, IMSG_NETWORK_DONE, 0, 0, -1, NULL, 0) == -1)
737		return (-1);
738
739	return (1);
740}
741
742int
743bgpd_filternexthop(struct kroute *kr, struct kroute6 *kr6)
744{
745	/* kernel routes are never filtered */
746	if (kr && kr->flags & F_KERNEL && kr->prefixlen != 0)
747		return (0);
748	if (kr6 && kr6->flags & F_KERNEL && kr6->prefixlen != 0)
749		return (0);
750
751	if (cflags & BGPD_FLAG_NEXTHOP_BGP) {
752		if (kr && kr->flags & F_BGPD_INSERTED)
753			return (0);
754		if (kr6 && kr6->flags & F_BGPD_INSERTED)
755			return (0);
756	}
757
758	if (cflags & BGPD_FLAG_NEXTHOP_DEFAULT) {
759		if (kr && kr->prefixlen == 0)
760			return (0);
761		if (kr6 && kr6->prefixlen == 0)
762			return (0);
763	}
764
765	return (1);
766}
767