1 /* $OpenBSD: eigrpe.c,v 1.37 2021/01/19 10:31:12 claudio Exp $ */ 2 3 /* 4 * Copyright (c) 2015 Renato Westphal <renato@openbsd.org> 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 <netinet/in.h> 24 #include <netinet/ip.h> 25 26 #include <arpa/inet.h> 27 #include <errno.h> 28 #include <pwd.h> 29 #include <signal.h> 30 #include <stdlib.h> 31 #include <string.h> 32 #include <unistd.h> 33 34 #include "eigrpd.h" 35 #include "eigrpe.h" 36 #include "rde.h" 37 #include "log.h" 38 #include "control.h" 39 40 static void eigrpe_sig_handler(int, short, void *); 41 static __dead void eigrpe_shutdown(void); 42 static void eigrpe_dispatch_main(int, short, void *); 43 static void eigrpe_dispatch_rde(int, short, void *); 44 45 struct eigrpd_conf *econf; 46 47 static struct event ev4; 48 static struct event ev6; 49 static struct imsgev *iev_main; 50 static struct imsgev *iev_rde; 51 52 /* ARGSUSED */ 53 static void 54 eigrpe_sig_handler(int sig, short event, void *bula) 55 { 56 switch (sig) { 57 case SIGINT: 58 case SIGTERM: 59 eigrpe_shutdown(); 60 /* NOTREACHED */ 61 default: 62 fatalx("unexpected signal"); 63 } 64 } 65 66 /* eigrp engine */ 67 void 68 eigrpe(int debug, int verbose, char *sockname) 69 { 70 struct passwd *pw; 71 struct event ev_sigint, ev_sigterm; 72 73 econf = config_new_empty(); 74 75 log_init(debug); 76 log_verbose(verbose); 77 78 /* create eigrpd control socket outside chroot */ 79 if (control_init(sockname) == -1) 80 fatalx("control socket setup failed"); 81 82 if (inet_pton(AF_INET, AllEIGRPRouters_v4, &global.mcast_addr_v4) != 1) 83 fatal("inet_pton"); 84 if (inet_pton(AF_INET6, AllEIGRPRouters_v6, &global.mcast_addr_v6) != 1) 85 fatal("inet_pton"); 86 87 /* create the raw ipv4 socket */ 88 if ((global.eigrp_socket_v4 = socket(AF_INET, 89 SOCK_RAW | SOCK_CLOEXEC | SOCK_NONBLOCK, IPPROTO_EIGRP)) == -1) 90 fatal("error creating raw ipv4 socket"); 91 92 /* set some defaults */ 93 if (if_set_ipv4_mcast_ttl(global.eigrp_socket_v4, EIGRP_IP_TTL) == -1) 94 fatal("if_set_ipv4_mcast_ttl"); 95 if (if_set_ipv4_mcast_loop(global.eigrp_socket_v4) == -1) 96 fatal("if_set_ipv4_mcast_loop"); 97 if (if_set_ipv4_recvif(global.eigrp_socket_v4, 1) == -1) 98 fatal("if_set_ipv4_recvif"); 99 if (if_set_ipv4_hdrincl(global.eigrp_socket_v4) == -1) 100 fatal("if_set_ipv4_hdrincl"); 101 if_set_sockbuf(global.eigrp_socket_v4); 102 103 /* create the raw ipv6 socket */ 104 if ((global.eigrp_socket_v6 = socket(AF_INET6, 105 SOCK_RAW | SOCK_CLOEXEC | SOCK_NONBLOCK, IPPROTO_EIGRP)) == -1) 106 fatal("error creating raw ipv6 socket"); 107 108 /* set some defaults */ 109 if (if_set_ipv6_mcast_loop(global.eigrp_socket_v6) == -1) 110 fatal("if_set_ipv6_mcast_loop"); 111 if (if_set_ipv6_pktinfo(global.eigrp_socket_v6, 1) == -1) 112 fatal("if_set_ipv6_pktinfo"); 113 if (if_set_ipv6_dscp(global.eigrp_socket_v6, 114 IPTOS_PREC_NETCONTROL) == -1) 115 fatal("if_set_ipv6_dscp"); 116 if_set_sockbuf(global.eigrp_socket_v6); 117 118 if ((pw = getpwnam(EIGRPD_USER)) == NULL) 119 fatal("getpwnam"); 120 121 if (chroot(pw->pw_dir) == -1) 122 fatal("chroot"); 123 if (chdir("/") == -1) 124 fatal("chdir(\"/\")"); 125 126 setproctitle("eigrp engine"); 127 eigrpd_process = PROC_EIGRP_ENGINE; 128 log_procname = log_procnames[eigrpd_process]; 129 130 if (setgroups(1, &pw->pw_gid) || 131 setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) || 132 setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid)) 133 fatal("can't drop privileges"); 134 135 if (pledge("stdio inet mcast recvfd", NULL) == -1) 136 fatal("pledge"); 137 138 event_init(); 139 140 /* setup signal handler */ 141 signal_set(&ev_sigint, SIGINT, eigrpe_sig_handler, NULL); 142 signal_set(&ev_sigterm, SIGTERM, eigrpe_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 pipe and event handler to the parent process */ 149 if ((iev_main = malloc(sizeof(struct imsgev))) == NULL) 150 fatal(NULL); 151 imsg_init(&iev_main->ibuf, 3); 152 iev_main->handler = eigrpe_dispatch_main; 153 iev_main->events = EV_READ; 154 event_set(&iev_main->ev, iev_main->ibuf.fd, iev_main->events, 155 iev_main->handler, iev_main); 156 event_add(&iev_main->ev, NULL); 157 158 event_set(&ev4, global.eigrp_socket_v4, EV_READ|EV_PERSIST, 159 recv_packet, econf); 160 event_add(&ev4, NULL); 161 162 event_set(&ev6, global.eigrp_socket_v6, EV_READ|EV_PERSIST, 163 recv_packet, econf); 164 event_add(&ev6, NULL); 165 166 /* listen on eigrpd control socket */ 167 TAILQ_INIT(&ctl_conns); 168 control_listen(); 169 170 event_dispatch(); 171 172 eigrpe_shutdown(); 173 } 174 175 static __dead void 176 eigrpe_shutdown(void) 177 { 178 /* close pipes */ 179 msgbuf_write(&iev_rde->ibuf.w); 180 msgbuf_clear(&iev_rde->ibuf.w); 181 close(iev_rde->ibuf.fd); 182 msgbuf_write(&iev_main->ibuf.w); 183 msgbuf_clear(&iev_main->ibuf.w); 184 close(iev_main->ibuf.fd); 185 186 config_clear(econf); 187 188 event_del(&ev4); 189 event_del(&ev6); 190 close(global.eigrp_socket_v4); 191 close(global.eigrp_socket_v6); 192 193 /* clean up */ 194 free(iev_rde); 195 free(iev_main); 196 197 log_info("eigrp engine exiting"); 198 exit(0); 199 } 200 201 /* imesg */ 202 int 203 eigrpe_imsg_compose_parent(int type, pid_t pid, void *data, uint16_t datalen) 204 { 205 return (imsg_compose_event(iev_main, type, 0, pid, -1, data, datalen)); 206 } 207 208 int 209 eigrpe_imsg_compose_rde(int type, uint32_t peerid, pid_t pid, 210 void *data, uint16_t datalen) 211 { 212 return (imsg_compose_event(iev_rde, type, peerid, pid, -1, 213 data, datalen)); 214 } 215 216 /* ARGSUSED */ 217 static void 218 eigrpe_dispatch_main(int fd, short event, void *bula) 219 { 220 static struct eigrpd_conf *nconf; 221 static struct iface *niface; 222 static struct eigrp *neigrp; 223 struct eigrp_iface *nei; 224 struct imsg imsg; 225 struct imsgev *iev = bula; 226 struct imsgbuf *ibuf = &iev->ibuf; 227 struct iface *iface = NULL; 228 struct kif *kif; 229 struct kaddr *ka; 230 int n, shut = 0; 231 232 if (event & EV_READ) { 233 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN) 234 fatal("imsg_read error"); 235 if (n == 0) /* connection closed */ 236 shut = 1; 237 } 238 if (event & EV_WRITE) { 239 if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN) 240 fatal("msgbuf_write"); 241 if (n == 0) /* connection closed */ 242 shut = 1; 243 } 244 245 for (;;) { 246 if ((n = imsg_get(ibuf, &imsg)) == -1) 247 fatal("eigrpe_dispatch_main: imsg_get error"); 248 if (n == 0) 249 break; 250 251 switch (imsg.hdr.type) { 252 case IMSG_IFINFO: 253 if (imsg.hdr.len != IMSG_HEADER_SIZE + 254 sizeof(struct kif)) 255 fatalx("IFSTATUS imsg with wrong len"); 256 kif = imsg.data; 257 258 iface = if_lookup(econf, kif->ifindex); 259 if (!iface) 260 break; 261 262 iface->flags = kif->flags; 263 iface->linkstate = kif->link_state; 264 if_update(iface, AF_UNSPEC); 265 break; 266 case IMSG_NEWADDR: 267 if (imsg.hdr.len != IMSG_HEADER_SIZE + 268 sizeof(struct kaddr)) 269 fatalx("NEWADDR imsg with wrong len"); 270 ka = imsg.data; 271 272 iface = if_lookup(econf, ka->ifindex); 273 if (iface == NULL) 274 break; 275 276 if_addr_new(iface, ka); 277 break; 278 case IMSG_DELADDR: 279 if (imsg.hdr.len != IMSG_HEADER_SIZE + 280 sizeof(struct kaddr)) 281 fatalx("DELADDR imsg with wrong len"); 282 ka = imsg.data; 283 284 iface = if_lookup(econf, ka->ifindex); 285 if (iface == NULL) 286 break; 287 288 if_addr_del(iface, ka); 289 break; 290 case IMSG_SOCKET_IPC: 291 if (iev_rde) { 292 log_warnx("%s: received unexpected imsg fd " 293 "to rde", __func__); 294 break; 295 } 296 if ((fd = imsg.fd) == -1) { 297 log_warnx("%s: expected to receive imsg fd to " 298 "rde but didn't receive any", __func__); 299 break; 300 } 301 302 iev_rde = malloc(sizeof(struct imsgev)); 303 if (iev_rde == NULL) 304 fatal(NULL); 305 imsg_init(&iev_rde->ibuf, fd); 306 iev_rde->handler = eigrpe_dispatch_rde; 307 iev_rde->events = EV_READ; 308 event_set(&iev_rde->ev, iev_rde->ibuf.fd, 309 iev_rde->events, iev_rde->handler, iev_rde); 310 event_add(&iev_rde->ev, NULL); 311 break; 312 case IMSG_RECONF_CONF: 313 if ((nconf = malloc(sizeof(struct eigrpd_conf))) == 314 NULL) 315 fatal(NULL); 316 memcpy(nconf, imsg.data, sizeof(struct eigrpd_conf)); 317 318 TAILQ_INIT(&nconf->iface_list); 319 TAILQ_INIT(&nconf->instances); 320 break; 321 case IMSG_RECONF_INSTANCE: 322 if ((neigrp = malloc(sizeof(struct eigrp))) == NULL) 323 fatal(NULL); 324 memcpy(neigrp, imsg.data, sizeof(struct eigrp)); 325 326 SIMPLEQ_INIT(&neigrp->redist_list); 327 TAILQ_INIT(&neigrp->ei_list); 328 RB_INIT(&neigrp->nbrs); 329 RB_INIT(&neigrp->topology); 330 TAILQ_INSERT_TAIL(&nconf->instances, neigrp, entry); 331 break; 332 case IMSG_RECONF_IFACE: 333 niface = imsg.data; 334 niface = if_lookup(nconf, niface->ifindex); 335 if (niface) 336 break; 337 338 if ((niface = malloc(sizeof(struct iface))) == NULL) 339 fatal(NULL); 340 memcpy(niface, imsg.data, sizeof(struct iface)); 341 342 TAILQ_INIT(&niface->ei_list); 343 TAILQ_INIT(&niface->addr_list); 344 TAILQ_INSERT_TAIL(&nconf->iface_list, niface, entry); 345 break; 346 case IMSG_RECONF_EIGRP_IFACE: 347 if (niface == NULL) 348 break; 349 if ((nei = malloc(sizeof(struct eigrp_iface))) == NULL) 350 fatal(NULL); 351 memcpy(nei, imsg.data, sizeof(struct eigrp_iface)); 352 353 nei->iface = niface; 354 nei->eigrp = neigrp; 355 TAILQ_INIT(&nei->nbr_list); 356 TAILQ_INIT(&nei->update_list); 357 TAILQ_INIT(&nei->query_list); 358 TAILQ_INIT(&nei->summary_list); 359 TAILQ_INSERT_TAIL(&niface->ei_list, nei, i_entry); 360 TAILQ_INSERT_TAIL(&neigrp->ei_list, nei, e_entry); 361 if (RB_INSERT(iface_id_head, &ifaces_by_id, nei) != 362 NULL) 363 fatalx("eigrpe_dispatch_main: " 364 "RB_INSERT(ifaces_by_id) failed"); 365 break; 366 case IMSG_RECONF_END: 367 merge_config(econf, nconf); 368 nconf = NULL; 369 break; 370 case IMSG_CTL_KROUTE: 371 case IMSG_CTL_IFINFO: 372 case IMSG_CTL_END: 373 control_imsg_relay(&imsg); 374 break; 375 default: 376 log_debug("%s: error handling imsg %d", __func__, 377 imsg.hdr.type); 378 break; 379 } 380 imsg_free(&imsg); 381 } 382 if (!shut) 383 imsg_event_add(iev); 384 else { 385 /* this pipe is dead, so remove the event handler */ 386 event_del(&iev->ev); 387 event_loopexit(NULL); 388 } 389 } 390 391 /* ARGSUSED */ 392 static void 393 eigrpe_dispatch_rde(int fd, short event, void *bula) 394 { 395 struct imsgev *iev = bula; 396 struct imsgbuf *ibuf = &iev->ibuf; 397 struct imsg imsg; 398 struct nbr *nbr; 399 struct eigrp_iface *ei; 400 struct rinfo rinfo; 401 int n, shut = 0; 402 403 if (event & EV_READ) { 404 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN) 405 fatal("imsg_read error"); 406 if (n == 0) /* connection closed */ 407 shut = 1; 408 } 409 if (event & EV_WRITE) { 410 if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN) 411 fatal("msgbuf_write"); 412 if (n == 0) /* connection closed */ 413 shut = 1; 414 } 415 416 for (;;) { 417 if ((n = imsg_get(ibuf, &imsg)) == -1) 418 fatal("eigrpe_dispatch_rde: imsg_get error"); 419 if (n == 0) 420 break; 421 422 switch (imsg.hdr.type) { 423 case IMSG_SEND_UPDATE: 424 case IMSG_SEND_QUERY: 425 case IMSG_SEND_REPLY: 426 if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(rinfo)) 427 fatalx("invalid size of rinfo"); 428 memcpy(&rinfo, imsg.data, sizeof(rinfo)); 429 430 nbr = nbr_find_peerid(imsg.hdr.peerid); 431 if (nbr == NULL) { 432 log_debug("%s: cannot find rde neighbor", 433 __func__); 434 break; 435 } 436 437 switch (imsg.hdr.type) { 438 case IMSG_SEND_UPDATE: 439 message_add(&nbr->update_list, &rinfo); 440 break; 441 case IMSG_SEND_QUERY: 442 message_add(&nbr->query_list, &rinfo); 443 break; 444 case IMSG_SEND_REPLY: 445 message_add(&nbr->reply_list, &rinfo); 446 break; 447 } 448 break; 449 case IMSG_SEND_MUPDATE: 450 case IMSG_SEND_MQUERY: 451 if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(rinfo)) 452 fatalx("invalid size of rinfo"); 453 memcpy(&rinfo, imsg.data, sizeof(rinfo)); 454 455 ei = eigrp_if_lookup_id(imsg.hdr.peerid); 456 if (ei == NULL) { 457 log_debug("%s: cannot find interface", 458 __func__); 459 break; 460 } 461 462 switch (imsg.hdr.type) { 463 case IMSG_SEND_MUPDATE: 464 message_add(&ei->update_list, &rinfo); 465 break; 466 case IMSG_SEND_MQUERY: 467 message_add(&ei->query_list, &rinfo); 468 break; 469 } 470 break; 471 case IMSG_SEND_UPDATE_END: 472 case IMSG_SEND_REPLY_END: 473 case IMSG_SEND_SIAQUERY_END: 474 case IMSG_SEND_SIAREPLY_END: 475 nbr = nbr_find_peerid(imsg.hdr.peerid); 476 if (nbr == NULL) { 477 log_debug("%s: cannot find rde neighbor", 478 __func__); 479 break; 480 } 481 482 switch (imsg.hdr.type) { 483 case IMSG_SEND_UPDATE_END: 484 send_update(nbr->ei, nbr, 0, &nbr->update_list); 485 message_list_clr(&nbr->update_list); 486 break; 487 case IMSG_SEND_REPLY_END: 488 send_reply(nbr, &nbr->reply_list, 0); 489 message_list_clr(&nbr->reply_list); 490 break; 491 case IMSG_SEND_SIAQUERY_END: 492 send_query(nbr->ei, nbr, &nbr->query_list, 1); 493 message_list_clr(&nbr->query_list); 494 break; 495 case IMSG_SEND_SIAREPLY_END: 496 send_reply(nbr, &nbr->reply_list, 1); 497 message_list_clr(&nbr->reply_list); 498 break; 499 } 500 break; 501 case IMSG_SEND_MUPDATE_END: 502 case IMSG_SEND_MQUERY_END: 503 ei = eigrp_if_lookup_id(imsg.hdr.peerid); 504 if (ei == NULL) { 505 log_debug("%s: cannot find interface", 506 __func__); 507 break; 508 } 509 510 switch (imsg.hdr.type) { 511 case IMSG_SEND_MUPDATE_END: 512 send_update(ei, NULL, 0, &ei->update_list); 513 message_list_clr(&ei->update_list); 514 break; 515 case IMSG_SEND_MQUERY_END: 516 send_query(ei, NULL, &ei->query_list, 0); 517 message_list_clr(&ei->query_list); 518 break; 519 } 520 break; 521 case IMSG_NEIGHBOR_DOWN: 522 nbr = nbr_find_peerid(imsg.hdr.peerid); 523 if (nbr == NULL) { 524 log_debug("%s: cannot find rde neighbor", 525 __func__); 526 break; 527 } 528 /* announce that this neighborship is dead */ 529 send_peerterm(nbr); 530 nbr_del(nbr); 531 break; 532 case IMSG_CTL_SHOW_TOPOLOGY: 533 case IMSG_CTL_END: 534 control_imsg_relay(&imsg); 535 break; 536 default: 537 log_debug("%s: error handling imsg %d", __func__, 538 imsg.hdr.type); 539 break; 540 } 541 imsg_free(&imsg); 542 } 543 if (!shut) 544 imsg_event_add(iev); 545 else { 546 /* this pipe is dead, so remove the event handler */ 547 event_del(&iev->ev); 548 event_loopexit(NULL); 549 } 550 } 551 552 void 553 eigrpe_instance_init(struct eigrp *eigrp) 554 { 555 } 556 557 void 558 eigrpe_instance_del(struct eigrp *eigrp) 559 { 560 struct eigrp_iface *ei; 561 562 while ((ei = TAILQ_FIRST(&eigrp->ei_list)) != NULL) 563 eigrp_if_del(ei); 564 565 free(eigrp); 566 } 567 568 void 569 message_add(struct rinfo_head *rinfo_list, struct rinfo *rinfo) 570 { 571 struct rinfo_entry *re; 572 573 re = calloc(1, sizeof(*re)); 574 if (re == NULL) 575 fatal("message_add"); 576 re->rinfo = *rinfo; 577 578 TAILQ_INSERT_TAIL(rinfo_list, re, entry); 579 } 580 581 void 582 message_list_clr(struct rinfo_head *rinfo_list) 583 { 584 struct rinfo_entry *re; 585 586 while ((re = TAILQ_FIRST(rinfo_list)) != NULL) { 587 TAILQ_REMOVE(rinfo_list, re, entry); 588 free(re); 589 } 590 } 591 592 void 593 seq_addr_list_clr(struct seq_addr_head *seq_addr_list) 594 { 595 struct seq_addr_entry *sa; 596 597 while ((sa = TAILQ_FIRST(seq_addr_list)) != NULL) { 598 TAILQ_REMOVE(seq_addr_list, sa, entry); 599 free(sa); 600 } 601 } 602 603 void 604 eigrpe_orig_local_route(struct eigrp_iface *ei, struct if_addr *if_addr, 605 int withdraw) 606 { 607 struct rinfo rinfo; 608 609 memset(&rinfo, 0, sizeof(rinfo)); 610 rinfo.af = if_addr->af; 611 rinfo.type = EIGRP_ROUTE_INTERNAL; 612 rinfo.prefix = if_addr->addr; 613 rinfo.prefixlen = if_addr->prefixlen; 614 615 eigrp_applymask(rinfo.af, &rinfo.prefix, &rinfo.prefix, 616 rinfo.prefixlen); 617 618 if (withdraw) 619 rinfo.metric.delay = EIGRP_INFINITE_METRIC; 620 else 621 rinfo.metric.delay = eigrp_composite_delay(ei->delay); 622 rinfo.metric.bandwidth = eigrp_composite_bandwidth(ei->bandwidth); 623 metric_encode_mtu(rinfo.metric.mtu, ei->iface->mtu); 624 rinfo.metric.hop_count = 0; 625 rinfo.metric.reliability = DEFAULT_RELIABILITY; 626 rinfo.metric.load = DEFAULT_LOAD; 627 rinfo.metric.tag = 0; 628 rinfo.metric.flags = 0; 629 630 eigrpe_imsg_compose_rde(IMSG_RECV_UPDATE, ei->self->peerid, 0, 631 &rinfo, sizeof(rinfo)); 632 } 633 634 void 635 eigrpe_iface_ctl(struct ctl_conn *c, unsigned int idx) 636 { 637 struct eigrp *eigrp; 638 struct eigrp_iface *ei; 639 struct ctl_iface *ictl; 640 641 TAILQ_FOREACH(eigrp, &econf->instances, entry) { 642 TAILQ_FOREACH(ei, &eigrp->ei_list, e_entry) { 643 if (idx == 0 || idx == ei->iface->ifindex) { 644 ictl = if_to_ctl(ei); 645 imsg_compose_event(&c->iev, 646 IMSG_CTL_SHOW_INTERFACE, 0, 0, -1, 647 ictl, sizeof(struct ctl_iface)); 648 } 649 } 650 } 651 } 652 653 void 654 eigrpe_nbr_ctl(struct ctl_conn *c) 655 { 656 struct eigrp *eigrp; 657 struct nbr *nbr; 658 struct ctl_nbr *nctl; 659 660 TAILQ_FOREACH(eigrp, &econf->instances, entry) { 661 RB_FOREACH(nbr, nbr_addr_head, &eigrp->nbrs) { 662 if (nbr->flags & (F_EIGRP_NBR_PENDING|F_EIGRP_NBR_SELF)) 663 continue; 664 665 nctl = nbr_to_ctl(nbr); 666 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_NBR, 0, 667 0, -1, nctl, sizeof(struct ctl_nbr)); 668 } 669 } 670 671 imsg_compose_event(&c->iev, IMSG_CTL_END, 0, 0, -1, NULL, 0); 672 } 673 674 void 675 eigrpe_stats_ctl(struct ctl_conn *c) 676 { 677 struct eigrp *eigrp; 678 struct ctl_stats sctl; 679 680 TAILQ_FOREACH(eigrp, &econf->instances, entry) { 681 sctl.af = eigrp->af; 682 sctl.as = eigrp->as; 683 sctl.stats = eigrp->stats; 684 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_STATS, 0, 685 0, -1, &sctl, sizeof(struct ctl_stats)); 686 } 687 688 imsg_compose_event(&c->iev, IMSG_CTL_END, 0, 0, -1, NULL, 0); 689 } 690