]> git.proxmox.com Git - mirror_frr.git/blob - ldpd/ldpe.c
projects / mirror_frr.git / blob
? search:


7dcc8fbe16dcf5db03c7a6ec2474b0db8cc376ef
[mirror_frr.git] / ldpd / ldpe.c
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2013, 2016 Renato Westphal <renato@openbsd.org>
5 * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
6 * Copyright (c) 2004, 2008 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 <zebra.h>
23
24 #include "ldpd.h"
25 #include "ldpe.h"
26 #include "lde.h"
27 #include "control.h"
28 #include "log.h"
29 #include "ldp_debug.h"
30
31 #include <lib/log.h>
32 #include "memory.h"
33 #include "privs.h"
34 #include "sigevent.h"
35
36 static void ldpe_shutdown(void);
37 static int ldpe_dispatch_main(struct thread *);
38 static int ldpe_dispatch_lde(struct thread *);
39 #ifdef __OpenBSD__
40 static int ldpe_dispatch_pfkey(struct thread *);
41 #endif
42 static void ldpe_setup_sockets(int, int, int, int);
43 static void ldpe_close_sockets(int);
44 static void ldpe_iface_af_ctl(struct ctl_conn *, int, unsigned int);
45
46 struct ldpd_conf *leconf;
47 #ifdef __OpenBSD__
48 struct ldpd_sysdep sysdep;
49 #endif
50
51 static struct imsgev *iev_main, *iev_main_sync;
52 static struct imsgev *iev_lde;
53 #ifdef __OpenBSD__
54 static struct thread *pfkey_ev;
55 #endif
56
57 /* Master of threads. */
58 struct thread_master *master;
59
60 /* ldpe privileges */
61 static zebra_capabilities_t _caps_p [] =
62 {
63 ZCAP_BIND,
64 ZCAP_NET_ADMIN
65 };
66
67 struct zebra_privs_t ldpe_privs =
68 {
69 #if defined(FRR_USER) && defined(FRR_GROUP)
70 .user = FRR_USER,
71 .group = FRR_GROUP,
72 #endif
73 #if defined(VTY_GROUP)
74 .vty_group = VTY_GROUP,
75 #endif
76 .caps_p = _caps_p,
77 .cap_num_p = array_size(_caps_p),
78 .cap_num_i = 0
79 };
80
81 /* SIGINT / SIGTERM handler. */
82 static void
83 sigint(void)
84 {
85 ldpe_shutdown();
86 }
87
88 static struct quagga_signal_t ldpe_signals[] =
89 {
90 {
91 .signal = SIGINT,
92 .handler = &sigint,
93 },
94 {
95 .signal = SIGTERM,
96 .handler = &sigint,
97 },
98 };
99
100 /* label distribution protocol engine */
101 void
102 ldpe(const char *user, const char *group, const char *ctl_path)
103 {
104 struct thread thread;
105
106 leconf = config_new_empty();
107
108 #ifdef HAVE_SETPROCTITLE
109 setproctitle("ldp engine");
110 #endif
111 ldpd_process = PROC_LDP_ENGINE;
112
113 LIST_INIT(&global.addr_list);
114 RB_INIT(&global.adj_tree);
115 TAILQ_INIT(&global.pending_conns);
116 if (inet_pton(AF_INET, AllRouters_v4, &global.mcast_addr_v4) != 1)
117 fatal("inet_pton");
118 if (inet_pton(AF_INET6, AllRouters_v6, &global.mcast_addr_v6) != 1)
119 fatal("inet_pton");
120 #ifdef __OpenBSD__
121 global.pfkeysock = pfkey_init();
122 #endif
123
124 /* drop privileges */
125 if (user)
126 ldpe_privs.user = user;
127 if (group)
128 ldpe_privs.group = group;
129 zprivs_init(&ldpe_privs);
130
131 strlcpy(ctl_sock_path, ctl_path, sizeof(ctl_sock_path));
132 if (control_init() == -1)
133 fatalx("control socket setup failed");
134
135 #ifdef HAVE_PLEDGE
136 if (pledge("stdio cpath inet mcast recvfd", NULL) == -1)
137 fatal("pledge");
138 #endif
139
140 master = thread_master_create();
141 accept_init();
142
143 /* setup signal handler */
144 signal_init(master, array_size(ldpe_signals), ldpe_signals);
145
146 /* setup pipes and event handlers to the parent process */
147 if ((iev_main = calloc(1, sizeof(struct imsgev))) == NULL)
148 fatal(NULL);
149 imsg_init(&iev_main->ibuf, LDPD_FD_ASYNC);
150 iev_main->handler_read = ldpe_dispatch_main;
151 iev_main->ev_read = thread_add_read(master, iev_main->handler_read,
152 iev_main, iev_main->ibuf.fd);
153 iev_main->handler_write = ldp_write_handler;
154
155 if ((iev_main_sync = calloc(1, sizeof(struct imsgev))) == NULL)
156 fatal(NULL);
157 imsg_init(&iev_main_sync->ibuf, LDPD_FD_SYNC);
158
159 #ifdef __OpenBSD__
160 if (sysdep.no_pfkey == 0)
161 pfkey_ev = thread_add_read(master, ldpe_dispatch_pfkey,
162 NULL, global.pfkeysock);
163 #endif
164
165 /* mark sockets as closed */
166 global.ipv4.ldp_disc_socket = -1;
167 global.ipv4.ldp_edisc_socket = -1;
168 global.ipv4.ldp_session_socket = -1;
169 global.ipv6.ldp_disc_socket = -1;
170 global.ipv6.ldp_edisc_socket = -1;
171 global.ipv6.ldp_session_socket = -1;
172
173 /* listen on ldpd control socket */
174 TAILQ_INIT(&ctl_conns);
175 control_listen();
176
177 if ((pkt_ptr = calloc(1, IBUF_READ_SIZE)) == NULL)
178 fatal(__func__);
179
180 /* Fetch next active thread. */
181 while (thread_fetch(master, &thread))
182 thread_call(&thread);
183 }
184
185 static void
186 ldpe_shutdown(void)
187 {
188 struct if_addr *if_addr;
189 struct adj *adj;
190
191 /* close pipes */
192 msgbuf_write(&iev_lde->ibuf.w);
193 msgbuf_clear(&iev_lde->ibuf.w);
194 close(iev_lde->ibuf.fd);
195 msgbuf_write(&iev_main->ibuf.w);
196 msgbuf_clear(&iev_main->ibuf.w);
197 close(iev_main->ibuf.fd);
198 msgbuf_clear(&iev_main_sync->ibuf.w);
199 close(iev_main_sync->ibuf.fd);
200
201 control_cleanup();
202 config_clear(leconf);
203
204 #ifdef __OpenBSD__
205 if (sysdep.no_pfkey == 0) {
206 THREAD_READ_OFF(pfkey_ev);
207 close(global.pfkeysock);
208 }
209 #endif
210 ldpe_close_sockets(AF_INET);
211 ldpe_close_sockets(AF_INET6);
212
213 /* remove addresses from global list */
214 while ((if_addr = LIST_FIRST(&global.addr_list)) != NULL) {
215 LIST_REMOVE(if_addr, entry);
216 free(if_addr);
217 }
218 while ((adj = RB_ROOT(&global.adj_tree)) != NULL)
219 adj_del(adj, S_SHUTDOWN);
220
221 /* clean up */
222 free(iev_lde);
223 free(iev_main);
224 free(iev_main_sync);
225 free(pkt_ptr);
226
227 log_info("ldp engine exiting");
228 exit(0);
229 }
230
231 /* imesg */
232 int
233 ldpe_imsg_compose_parent(int type, pid_t pid, void *data, uint16_t datalen)
234 {
235 return (imsg_compose_event(iev_main, type, 0, pid, -1, data, datalen));
236 }
237
238 int
239 ldpe_imsg_compose_lde(int type, uint32_t peerid, pid_t pid, void *data,
240 uint16_t datalen)
241 {
242 return (imsg_compose_event(iev_lde, type, peerid, pid, -1,
243 data, datalen));
244 }
245
246 /* ARGSUSED */
247 static int
248 ldpe_dispatch_main(struct thread *thread)
249 {
250 static struct ldpd_conf *nconf;
251 struct iface *niface;
252 struct tnbr *ntnbr;
253 struct nbr_params *nnbrp;
254 static struct l2vpn *nl2vpn;
255 struct l2vpn_if *nlif;
256 struct l2vpn_pw *npw;
257 struct imsg imsg;
258 int fd = THREAD_FD(thread);
259 struct imsgev *iev = THREAD_ARG(thread);
260 struct imsgbuf *ibuf = &iev->ibuf;
261 struct iface *iface = NULL;
262 struct kif *kif;
263 int af;
264 enum socket_type *socket_type;
265 static int disc_socket = -1;
266 static int edisc_socket = -1;
267 static int session_socket = -1;
268 struct nbr *nbr;
269 #ifdef __OpenBSD__
270 struct nbr_params *nbrp;
271 #endif
272 int n, shut = 0;
273
274 iev->ev_read = NULL;
275
276 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
277 fatal("imsg_read error");
278 if (n == 0) /* connection closed */
279 shut = 1;
280
281 for (;;) {
282 if ((n = imsg_get(ibuf, &imsg)) == -1)
283 fatal("ldpe_dispatch_main: imsg_get error");
284 if (n == 0)
285 break;
286
287 switch (imsg.hdr.type) {
288 case IMSG_IFSTATUS:
289 if (imsg.hdr.len != IMSG_HEADER_SIZE +
290 sizeof(struct kif))
291 fatalx("IFSTATUS imsg with wrong len");
292 kif = imsg.data;
293
294 iface = if_lookup_name(leconf, kif->ifname);
295 if (!iface)
296 break;
297
298 if_update_info(iface, kif);
299 if_update(iface, AF_UNSPEC);
300 break;
301 case IMSG_NEWADDR:
302 if (imsg.hdr.len != IMSG_HEADER_SIZE +
303 sizeof(struct kaddr))
304 fatalx("NEWADDR imsg with wrong len");
305
306 if_addr_add(imsg.data);
307 break;
308 case IMSG_DELADDR:
309 if (imsg.hdr.len != IMSG_HEADER_SIZE +
310 sizeof(struct kaddr))
311 fatalx("DELADDR imsg with wrong len");
312
313 if_addr_del(imsg.data);
314 break;
315 case IMSG_SOCKET_IPC:
316 if (iev_lde) {
317 log_warnx("%s: received unexpected imsg fd "
318 "to lde", __func__);
319 break;
320 }
321 if ((fd = imsg.fd) == -1) {
322 log_warnx("%s: expected to receive imsg fd to "
323 "lde but didn't receive any", __func__);
324 break;
325 }
326
327 if ((iev_lde = malloc(sizeof(struct imsgev))) == NULL)
328 fatal(NULL);
329 imsg_init(&iev_lde->ibuf, fd);
330 iev_lde->handler_read = ldpe_dispatch_lde;
331 iev_lde->ev_read = thread_add_read(master,
332 iev_lde->handler_read, iev_lde, iev_lde->ibuf.fd);
333 iev_lde->handler_write = ldp_write_handler;
334 iev_lde->ev_write = NULL;
335 break;
336 case IMSG_CLOSE_SOCKETS:
337 af = imsg.hdr.peerid;
338
339 RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) {
340 if (nbr->af != af)
341 continue;
342 session_shutdown(nbr, S_SHUTDOWN, 0, 0);
343 #ifdef __OpenBSD__
344 pfkey_remove(nbr);
345 #endif
346 }
347 ldpe_close_sockets(af);
348 if_update_all(af);
349 tnbr_update_all(af);
350
351 disc_socket = -1;
352 edisc_socket = -1;
353 session_socket = -1;
354 if ((ldp_af_conf_get(leconf, af))->flags &
355 F_LDPD_AF_ENABLED)
356 ldpe_imsg_compose_parent(IMSG_REQUEST_SOCKETS,
357 af, NULL, 0);
358 break;
359 case IMSG_SOCKET_NET:
360 if (imsg.hdr.len != IMSG_HEADER_SIZE +
361 sizeof(enum socket_type))
362 fatalx("SOCKET_NET imsg with wrong len");
363 socket_type = imsg.data;
364
365 switch (*socket_type) {
366 case LDP_SOCKET_DISC:
367 disc_socket = imsg.fd;
368 break;
369 case LDP_SOCKET_EDISC:
370 edisc_socket = imsg.fd;
371 break;
372 case LDP_SOCKET_SESSION:
373 session_socket = imsg.fd;
374 break;
375 }
376 break;
377 case IMSG_SETUP_SOCKETS:
378 af = imsg.hdr.peerid;
379 if (disc_socket == -1 || edisc_socket == -1 ||
380 session_socket == -1) {
381 if (disc_socket != -1)
382 close(disc_socket);
383 if (edisc_socket != -1)
384 close(edisc_socket);
385 if (session_socket != -1)
386 close(session_socket);
387 break;
388 }
389
390 ldpe_setup_sockets(af, disc_socket, edisc_socket,
391 session_socket);
392 if_update_all(af);
393 tnbr_update_all(af);
394 RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) {
395 if (nbr->af != af)
396 continue;
397 nbr->laddr = (ldp_af_conf_get(leconf,
398 af))->trans_addr;
399 #ifdef __OpenBSD__
400 nbrp = nbr_params_find(leconf, nbr->id);
401 if (nbrp && pfkey_establish(nbr, nbrp) == -1)
402 fatalx("pfkey setup failed");
403 #endif
404 if (nbr_session_active_role(nbr))
405 nbr_establish_connection(nbr);
406 }
407 break;
408 case IMSG_RTRID_UPDATE:
409 memcpy(&global.rtr_id, imsg.data,
410 sizeof(global.rtr_id));
411 if (leconf->rtr_id.s_addr == INADDR_ANY) {
412 ldpe_reset_nbrs(AF_UNSPEC);
413 }
414 if_update_all(AF_UNSPEC);
415 tnbr_update_all(AF_UNSPEC);
416 break;
417 case IMSG_RECONF_CONF:
418 if ((nconf = malloc(sizeof(struct ldpd_conf))) ==
419 NULL)
420 fatal(NULL);
421 memcpy(nconf, imsg.data, sizeof(struct ldpd_conf));
422
423 RB_INIT(&nconf->iface_tree);
424 RB_INIT(&nconf->tnbr_tree);
425 RB_INIT(&nconf->nbrp_tree);
426 RB_INIT(&nconf->l2vpn_tree);
427 break;
428 case IMSG_RECONF_IFACE:
429 if ((niface = malloc(sizeof(struct iface))) == NULL)
430 fatal(NULL);
431 memcpy(niface, imsg.data, sizeof(struct iface));
432
433 LIST_INIT(&niface->addr_list);
434 RB_INIT(&niface->ipv4.adj_tree);
435 RB_INIT(&niface->ipv6.adj_tree);
436 niface->ipv4.iface = niface;
437 niface->ipv6.iface = niface;
438
439 RB_INSERT(iface_head, &nconf->iface_tree, niface);
440 break;
441 case IMSG_RECONF_TNBR:
442 if ((ntnbr = malloc(sizeof(struct tnbr))) == NULL)
443 fatal(NULL);
444 memcpy(ntnbr, imsg.data, sizeof(struct tnbr));
445
446 RB_INSERT(tnbr_head, &nconf->tnbr_tree, ntnbr);
447 break;
448 case IMSG_RECONF_NBRP:
449 if ((nnbrp = malloc(sizeof(struct nbr_params))) == NULL)
450 fatal(NULL);
451 memcpy(nnbrp, imsg.data, sizeof(struct nbr_params));
452
453 RB_INSERT(nbrp_head, &nconf->nbrp_tree, nnbrp);
454 break;
455 case IMSG_RECONF_L2VPN:
456 if ((nl2vpn = malloc(sizeof(struct l2vpn))) == NULL)
457 fatal(NULL);
458 memcpy(nl2vpn, imsg.data, sizeof(struct l2vpn));
459
460 RB_INIT(&nl2vpn->if_tree);
461 RB_INIT(&nl2vpn->pw_tree);
462 RB_INIT(&nl2vpn->pw_inactive_tree);
463
464 RB_INSERT(l2vpn_head, &nconf->l2vpn_tree, nl2vpn);
465 break;
466 case IMSG_RECONF_L2VPN_IF:
467 if ((nlif = malloc(sizeof(struct l2vpn_if))) == NULL)
468 fatal(NULL);
469 memcpy(nlif, imsg.data, sizeof(struct l2vpn_if));
470
471 nlif->l2vpn = nl2vpn;
472 RB_INSERT(l2vpn_if_head, &nl2vpn->if_tree, nlif);
473 break;
474 case IMSG_RECONF_L2VPN_PW:
475 if ((npw = malloc(sizeof(struct l2vpn_pw))) == NULL)
476 fatal(NULL);
477 memcpy(npw, imsg.data, sizeof(struct l2vpn_pw));
478
479 npw->l2vpn = nl2vpn;
480 RB_INSERT(l2vpn_pw_head, &nl2vpn->pw_tree, npw);
481 break;
482 case IMSG_RECONF_L2VPN_IPW:
483 if ((npw = malloc(sizeof(struct l2vpn_pw))) == NULL)
484 fatal(NULL);
485 memcpy(npw, imsg.data, sizeof(struct l2vpn_pw));
486
487 npw->l2vpn = nl2vpn;
488 RB_INSERT(l2vpn_pw_head, &nl2vpn->pw_inactive_tree, npw);
489 break;
490 case IMSG_RECONF_END:
491 merge_config(leconf, nconf);
492 nconf = NULL;
493 global.conf_seqnum++;
494 break;
495 case IMSG_CTL_END:
496 control_imsg_relay(&imsg);
497 break;
498 case IMSG_DEBUG_UPDATE:
499 if (imsg.hdr.len != IMSG_HEADER_SIZE +
500 sizeof(ldp_debug)) {
501 log_warnx("%s: wrong imsg len", __func__);
502 break;
503 }
504 memcpy(&ldp_debug, imsg.data, sizeof(ldp_debug));
505 break;
506 default:
507 log_debug("ldpe_dispatch_main: error handling imsg %d",
508 imsg.hdr.type);
509 break;
510 }
511 imsg_free(&imsg);
512 }
513 if (!shut)
514 imsg_event_add(iev);
515 else {
516 /* this pipe is dead, so remove the event handlers and exit */
517 THREAD_READ_OFF(iev->ev_read);
518 THREAD_WRITE_OFF(iev->ev_write);
519 ldpe_shutdown();
520 }
521
522 return (0);
523 }
524
525 /* ARGSUSED */
526 static int
527 ldpe_dispatch_lde(struct thread *thread)
528 {
529 struct imsgev *iev = THREAD_ARG(thread);
530 struct imsgbuf *ibuf = &iev->ibuf;
531 struct imsg imsg;
532 struct map map;
533 struct notify_msg nm;
534 int n, shut = 0;
535 struct nbr *nbr = NULL;
536
537 iev->ev_read = NULL;
538
539 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
540 fatal("imsg_read error");
541 if (n == 0) /* connection closed */
542 shut = 1;
543
544 for (;;) {
545 if ((n = imsg_get(ibuf, &imsg)) == -1)
546 fatal("ldpe_dispatch_lde: imsg_get error");
547 if (n == 0)
548 break;
549
550 switch (imsg.hdr.type) {
551 case IMSG_MAPPING_ADD:
552 case IMSG_RELEASE_ADD:
553 case IMSG_REQUEST_ADD:
554 case IMSG_WITHDRAW_ADD:
555 if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(map))
556 fatalx("invalid size of map request");
557 memcpy(&map, imsg.data, sizeof(map));
558
559 nbr = nbr_find_peerid(imsg.hdr.peerid);
560 if (nbr == NULL) {
561 log_debug("ldpe_dispatch_lde: cannot find "
562 "neighbor");
563 break;
564 }
565 if (nbr->state != NBR_STA_OPER)
566 break;
567
568 switch (imsg.hdr.type) {
569 case IMSG_MAPPING_ADD:
570 mapping_list_add(&nbr->mapping_list, &map);
571 break;
572 case IMSG_RELEASE_ADD:
573 mapping_list_add(&nbr->release_list, &map);
574 break;
575 case IMSG_REQUEST_ADD:
576 mapping_list_add(&nbr->request_list, &map);
577 break;
578 case IMSG_WITHDRAW_ADD:
579 mapping_list_add(&nbr->withdraw_list, &map);
580 break;
581 }
582 break;
583 case IMSG_MAPPING_ADD_END:
584 case IMSG_RELEASE_ADD_END:
585 case IMSG_REQUEST_ADD_END:
586 case IMSG_WITHDRAW_ADD_END:
587 nbr = nbr_find_peerid(imsg.hdr.peerid);
588 if (nbr == NULL) {
589 log_debug("ldpe_dispatch_lde: cannot find "
590 "neighbor");
591 break;
592 }
593 if (nbr->state != NBR_STA_OPER)
594 break;
595
596 switch (imsg.hdr.type) {
597 case IMSG_MAPPING_ADD_END:
598 send_labelmessage(nbr, MSG_TYPE_LABELMAPPING,
599 &nbr->mapping_list);
600 break;
601 case IMSG_RELEASE_ADD_END:
602 send_labelmessage(nbr, MSG_TYPE_LABELRELEASE,
603 &nbr->release_list);
604 break;
605 case IMSG_REQUEST_ADD_END:
606 send_labelmessage(nbr, MSG_TYPE_LABELREQUEST,
607 &nbr->request_list);
608 break;
609 case IMSG_WITHDRAW_ADD_END:
610 send_labelmessage(nbr, MSG_TYPE_LABELWITHDRAW,
611 &nbr->withdraw_list);
612 break;
613 }
614 break;
615 case IMSG_NOTIFICATION_SEND:
616 if (imsg.hdr.len - IMSG_HEADER_SIZE != sizeof(nm))
617 fatalx("invalid size of OE request");
618 memcpy(&nm, imsg.data, sizeof(nm));
619
620 nbr = nbr_find_peerid(imsg.hdr.peerid);
621 if (nbr == NULL) {
622 log_debug("ldpe_dispatch_lde: cannot find "
623 "neighbor");
624 break;
625 }
626 if (nbr->state != NBR_STA_OPER)
627 break;
628
629 send_notification_full(nbr->tcp, &nm);
630 break;
631 case IMSG_CTL_END:
632 case IMSG_CTL_SHOW_LIB:
633 case IMSG_CTL_SHOW_L2VPN_PW:
634 case IMSG_CTL_SHOW_L2VPN_BINDING:
635 control_imsg_relay(&imsg);
636 break;
637 default:
638 log_debug("ldpe_dispatch_lde: error handling imsg %d",
639 imsg.hdr.type);
640 break;
641 }
642 imsg_free(&imsg);
643 }
644 if (!shut)
645 imsg_event_add(iev);
646 else {
647 /* this pipe is dead, so remove the event handlers and exit */
648 THREAD_READ_OFF(iev->ev_read);
649 THREAD_WRITE_OFF(iev->ev_write);
650 ldpe_shutdown();
651 }
652
653 return (0);
654 }
655
656 #ifdef __OpenBSD__
657 /* ARGSUSED */
658 static int
659 ldpe_dispatch_pfkey(struct thread *thread)
660 {
661 int fd = THREAD_FD(thread);
662
663 pfkey_ev = thread_add_read(master, ldpe_dispatch_pfkey,
664 NULL, global.pfkeysock);
665
666 if (pfkey_read(fd, NULL) == -1)
667 fatal("pfkey_read failed, exiting...");
668
669 return (0);
670 }
671 #endif /* __OpenBSD__ */
672
673 static void
674 ldpe_setup_sockets(int af, int disc_socket, int edisc_socket,
675 int session_socket)
676 {
677 struct ldpd_af_global *af_global;
678
679 af_global = ldp_af_global_get(&global, af);
680
681 /* discovery socket */
682 af_global->ldp_disc_socket = disc_socket;
683 af_global->disc_ev = thread_add_read(master, disc_recv_packet,
684 &af_global->disc_ev, af_global->ldp_disc_socket);
685
686 /* extended discovery socket */
687 af_global->ldp_edisc_socket = edisc_socket;
688 af_global->edisc_ev = thread_add_read(master, disc_recv_packet,
689 &af_global->edisc_ev, af_global->ldp_edisc_socket);
690
691 /* session socket */
692 af_global->ldp_session_socket = session_socket;
693 accept_add(af_global->ldp_session_socket, session_accept, NULL);
694 }
695
696 static void
697 ldpe_close_sockets(int af)
698 {
699 struct ldpd_af_global *af_global;
700
701 af_global = ldp_af_global_get(&global, af);
702
703 /* discovery socket */
704 THREAD_READ_OFF(af_global->disc_ev);
705 if (af_global->ldp_disc_socket != -1) {
706 close(af_global->ldp_disc_socket);
707 af_global->ldp_disc_socket = -1;
708 }
709
710 /* extended discovery socket */
711 THREAD_READ_OFF(af_global->edisc_ev);
712 if (af_global->ldp_edisc_socket != -1) {
713 close(af_global->ldp_edisc_socket);
714 af_global->ldp_edisc_socket = -1;
715 }
716
717 /* session socket */
718 if (af_global->ldp_session_socket != -1) {
719 accept_del(af_global->ldp_session_socket);
720 close(af_global->ldp_session_socket);
721 af_global->ldp_session_socket = -1;
722 }
723 }
724
725 int
726 ldpe_acl_check(char *acl_name, int af, union ldpd_addr *addr, uint8_t prefixlen)
727 {
728 return ldp_acl_request(iev_main_sync, acl_name, af, addr, prefixlen);
729 }
730
731 void
732 ldpe_reset_nbrs(int af)
733 {
734 struct nbr *nbr;
735
736 RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) {
737 if (af == AF_UNSPEC || nbr->af == af)
738 session_shutdown(nbr, S_SHUTDOWN, 0, 0);
739 }
740 }
741
742 void
743 ldpe_reset_ds_nbrs(void)
744 {
745 struct nbr *nbr;
746
747 RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) {
748 if (nbr->ds_tlv)
749 session_shutdown(nbr, S_SHUTDOWN, 0, 0);
750 }
751 }
752
753 void
754 ldpe_remove_dynamic_tnbrs(int af)
755 {
756 struct tnbr *tnbr, *safe;
757
758 RB_FOREACH_SAFE(tnbr, tnbr_head, &leconf->tnbr_tree, safe) {
759 if (tnbr->af != af)
760 continue;
761
762 tnbr->flags &= ~F_TNBR_DYNAMIC;
763 tnbr_check(leconf, tnbr);
764 }
765 }
766
767 void
768 ldpe_stop_init_backoff(int af)
769 {
770 struct nbr *nbr;
771
772 RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) {
773 if (nbr->af == af && nbr_pending_idtimer(nbr)) {
774 nbr_stop_idtimer(nbr);
775 nbr_establish_connection(nbr);
776 }
777 }
778 }
779
780 static void
781 ldpe_iface_af_ctl(struct ctl_conn *c, int af, unsigned int idx)
782 {
783 struct iface *iface;
784 struct iface_af *ia;
785 struct ctl_iface *ictl;
786
787 RB_FOREACH(iface, iface_head, &leconf->iface_tree) {
788 if (idx == 0 || idx == iface->ifindex) {
789 ia = iface_af_get(iface, af);
790 if (!ia->enabled)
791 continue;
792
793 ictl = if_to_ctl(ia);
794 imsg_compose_event(&c->iev,
795 IMSG_CTL_SHOW_INTERFACE,
796 0, 0, -1, ictl, sizeof(struct ctl_iface));
797 }
798 }
799 }
800
801 void
802 ldpe_iface_ctl(struct ctl_conn *c, unsigned int idx)
803 {
804 ldpe_iface_af_ctl(c, AF_INET, idx);
805 ldpe_iface_af_ctl(c, AF_INET6, idx);
806 }
807
808 void
809 ldpe_adj_ctl(struct ctl_conn *c)
810 {
811 struct iface *iface;
812 struct tnbr *tnbr;
813 struct adj *adj;
814 struct ctl_adj *actl;
815 struct ctl_disc_if ictl;
816 struct ctl_disc_tnbr tctl;
817
818 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_DISCOVERY, 0, 0, -1, NULL, 0);
819
820 RB_FOREACH(iface, iface_head, &leconf->iface_tree) {
821 memset(&ictl, 0, sizeof(ictl));
822 ictl.active_v4 = (iface->ipv4.state == IF_STA_ACTIVE);
823 ictl.active_v6 = (iface->ipv6.state == IF_STA_ACTIVE);
824
825 if (!ictl.active_v4 && !ictl.active_v6)
826 continue;
827
828 strlcpy(ictl.name, iface->name, sizeof(ictl.name));
829 if (RB_EMPTY(&iface->ipv4.adj_tree) &&
830 RB_EMPTY(&iface->ipv6.adj_tree))
831 ictl.no_adj = 1;
832 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_DISC_IFACE, 0, 0,
833 -1, &ictl, sizeof(ictl));
834
835 RB_FOREACH(adj, ia_adj_head, &iface->ipv4.adj_tree) {
836 actl = adj_to_ctl(adj);
837 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_DISC_ADJ,
838 0, 0, -1, actl, sizeof(struct ctl_adj));
839 }
840 RB_FOREACH(adj, ia_adj_head, &iface->ipv6.adj_tree) {
841 actl = adj_to_ctl(adj);
842 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_DISC_ADJ,
843 0, 0, -1, actl, sizeof(struct ctl_adj));
844 }
845 }
846
847 RB_FOREACH(tnbr, tnbr_head, &leconf->tnbr_tree) {
848 memset(&tctl, 0, sizeof(tctl));
849 tctl.af = tnbr->af;
850 tctl.addr = tnbr->addr;
851 if (tnbr->adj == NULL)
852 tctl.no_adj = 1;
853
854 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_DISC_TNBR, 0, 0,
855 -1, &tctl, sizeof(tctl));
856
857 if (tnbr->adj == NULL)
858 continue;
859
860 actl = adj_to_ctl(tnbr->adj);
861 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_DISC_ADJ, 0, 0,
862 -1, actl, sizeof(struct ctl_adj));
863 }
864
865 imsg_compose_event(&c->iev, IMSG_CTL_END, 0, 0, -1, NULL, 0);
866 }
867
868 void
869 ldpe_nbr_ctl(struct ctl_conn *c)
870 {
871 struct adj *adj;
872 struct ctl_adj *actl;
873 struct nbr *nbr;
874 struct ctl_nbr *nctl;
875
876 RB_FOREACH(nbr, nbr_addr_head, &nbrs_by_addr) {
877 if (nbr->state == NBR_STA_PRESENT)
878 continue;
879
880 nctl = nbr_to_ctl(nbr);
881 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_NBR, 0, 0, -1, nctl,
882 sizeof(struct ctl_nbr));
883
884 RB_FOREACH(adj, nbr_adj_head, &nbr->adj_tree) {
885 actl = adj_to_ctl(adj);
886 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_NBR_DISC,
887 0, 0, -1, actl, sizeof(struct ctl_adj));
888 }
889
890 imsg_compose_event(&c->iev, IMSG_CTL_SHOW_NBR_END, 0, 0, -1,
891 NULL, 0);
892 }
893 imsg_compose_event(&c->iev, IMSG_CTL_END, 0, 0, -1, NULL, 0);
894 }
895
896 void
897 mapping_list_add(struct mapping_head *mh, struct map *map)
898 {
899 struct mapping_entry *me;
900
901 me = calloc(1, sizeof(*me));
902 if (me == NULL)
903 fatal(__func__);
904 me->map = *map;
905
906 TAILQ_INSERT_TAIL(mh, me, entry);
907 }
908
909 void
910 mapping_list_clr(struct mapping_head *mh)
911 {
912 struct mapping_entry *me;
913
914 while ((me = TAILQ_FIRST(mh)) != NULL) {
915 TAILQ_REMOVE(mh, me, entry);
916 free(me);
917 }
918 }
FRRouting mirror