1 /* $OpenBSD: ripe.c,v 1.14 2011/07/04 04:34:14 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 #include <stdlib.h> 39 40 #include "ripd.h" 41 #include "rip.h" 42 #include "ripe.h" 43 #include "log.h" 44 #include "control.h" 45 46 void ripe_sig_handler(int, short, void *); 47 void ripe_shutdown(void); 48 49 struct ripd_conf *oeconf = NULL; 50 struct imsgev *iev_main; 51 struct imsgev *iev_rde; 52 53 /* ARGSUSED */ 54 void 55 ripe_sig_handler(int sig, short event, void *bula) 56 { 57 switch (sig) { 58 case SIGINT: 59 case SIGTERM: 60 ripe_shutdown(); 61 /* NOTREACHED */ 62 default: 63 fatalx("unexpected signal"); 64 } 65 } 66 67 /* rip engine */ 68 pid_t 69 ripe(struct ripd_conf *xconf, int pipe_parent2ripe[2], int pipe_ripe2rde[2], 70 int pipe_parent2rde[2]) 71 { 72 struct event ev_sigint, ev_sigterm; 73 struct sockaddr_in addr; 74 struct iface *iface = NULL; 75 struct passwd *pw; 76 struct redistribute *r; 77 pid_t pid; 78 79 switch (pid = fork()) { 80 case -1: 81 fatal("cannot fork"); 82 case 0: 83 break; 84 default: 85 return (pid); 86 } 87 88 /* create ripd control socket outside chroot */ 89 if (control_init() == -1) 90 fatalx("control socket setup failed"); 91 92 addr.sin_family = AF_INET; 93 addr.sin_port = htons(RIP_PORT); 94 addr.sin_addr.s_addr = INADDR_ANY; 95 96 if ((xconf->rip_socket = socket(AF_INET, SOCK_DGRAM, 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 132 if (setgroups(1, &pw->pw_gid) || 133 setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) || 134 setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid)) 135 fatal("can't drop privileges"); 136 137 event_init(); 138 nbr_init(NBR_HASHSIZE); 139 140 /* setup signal handler */ 141 signal_set(&ev_sigint, SIGINT, ripe_sig_handler, NULL); 142 signal_set(&ev_sigterm, SIGTERM, ripe_sig_handler, NULL); 143 signal_add(&ev_sigint, NULL); 144 signal_add(&ev_sigterm, NULL); 145 signal(SIGPIPE, SIG_IGN); 146 signal(SIGHUP, SIG_IGN); 147 148 /* setup pipes */ 149 close(pipe_parent2ripe[0]); 150 close(pipe_ripe2rde[1]); 151 close(pipe_parent2rde[0]); 152 close(pipe_parent2rde[1]); 153 154 if ((iev_rde = malloc(sizeof(struct imsgev))) == NULL || 155 (iev_main = malloc(sizeof(struct imsgev))) == NULL) 156 fatal(NULL); 157 imsg_init(&iev_rde->ibuf, pipe_ripe2rde[0]); 158 iev_rde->handler = ripe_dispatch_rde; 159 imsg_init(&iev_main->ibuf, pipe_parent2ripe[1]); 160 iev_main->handler = ripe_dispatch_main; 161 162 /* setup event handler */ 163 iev_rde->events = EV_READ; 164 event_set(&iev_rde->ev, iev_rde->ibuf.fd, iev_rde->events, 165 iev_rde->handler, iev_rde); 166 event_add(&iev_rde->ev, NULL); 167 168 iev_main->events = EV_READ; 169 event_set(&iev_main->ev, iev_main->ibuf.fd, iev_main->events, 170 iev_main->handler, iev_main); 171 event_add(&iev_main->ev, NULL); 172 173 event_set(&oeconf->ev, oeconf->rip_socket, EV_READ|EV_PERSIST, 174 recv_packet, oeconf); 175 event_add(&oeconf->ev, NULL); 176 177 /* remove unneeded config stuff */ 178 while ((r = SIMPLEQ_FIRST(&oeconf->redist_list)) != NULL) { 179 SIMPLEQ_REMOVE_HEAD(&oeconf->redist_list, entry); 180 free(r); 181 } 182 183 /* listen on ripd control socket */ 184 TAILQ_INIT(&ctl_conns); 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 evtimer_set(&oeconf->report_timer, report_timer, oeconf); 199 start_report_timer(); 200 201 ripe_imsg_compose_rde(IMSG_FULL_REQUEST, 0, 0, NULL, 0); 202 203 event_dispatch(); 204 205 ripe_shutdown(); 206 /* NOTREACHED */ 207 return (0); 208 } 209 210 int 211 ripe_imsg_compose_parent(int type, pid_t pid, void *data, u_int16_t datalen) 212 { 213 return (imsg_compose_event(iev_main, type, 0, pid, -1, data, datalen)); 214 } 215 216 int 217 ripe_imsg_compose_rde(int type, u_int32_t peerid, pid_t pid, 218 void *data, u_int16_t datalen) 219 { 220 return (imsg_compose_event(iev_rde, type, peerid, pid, -1, 221 data, datalen)); 222 } 223 224 /* ARGSUSED */ 225 void 226 ripe_dispatch_main(int fd, short event, void *bula) 227 { 228 struct imsg imsg; 229 struct imsgev *iev = bula; 230 struct imsgbuf *ibuf = &iev->ibuf; 231 struct kif *kif; 232 struct iface *iface; 233 ssize_t n; 234 int link_ok, shut = 0; 235 236 if (event & EV_READ) { 237 if ((n = imsg_read(ibuf)) == -1) 238 fatal("imsg_read error"); 239 if (n == 0) /* connection closed */ 240 shut = 1; 241 } 242 if (event & EV_WRITE) { 243 if (msgbuf_write(&ibuf->w) == -1) 244 fatal("msgbuf_write"); 245 } 246 247 for (;;) { 248 if ((n = imsg_get(ibuf, &imsg)) == -1) 249 fatal("ripe_dispatch_main: imsg_read error"); 250 if (n == 0) 251 break; 252 253 switch (imsg.hdr.type) { 254 case IMSG_IFINFO: 255 if (imsg.hdr.len - IMSG_HEADER_SIZE != 256 sizeof(struct kif)) 257 fatalx("IFINFO imsg with wrong len"); 258 kif = imsg.data; 259 link_ok = (kif->flags & IFF_UP) && 260 LINK_STATE_IS_UP(kif->link_state); 261 262 LIST_FOREACH(iface, &oeconf->iface_list, entry) { 263 if (kif->ifindex == iface->ifindex) { 264 iface->flags = kif->flags; 265 iface->linkstate = kif->link_state; 266 267 if (link_ok) { 268 if_fsm(iface, IF_EVT_UP); 269 log_warnx("interface %s up", 270 iface->name); 271 } else { 272 if_fsm(iface, IF_EVT_DOWN); 273 log_warnx("interface %s down", 274 iface->name); 275 } 276 } 277 } 278 break; 279 case IMSG_CTL_IFINFO: 280 case IMSG_CTL_KROUTE: 281 case IMSG_CTL_KROUTE_ADDR: 282 case IMSG_CTL_END: 283 control_imsg_relay(&imsg); 284 break; 285 default: 286 log_debug("ripe_dispatch_main: error handling imsg %d", 287 imsg.hdr.type); 288 break; 289 } 290 imsg_free(&imsg); 291 } 292 if (!shut) 293 imsg_event_add(iev); 294 else { 295 /* this pipe is dead, so remove the event handler */ 296 event_del(&iev->ev); 297 event_loopexit(NULL); 298 } 299 } 300 301 /* ARGSUSED */ 302 void 303 ripe_dispatch_rde(int fd, short event, void *bula) 304 { 305 struct rip_route *rr; 306 struct imsg imsg; 307 struct imsgev *iev = bula; 308 struct imsgbuf *ibuf = &iev->ibuf; 309 struct iface *iface; 310 struct nbr *nbr; 311 ssize_t n; 312 int shut = 0; 313 314 if (event & EV_READ) { 315 if ((n = imsg_read(ibuf)) == -1) 316 fatal("imsg_read error"); 317 if (n == 0) /* connection closed */ 318 shut = 1; 319 } 320 if (event & EV_WRITE) { 321 if (msgbuf_write(&ibuf->w) == -1) 322 fatal("msgbuf_write"); 323 } 324 325 for (;;) { 326 if ((n = imsg_get(ibuf, &imsg)) == -1) 327 fatal("ripe_dispatch_rde: imsg_read error"); 328 if (n == 0) 329 break; 330 331 switch (imsg.hdr.type) { 332 case IMSG_REQUEST_ADD: 333 if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(*rr)) 334 fatalx("invalid size of RDE request"); 335 336 if ((rr = malloc(sizeof(*rr))) == NULL) 337 fatal("ripe_dispatch_rde"); 338 339 memcpy(rr, imsg.data, sizeof(*rr)); 340 341 if (imsg.hdr.peerid != 0) { 342 if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) == 343 NULL) { 344 log_debug("unknown neighbor id %u", 345 imsg.hdr.peerid); 346 break; 347 } 348 add_entry(&nbr->rq_list, rr); 349 break; 350 } 351 352 LIST_FOREACH(iface, &oeconf->iface_list, entry) { 353 add_entry(&iface->rq_list, rr); 354 } 355 break; 356 case IMSG_SEND_REQUEST: 357 if (imsg.hdr.peerid != 0) { 358 if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) == 359 NULL) { 360 log_debug("unknown neighbor id %u", 361 imsg.hdr.peerid); 362 break; 363 } 364 send_request(&nbr->rq_list, NULL, nbr); 365 break; 366 } 367 368 LIST_FOREACH(iface, &oeconf->iface_list, entry) { 369 send_request(&iface->rq_list, iface, NULL); 370 } 371 break; 372 case IMSG_RESPONSE_ADD: 373 if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(*rr)) 374 fatalx("invalid size of RDE request"); 375 376 if ((rr = malloc(sizeof(*rr))) == NULL) 377 fatal("ripe_dispatch_rde"); 378 379 memcpy(rr, imsg.data, sizeof(*rr)); 380 381 if (imsg.hdr.peerid == 0) { 382 LIST_FOREACH(iface, &oeconf->iface_list, entry) 383 add_entry(&iface->rp_list, rr); 384 385 break; 386 } 387 388 if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) == NULL) { 389 log_debug("unknown neighbor id %u", 390 imsg.hdr.peerid); 391 break; 392 } 393 iface = nbr->iface; 394 add_entry(&nbr->rp_list, rr); 395 396 break; 397 case IMSG_SEND_RESPONSE: 398 if (imsg.hdr.peerid == 0) { 399 LIST_FOREACH(iface, &oeconf->iface_list, 400 entry) { 401 send_response(&iface->rp_list, 402 iface, NULL); 403 } 404 break; 405 } 406 407 if ((nbr = nbr_find_peerid(imsg.hdr.peerid)) == NULL) { 408 log_debug("unknown neighbor id %u", 409 imsg.hdr.peerid); 410 break; 411 } 412 send_response(&nbr->rp_list, NULL, nbr); 413 nbr_fsm(nbr, NBR_EVT_RESPONSE_SENT); 414 break; 415 case IMSG_SEND_TRIGGERED_UPDATE: 416 if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(struct 417 rip_route)) 418 fatalx("invalid size of RDE request"); 419 420 rr = imsg.data; 421 422 LIST_FOREACH(iface, &oeconf->iface_list, 423 entry) { 424 if (rr->ifindex != iface->ifindex) 425 send_triggered_update(iface, rr); 426 } 427 break; 428 case IMSG_CTL_END: 429 case IMSG_CTL_SHOW_RIB: 430 control_imsg_relay(&imsg); 431 break; 432 default: 433 log_debug("ripe_dispatch_rde: error handling imsg %d", 434 imsg.hdr.type); 435 break; 436 } 437 imsg_free(&imsg); 438 } 439 if (!shut) 440 imsg_event_add(iev); 441 else { 442 /* this pipe is dead, so remove the event handler */ 443 event_del(&iev->ev); 444 event_loopexit(NULL); 445 } 446 } 447 448 void 449 ripe_shutdown(void) 450 { 451 struct iface *iface; 452 453 LIST_FOREACH(iface, &oeconf->iface_list, entry) { 454 if (if_fsm(iface, IF_EVT_DOWN)) { 455 log_debug("error stopping interface %s", 456 iface->name); 457 } 458 } 459 while ((iface = LIST_FIRST(&oeconf->iface_list)) != NULL) { 460 LIST_REMOVE(iface, entry); 461 if_del(iface); 462 } 463 464 close(oeconf->rip_socket); 465 466 /* clean up */ 467 msgbuf_write(&iev_rde->ibuf.w); 468 msgbuf_clear(&iev_rde->ibuf.w); 469 free(iev_rde); 470 msgbuf_write(&iev_main->ibuf.w); 471 msgbuf_clear(&iev_main->ibuf.w); 472 free(iev_main); 473 free(oeconf); 474 free(pkt_ptr); 475 476 log_info("rip engine exiting"); 477 _exit(0); 478 } 479 480 void 481 ripe_iface_ctl(struct ctl_conn *c, unsigned int idx) 482 { 483 struct iface *iface; 484 struct ctl_iface *ictl; 485 486 LIST_FOREACH(iface, &oeconf->iface_list, entry) { 487 if (idx == 0 || idx == iface->ifindex) { 488 ictl = if_to_ctl(iface); 489 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_IFACE, 490 0, 0, -1, ictl, sizeof(struct ctl_iface)); 491 } 492 } 493 } 494 495 void 496 ripe_nbr_ctl(struct ctl_conn *c) 497 { 498 struct iface *iface; 499 struct nbr *nbr; 500 struct ctl_nbr *nctl; 501 502 LIST_FOREACH(iface, &oeconf->iface_list, entry) 503 LIST_FOREACH(nbr, &iface->nbr_list, entry) { 504 nctl = nbr_to_ctl(nbr); 505 imsg_compose_event(&c->iev, 506 IMSG_CTL_SHOW_NBR, 0, 0, -1, nctl, 507 sizeof(struct ctl_nbr)); 508 } 509 510 imsg_compose_event(&c->iev, IMSG_CTL_END, 0, 0, -1, NULL, 0); 511 } 512 513 void 514 ripe_demote_iface(struct iface *iface, int active) 515 { 516 struct demote_msg dmsg; 517 518 if (ripd_process != PROC_RIP_ENGINE || 519 iface->demote_group[0] == '\0') 520 return; 521 522 bzero(&dmsg, sizeof(dmsg)); 523 strlcpy(dmsg.demote_group, iface->demote_group, 524 sizeof(dmsg.demote_group)); 525 if (active) 526 dmsg.level = -1; 527 else 528 dmsg.level = 1; 529 530 ripe_imsg_compose_parent(IMSG_DEMOTE, 0, &dmsg, sizeof(dmsg)); 531 } 532