xref: /openbsd/usr.sbin/ripd/ripe.c (revision 7b5b21db) 
1 /*	$OpenBSD: ripe.c,v 1.26 2021/01/19 10:00:36 claudio Exp $ */
2 
3 /*
4  * Copyright (c) 2006 Michele Marchetto <mydecay@openbeer.it>
5  * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
6  * Copyright (c) 2004 Esben Norby <norby@openbsd.org>
7  * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
8  *
9  * Permission to use, copy, modify, and distribute this software for any
10  * purpose with or without fee is hereby granted, provided that the above
11  * copyright notice and this permission notice appear in all copies.
12  *
13  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20  */
21 
22 #include <sys/types.h>
23 #include <sys/socket.h>
24 #include <sys/queue.h>
25 #include <netinet/in.h>
26 #include <arpa/inet.h>
27 #include <net/if_types.h>
28 #include <stdlib.h>
29 #include <signal.h>
30 #include <string.h>
31 #include <fcntl.h>
32 #include <pwd.h>
33 #include <unistd.h>
34 #include <event.h>
35 #include <err.h>
36 #include <errno.h>
37 #include <stdio.h>
38 
39 #include "ripd.h"
40 #include "rip.h"
41 #include "ripe.h"
42 #include "log.h"
43 #include "control.h"
44 
45 void		 ripe_sig_handler(int, short, void *);
46 __dead void	 ripe_shutdown(void);
47 
48 struct ripd_conf	*oeconf = NULL;
49 struct imsgev		*iev_main;
50 struct imsgev		*iev_rde;
51 
52 /* ARGSUSED */
53 void
54 ripe_sig_handler(int sig, short event, void *bula)
55 {
56 	switch (sig) {
57 	case SIGINT:
58 	case SIGTERM:
59 		ripe_shutdown();
60 		/* NOTREACHED */
61 	default:
62 		fatalx("unexpected signal");
63 	}
64 }
65 
66 /* rip engine */
67 pid_t
68 ripe(struct ripd_conf *xconf, int pipe_parent2ripe[2], int pipe_ripe2rde[2],
69     int pipe_parent2rde[2])
70 {
71 	struct event		 ev_sigint, ev_sigterm;
72 	struct sockaddr_in	 addr;
73 	struct iface		*iface = NULL;
74 	struct passwd		*pw;
75 	struct redistribute	*r;
76 	pid_t			 pid;
77 
78 	switch (pid = fork()) {
79 	case -1:
80 		fatal("cannot fork");
81 	case 0:
82 		break;
83 	default:
84 		return (pid);
85 	}
86 
87 	/* create ripd control socket outside chroot */
88 	if (control_init(xconf->csock) == -1)
89 		fatalx("control socket setup failed");
90 
91 	addr.sin_family = AF_INET;
92 	addr.sin_port = htons(RIP_PORT);
93 	addr.sin_addr.s_addr = INADDR_ANY;
94 
95 	if ((xconf->rip_socket = socket(AF_INET,
96 	    SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
97 	    IPPROTO_UDP)) == -1)
98 		fatalx("error creating socket");
99 
100 	if (bind(xconf->rip_socket, (struct sockaddr *)&addr,
101 	    sizeof(addr)) == -1)
102 		fatal("error binding socket");
103 
104 	/* set some defaults */
105 	if (if_set_opt(xconf->rip_socket) == -1)
106 		fatal("if_set_opt");
107 
108 	if (if_set_mcast_ttl(xconf->rip_socket, IP_DEFAULT_MULTICAST_TTL) == -1)
109 		fatal("if_set_mcast_ttl");
110 
111 	if (if_set_mcast_loop(xconf->rip_socket) == -1)
112 		fatal("if_set_mcast_loop");
113 
114 	if (if_set_tos(xconf->rip_socket, IPTOS_PREC_INTERNETCONTROL) == -1)
115 		fatal("if_set_tos");
116 
117 	if_set_recvbuf(xconf->rip_socket);
118 
119 	oeconf = xconf;
120 
121 	if ((pw = getpwnam(RIPD_USER)) == NULL)
122 		fatal("getpwnam");
123 
124 	if (chroot(pw->pw_dir) == -1)
125 		fatal("chroot");
126 	if (chdir("/") == -1)
127 		fatal("chdir(\"/\")");
128 
129 	setproctitle("rip engine");
130 	ripd_process = PROC_RIP_ENGINE;
131 	log_procname = log_procnames[ripd_process];
132 
133 	if (setgroups(1, &pw->pw_gid) ||
134 	    setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
135 	    setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
136 		fatal("can't drop privileges");
137 
138 	event_init();
139 	nbr_init(NBR_HASHSIZE);
140 
141 	/* setup signal handler */
142 	signal_set(&ev_sigint, SIGINT, ripe_sig_handler, NULL);
143 	signal_set(&ev_sigterm, SIGTERM, ripe_sig_handler, NULL);
144 	signal_add(&ev_sigint, NULL);
145 	signal_add(&ev_sigterm, NULL);
146 	signal(SIGPIPE, SIG_IGN);
147 	signal(SIGHUP, SIG_IGN);
148 
149 	/* setup pipes */
150 	close(pipe_parent2ripe[0]);
151 	close(pipe_ripe2rde[1]);
152 	close(pipe_parent2rde[0]);
153 	close(pipe_parent2rde[1]);
154 
155 	if ((iev_rde = malloc(sizeof(struct imsgev))) == NULL ||
156 	    (iev_main = malloc(sizeof(struct imsgev))) == NULL)
157 		fatal(NULL);
158 	imsg_init(&iev_rde->ibuf, pipe_ripe2rde[0]);
159 	iev_rde->handler = ripe_dispatch_rde;
160 	imsg_init(&iev_main->ibuf, pipe_parent2ripe[1]);
161 	iev_main->handler = ripe_dispatch_main;
162 
163 	/* setup event handler */
164 	iev_rde->events = EV_READ;
165 	event_set(&iev_rde->ev, iev_rde->ibuf.fd, iev_rde->events,
166 	    iev_rde->handler, iev_rde);
167 	event_add(&iev_rde->ev, NULL);
168 
169 	iev_main->events = EV_READ;
170 	event_set(&iev_main->ev, iev_main->ibuf.fd, iev_main->events,
171 	    iev_main->handler, iev_main);
172 	event_add(&iev_main->ev, NULL);
173 
174 	event_set(&oeconf->ev, oeconf->rip_socket, EV_READ|EV_PERSIST,
175 	    recv_packet, oeconf);
176 	event_add(&oeconf->ev, NULL);
177 
178 	/* remove unneeded config stuff */
179 	while ((r = SIMPLEQ_FIRST(&oeconf->redist_list)) != NULL) {
180 		SIMPLEQ_REMOVE_HEAD(&oeconf->redist_list, entry);
181 		free(r);
182 	}
183 
184 	/* listen on ripd control socket */
185 	control_listen();
186 
187 	if ((pkt_ptr = calloc(1, IBUF_READ_SIZE)) == NULL)
188 		fatal("ripe");
189 
190 	/* start interfaces */
191 	LIST_FOREACH(iface, &xconf->iface_list, entry) {
192 		if_init(xconf, iface);
193 		if (if_fsm(iface, IF_EVT_UP))
194 			log_debug("ripe: error starting interface: %s",
195 			    iface->name);
196 	}
197 
198 	if (pledge("stdio inet mcast", NULL) == -1)
199 		fatal("pledge");
200 
201 	evtimer_set(&oeconf->report_timer, report_timer, oeconf);
202 	start_report_timer();
203 
204 	ripe_imsg_compose_rde(IMSG_FULL_REQUEST, 0, 0, NULL, 0);
205 
206 	event_dispatch();
207 
208 	ripe_shutdown();
209 	/* NOTREACHED */
210 	return (0);
211 }
212 
213 int
214 ripe_imsg_compose_parent(int type, pid_t pid, void *data, u_int16_t datalen)
215 {
216 	return (imsg_compose_event(iev_main, type, 0, pid, -1, data, datalen));
217 }
218 
219 int
220 ripe_imsg_compose_rde(int type, u_int32_t peerid, pid_t pid,
221     void *data, u_int16_t datalen)
222 {
223 	return (imsg_compose_event(iev_rde, type, peerid, pid, -1,
224 	    data, datalen));
225 }
226 
227 /* ARGSUSED */
228 void
229 ripe_dispatch_main(int fd, short event, void *bula)
230 {
231 	struct imsg	 imsg;
232 	struct imsgev	*iev = bula;
233 	struct imsgbuf	*ibuf = &iev->ibuf;
234 	struct kif	*kif;
235 	struct iface	*iface;
236 	ssize_t		 n;
237 	int		 link_ok, shut = 0;
238 
239 	if (event & EV_READ) {
240 		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
241 			fatal("imsg_read error");
242 		if (n == 0)	/* connection closed */
243 			shut = 1;
244 	}
245 	if (event & EV_WRITE) {
246 		if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN)
247 			fatal("msgbuf_write");
248 		if (n == 0)	/* connection closed */
249 			shut = 1;
250 	}
251 
252 	for (;;) {
253 		if ((n = imsg_get(ibuf, &imsg)) == -1)
254 			fatal("ripe_dispatch_main: imsg_get error");
255 		if (n == 0)
256 			break;
257 
258 		switch (imsg.hdr.type) {
259 		case IMSG_IFINFO:
260 			if (imsg.hdr.len - IMSG_HEADER_SIZE !=
261 			    sizeof(struct kif))
262 				fatalx("IFINFO imsg with wrong len");
263 			kif = imsg.data;
264 			link_ok = (kif->flags & IFF_UP) &&
265 			    LINK_STATE_IS_UP(kif->link_state);
266 
267 			LIST_FOREACH(iface, &oeconf->iface_list, entry) {
268 				if (kif->ifindex == iface->ifindex) {
269 					iface->flags = kif->flags;
270 					iface->linkstate = kif->link_state;
271 
272 					if (link_ok) {
273 						if_fsm(iface, IF_EVT_UP);
274 						log_warnx("interface %s up",
275 						    iface->name);
276 					} else {
277 						if_fsm(iface, IF_EVT_DOWN);
278 						log_warnx("interface %s down",
279 						    iface->name);
280 					}
281 				}
282 			}
283 			break;
284 		case IMSG_CTL_IFINFO:
285 		case IMSG_CTL_KROUTE:
286 		case IMSG_CTL_KROUTE_ADDR:
287 		case IMSG_CTL_END:
288 			control_imsg_relay(&imsg);
289 			break;
290 		default:
291 			log_debug("ripe_dispatch_main: error handling imsg %d",
292 			    imsg.hdr.type);
293 			break;
294 		}
295 		imsg_free(&imsg);
296 	}
297 	if (!shut)
298 		imsg_event_add(iev);
299 	else {
300 		/* this pipe is dead, so remove the event handler */
301 		event_del(&iev->ev);
302 		event_loopexit(NULL);
303 	}
304 }
305 
306 /* ARGSUSED */
307 void
308 ripe_dispatch_rde(int fd, short event, void *bula)
309 {
310 	struct rip_route	*rr;
311 	struct imsg		 imsg;
312 	struct imsgev		*iev = bula;
313 	struct imsgbuf		*ibuf = &iev->ibuf;
314 	struct iface		*iface;
315 	struct nbr		*nbr;
316 	ssize_t			 n;
317 	int			 shut = 0;
318 
319 	if (event & EV_READ) {
320 		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
321 			fatal("imsg_read error");
322 		if (n == 0)	/* connection closed */
323 			shut = 1;
324 	}
325 	if (event & EV_WRITE) {
326 		if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN)
327 			fatal("msgbuf_write");
328 		if (n == 0)	/* connection closed */
329 			shut = 1;
330 	}
331 
332 	for (;;) {
333 		if ((n = imsg_get(ibuf, &imsg)) == -1)
334 			fatal("ripe_dispatch_rde: imsg_get error");
335 		if (n == 0)
336 			break;
337 
338 		switch (imsg.hdr.type) {
339 		case IMSG_REQUEST_ADD:
340 			if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(*rr))
341 				fatalx("invalid size of RDE request");
342 
343 			if ((rr = malloc(sizeof(*rr))) == NULL)
344 				fatal("ripe_dispatch_rde");
345 
346 			memcpy(rr, imsg.data, sizeof(*rr));
347 
348 			if (imsg.hdr.peerid != 0) {
349 				if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) ==
350 				    NULL) {
351 					log_debug("unknown neighbor id %u",
352 					    imsg.hdr.peerid);
353 					free(rr);
354 					break;
355 				}
356 				add_entry(&nbr->rq_list, rr);
357 				break;
358 			}
359 
360 			LIST_FOREACH(iface, &oeconf->iface_list, entry) {
361 				add_entry(&iface->rq_list, rr);
362 			}
363 			break;
364 		case IMSG_SEND_REQUEST:
365 			if (imsg.hdr.peerid != 0) {
366 				if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) ==
367 				    NULL) {
368 					log_debug("unknown neighbor id %u",
369 					    imsg.hdr.peerid);
370 					break;
371 				}
372 				send_request(&nbr->rq_list, NULL, nbr);
373 				break;
374 			}
375 
376 			LIST_FOREACH(iface, &oeconf->iface_list, entry) {
377 				send_request(&iface->rq_list, iface, NULL);
378 			}
379 			break;
380 		case IMSG_RESPONSE_ADD:
381 			if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(*rr))
382 				fatalx("invalid size of RDE request");
383 
384 			if ((rr = malloc(sizeof(*rr))) == NULL)
385 				fatal("ripe_dispatch_rde");
386 
387 			memcpy(rr, imsg.data, sizeof(*rr));
388 
389 			if (imsg.hdr.peerid == 0) {
390 				LIST_FOREACH(iface, &oeconf->iface_list, entry)
391 					add_entry(&iface->rp_list, rr);
392 
393 				break;
394 			}
395 
396 			if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) == NULL) {
397 				log_debug("unknown neighbor id %u",
398 				    imsg.hdr.peerid);
399 				free(rr);
400 				break;
401 			}
402 			add_entry(&nbr->rp_list, rr);
403 
404 			break;
405 		case IMSG_SEND_RESPONSE:
406 			if (imsg.hdr.peerid == 0) {
407 				LIST_FOREACH(iface, &oeconf->iface_list,
408 				    entry) {
409 					send_response(&iface->rp_list,
410 					    iface, NULL);
411 				}
412 				break;
413 			}
414 
415 			if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) == NULL) {
416 				log_debug("unknown neighbor id %u",
417 				    imsg.hdr.peerid);
418 				break;
419 			}
420 			send_response(&nbr->rp_list, NULL, nbr);
421 			nbr_fsm(nbr, NBR_EVT_RESPONSE_SENT);
422 			break;
423 		case IMSG_SEND_TRIGGERED_UPDATE:
424 			if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(struct
425 			    rip_route))
426 				fatalx("invalid size of RDE request");
427 
428 			rr = imsg.data;
429 
430 			LIST_FOREACH(iface, &oeconf->iface_list,
431 			    entry) {
432 				if (rr->ifindex != iface->ifindex)
433 					send_triggered_update(iface, rr);
434 			}
435 			break;
436 		case IMSG_CTL_END:
437 		case IMSG_CTL_SHOW_RIB:
438 			control_imsg_relay(&imsg);
439 			break;
440 		default:
441 			log_debug("ripe_dispatch_rde: error handling imsg %d",
442 			    imsg.hdr.type);
443 			break;
444 		}
445 		imsg_free(&imsg);
446 	}
447 	if (!shut)
448 		imsg_event_add(iev);
449 	else {
450 		/* this pipe is dead, so remove the event handler */
451 		event_del(&iev->ev);
452 		event_loopexit(NULL);
453 	}
454 }
455 
456 __dead void
457 ripe_shutdown(void)
458 {
459 	struct iface	*iface;
460 
461 	/* close pipes */
462 	msgbuf_write(&iev_rde->ibuf.w);
463 	msgbuf_clear(&iev_rde->ibuf.w);
464 	close(iev_rde->ibuf.fd);
465 	msgbuf_write(&iev_main->ibuf.w);
466 	msgbuf_clear(&iev_main->ibuf.w);
467 	close(iev_main->ibuf.fd);
468 
469 	LIST_FOREACH(iface, &oeconf->iface_list, entry) {
470 		if (if_fsm(iface, IF_EVT_DOWN)) {
471 			log_debug("error stopping interface %s",
472 			    iface->name);
473 		}
474 	}
475 	while ((iface = LIST_FIRST(&oeconf->iface_list)) != NULL) {
476 		LIST_REMOVE(iface, entry);
477 		if_del(iface);
478 	}
479 
480 	close(oeconf->rip_socket);
481 
482 	/* clean up */
483 	free(iev_rde);
484 	free(iev_main);
485 	free(oeconf);
486 	free(pkt_ptr);
487 
488 	log_info("rip engine exiting");
489 	_exit(0);
490 }
491 
492 void
493 ripe_iface_ctl(struct ctl_conn *c, unsigned int idx)
494 {
495 	struct iface		*iface;
496 	struct ctl_iface	*ictl;
497 
498 	LIST_FOREACH(iface, &oeconf->iface_list, entry) {
499 		if (idx == 0 || idx == iface->ifindex) {
500 			ictl = if_to_ctl(iface);
501 			imsg_compose_event(&c->iev, IMSG_CTL_SHOW_IFACE,
502 			    0, 0, -1, ictl, sizeof(struct ctl_iface));
503 		}
504 	}
505 }
506 
507 void
508 ripe_nbr_ctl(struct ctl_conn *c)
509 {
510 	struct iface	*iface;
511 	struct nbr	*nbr;
512 	struct ctl_nbr	*nctl;
513 
514 	LIST_FOREACH(iface, &oeconf->iface_list, entry)
515 		LIST_FOREACH(nbr, &iface->nbr_list, entry) {
516 				nctl = nbr_to_ctl(nbr);
517 				imsg_compose_event(&c->iev,
518 				    IMSG_CTL_SHOW_NBR, 0, 0, -1, nctl,
519 				    sizeof(struct ctl_nbr));
520 		}
521 
522 	imsg_compose_event(&c->iev, IMSG_CTL_END, 0, 0, -1, NULL, 0);
523 }
524 
525 void
526 ripe_demote_iface(struct iface *iface, int active)
527 {
528 	struct demote_msg	dmsg;
529 
530 	if (ripd_process != PROC_RIP_ENGINE ||
531 	    iface->demote_group[0] == '\0')
532 		return;
533 
534 	bzero(&dmsg, sizeof(dmsg));
535 	strlcpy(dmsg.demote_group, iface->demote_group,
536 	    sizeof(dmsg.demote_group));
537 	if (active)
538 		dmsg.level = -1;
539 	else
540 		dmsg.level = 1;
541 
542 	ripe_imsg_compose_parent(IMSG_DEMOTE, 0, &dmsg, sizeof(dmsg));
543 }
544