]> git.proxmox.com Git - mirror_frr.git/blob - ldpd/lde.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #7748 from adrianomarto/bgp-listen-on-multiple-addresses
[mirror_frr.git] / ldpd / lde.c
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2013, 2016 Renato Westphal <renato@openbsd.org>
5 * Copyright (c) 2004, 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 <zebra.h>
23
24 #include "ldp.h"
25 #include "ldpd.h"
26 #include "ldpe.h"
27 #include "log.h"
28 #include "lde.h"
29 #include "ldp_debug.h"
30 #include "rlfa.h"
31
32 #include <lib/log.h>
33 #include "memory.h"
34 #include "privs.h"
35 #include "sigevent.h"
36 #include "mpls.h"
37 #include <lib/linklist.h>
38 #include "zclient.h"
39 #include "stream.h"
40 #include "network.h"
41 #include "libfrr.h"
42
43 static void lde_shutdown(void);
44 static int lde_dispatch_imsg(struct thread *);
45 static int lde_dispatch_parent(struct thread *);
46 static __inline int lde_nbr_compare(const struct lde_nbr *,
47 const struct lde_nbr *);
48 static struct lde_nbr *lde_nbr_new(uint32_t, struct lde_nbr *);
49 static void lde_nbr_del(struct lde_nbr *);
50 static struct lde_nbr *lde_nbr_find(uint32_t);
51 static void lde_nbr_clear(void);
52 static void lde_nbr_addr_update(struct lde_nbr *,
53 struct lde_addr *, int);
54 static __inline int lde_map_compare(const struct lde_map *,
55 const struct lde_map *);
56 static void lde_map_free(void *);
57 static int lde_address_add(struct lde_nbr *, struct lde_addr *);
58 static int lde_address_del(struct lde_nbr *, struct lde_addr *);
59 static void lde_address_list_free(struct lde_nbr *);
60 static void zclient_sync_init(void);
61 static void lde_label_list_init(void);
62 static int lde_get_label_chunk(void);
63 static void on_get_label_chunk_response(uint32_t start, uint32_t end);
64 static uint32_t lde_get_next_label(void);
65 static bool lde_fec_connected(const struct fec_node *);
66 static bool lde_fec_outside_mpls_network(const struct fec_node *);
67 static void lde_check_filter_af(int, struct ldpd_af_conf *,
68 const char *);
69
70 RB_GENERATE(nbr_tree, lde_nbr, entry, lde_nbr_compare)
71 RB_GENERATE(lde_map_head, lde_map, entry, lde_map_compare)
72
73 struct ldpd_conf *ldeconf;
74 struct nbr_tree lde_nbrs = RB_INITIALIZER(&lde_nbrs);
75
76 static struct imsgev *iev_ldpe;
77 static struct imsgev iev_main_sync_data;
78 static struct imsgev *iev_main, *iev_main_sync;
79
80 /* lde privileges */
81 static zebra_capabilities_t _caps_p [] =
82 {
83 ZCAP_NET_ADMIN
84 };
85
86 static struct zebra_privs_t lde_privs =
87 {
88 #if defined(VTY_GROUP)
89 .vty_group = VTY_GROUP,
90 #endif
91 .caps_p = _caps_p,
92 .cap_num_p = array_size(_caps_p),
93 .cap_num_i = 0
94 };
95
96 /* List of chunks of labels externally assigned by Zebra */
97 static struct list *label_chunk_list;
98 static struct listnode *current_label_chunk;
99
100 /* Synchronous zclient to request labels */
101 static struct zclient *zclient_sync;
102
103 /* SIGINT / SIGTERM handler. */
104 static void
105 sigint(void)
106 {
107 lde_shutdown();
108 }
109
110 static struct quagga_signal_t lde_signals[] =
111 {
112 {
113 .signal = SIGHUP,
114 /* ignore */
115 },
116 {
117 .signal = SIGINT,
118 .handler = &sigint,
119 },
120 {
121 .signal = SIGTERM,
122 .handler = &sigint,
123 },
124 };
125
126 /* label decision engine */
127 void
128 lde(void)
129 {
130 struct thread thread;
131
132 #ifdef HAVE_SETPROCTITLE
133 setproctitle("label decision engine");
134 #endif
135 ldpd_process = PROC_LDE_ENGINE;
136 log_procname = log_procnames[PROC_LDE_ENGINE];
137
138 master = thread_master_create(NULL);
139
140 /* setup signal handler */
141 signal_init(master, array_size(lde_signals), lde_signals);
142
143 /* setup pipes and event handlers to the parent process */
144 if ((iev_main = calloc(1, sizeof(struct imsgev))) == NULL)
145 fatal(NULL);
146 imsg_init(&iev_main->ibuf, LDPD_FD_ASYNC);
147 iev_main->handler_read = lde_dispatch_parent;
148 iev_main->ev_read = NULL;
149 thread_add_read(master, iev_main->handler_read, iev_main, iev_main->ibuf.fd,
150 &iev_main->ev_read);
151 iev_main->handler_write = ldp_write_handler;
152
153 memset(&iev_main_sync_data, 0, sizeof(iev_main_sync_data));
154 iev_main_sync = &iev_main_sync_data;
155 imsg_init(&iev_main_sync->ibuf, LDPD_FD_SYNC);
156
157 /* create base configuration */
158 ldeconf = config_new_empty();
159
160 /* Fetch next active thread. */
161 while (thread_fetch(master, &thread))
162 thread_call(&thread);
163 }
164
165 void
166 lde_init(struct ldpd_init *init)
167 {
168 /* drop privileges */
169 lde_privs.user = init->user;
170 lde_privs.group = init->group;
171 zprivs_preinit(&lde_privs);
172 zprivs_init(&lde_privs);
173
174 /* start the LIB garbage collector */
175 lde_gc_start_timer();
176
177 /* Init synchronous zclient and label list */
178 frr_zclient_addr(&zclient_addr, &zclient_addr_len,
179 init->zclient_serv_path);
180 zclient_sync_init();
181 }
182
183 static void
184 lde_shutdown(void)
185 {
186 /* close pipes */
187 if (iev_ldpe) {
188 msgbuf_clear(&iev_ldpe->ibuf.w);
189 close(iev_ldpe->ibuf.fd);
190 iev_ldpe->ibuf.fd = -1;
191 }
192 msgbuf_clear(&iev_main->ibuf.w);
193 close(iev_main->ibuf.fd);
194 iev_main->ibuf.fd = -1;
195 msgbuf_clear(&iev_main_sync->ibuf.w);
196 close(iev_main_sync->ibuf.fd);
197 iev_main_sync->ibuf.fd = -1;
198
199 lde_gc_stop_timer();
200 lde_nbr_clear();
201 fec_tree_clear();
202
203 config_clear(ldeconf);
204
205 if (iev_ldpe)
206 free(iev_ldpe);
207 free(iev_main);
208
209 log_info("label decision engine exiting");
210
211 zlog_fini();
212 exit(0);
213 }
214
215 /* imesg */
216 int
217 lde_imsg_compose_parent(int type, pid_t pid, void *data, uint16_t datalen)
218 {
219 if (iev_main->ibuf.fd == -1)
220 return (0);
221 return (imsg_compose_event(iev_main, type, 0, pid, -1, data, datalen));
222 }
223
224 void
225 lde_imsg_compose_parent_sync(int type, pid_t pid, void *data, uint16_t datalen)
226 {
227 if (iev_main_sync->ibuf.fd == -1)
228 return;
229 imsg_compose_event(iev_main_sync, type, 0, pid, -1, data, datalen);
230 imsg_flush(&iev_main_sync->ibuf);
231 }
232
233 int
234 lde_imsg_compose_ldpe(int type, uint32_t peerid, pid_t pid, void *data,
235 uint16_t datalen)
236 {
237 if (iev_ldpe->ibuf.fd == -1)
238 return (0);
239 return (imsg_compose_event(iev_ldpe, type, peerid, pid,
240 -1, data, datalen));
241 }
242
243 /* ARGSUSED */
244 static int
245 lde_dispatch_imsg(struct thread *thread)
246 {
247 struct imsgev *iev = THREAD_ARG(thread);
248 struct imsgbuf *ibuf = &iev->ibuf;
249 struct imsg imsg;
250 struct lde_nbr *ln;
251 struct map *map;
252 struct lde_addr *lde_addr;
253 struct notify_msg *nm;
254 ssize_t n;
255 int shut = 0;
256
257 iev->ev_read = NULL;
258
259 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
260 fatal("imsg_read error");
261 if (n == 0) /* connection closed */
262 shut = 1;
263
264 for (;;) {
265 if ((n = imsg_get(ibuf, &imsg)) == -1)
266 fatal("lde_dispatch_imsg: imsg_get error");
267 if (n == 0)
268 break;
269
270 switch (imsg.hdr.type) {
271 case IMSG_LABEL_MAPPING_FULL:
272 ln = lde_nbr_find(imsg.hdr.peerid);
273 if (ln == NULL) {
274 log_debug("%s: cannot find lde neighbor",
275 __func__);
276 break;
277 }
278
279 fec_snap(ln);
280 break;
281 case IMSG_LABEL_MAPPING:
282 case IMSG_LABEL_REQUEST:
283 case IMSG_LABEL_RELEASE:
284 case IMSG_LABEL_WITHDRAW:
285 case IMSG_LABEL_ABORT:
286 if (imsg.hdr.len - IMSG_HEADER_SIZE !=
287 sizeof(struct map))
288 fatalx("lde_dispatch_imsg: wrong imsg len");
289 map = imsg.data;
290
291 ln = lde_nbr_find(imsg.hdr.peerid);
292 if (ln == NULL) {
293 log_debug("%s: cannot find lde neighbor",
294 __func__);
295 break;
296 }
297
298 switch (imsg.hdr.type) {
299 case IMSG_LABEL_MAPPING:
300 lde_check_mapping(map, ln, 1);
301 break;
302 case IMSG_LABEL_REQUEST:
303 lde_check_request(map, ln);
304 break;
305 case IMSG_LABEL_RELEASE:
306 lde_check_release(map, ln);
307 break;
308 case IMSG_LABEL_WITHDRAW:
309 lde_check_withdraw(map, ln);
310 break;
311 case IMSG_LABEL_ABORT:
312 /* not necessary */
313 break;
314 }
315 break;
316 case IMSG_ADDRESS_ADD:
317 if (imsg.hdr.len - IMSG_HEADER_SIZE !=
318 sizeof(struct lde_addr))
319 fatalx("lde_dispatch_imsg: wrong imsg len");
320 lde_addr = imsg.data;
321
322 ln = lde_nbr_find(imsg.hdr.peerid);
323 if (ln == NULL) {
324 log_debug("%s: cannot find lde neighbor",
325 __func__);
326 break;
327 }
328 if (lde_address_add(ln, lde_addr) < 0) {
329 log_debug("%s: cannot add address %s, it already exists", __func__,
330 log_addr(lde_addr->af, &lde_addr->addr));
331 }
332 break;
333 case IMSG_ADDRESS_DEL:
334 if (imsg.hdr.len - IMSG_HEADER_SIZE !=
335 sizeof(struct lde_addr))
336 fatalx("lde_dispatch_imsg: wrong imsg len");
337 lde_addr = imsg.data;
338
339 ln = lde_nbr_find(imsg.hdr.peerid);
340 if (ln == NULL) {
341 log_debug("%s: cannot find lde neighbor",
342 __func__);
343 break;
344 }
345 if (lde_address_del(ln, lde_addr) < 0) {
346 log_debug("%s: cannot delete address %s, it does not exist", __func__,
347 log_addr(lde_addr->af, &lde_addr->addr));
348 }
349 break;
350 case IMSG_NOTIFICATION:
351 if (imsg.hdr.len - IMSG_HEADER_SIZE !=
352 sizeof(struct notify_msg))
353 fatalx("lde_dispatch_imsg: wrong imsg len");
354 nm = imsg.data;
355
356 ln = lde_nbr_find(imsg.hdr.peerid);
357 if (ln == NULL) {
358 log_debug("%s: cannot find lde neighbor",
359 __func__);
360 break;
361 }
362
363 switch (nm->status_code) {
364 case S_PW_STATUS:
365 l2vpn_recv_pw_status(ln, nm);
366 break;
367 case S_ENDOFLIB:
368 /*
369 * Do nothing for now. Should be useful in
370 * the future when we implement LDP-IGP
371 * Synchronization (RFC 5443) and Graceful
372 * Restart (RFC 3478).
373 */
374 default:
375 break;
376 }
377 break;
378 case IMSG_NEIGHBOR_UP:
379 if (imsg.hdr.len - IMSG_HEADER_SIZE !=
380 sizeof(struct lde_nbr))
381 fatalx("lde_dispatch_imsg: wrong imsg len");
382
383 if (lde_nbr_find(imsg.hdr.peerid))
384 fatalx("lde_dispatch_imsg: neighbor already exists");
385 lde_nbr_new(imsg.hdr.peerid, imsg.data);
386 break;
387 case IMSG_NEIGHBOR_DOWN:
388 lde_nbr_del(lde_nbr_find(imsg.hdr.peerid));
389 break;
390 case IMSG_CTL_SHOW_LIB:
391 rt_dump(imsg.hdr.pid);
392
393 lde_imsg_compose_ldpe(IMSG_CTL_END, 0,
394 imsg.hdr.pid, NULL, 0);
395 break;
396 case IMSG_CTL_SHOW_L2VPN_PW:
397 l2vpn_pw_ctl(imsg.hdr.pid);
398
399 lde_imsg_compose_ldpe(IMSG_CTL_END, 0,
400 imsg.hdr.pid, NULL, 0);
401 break;
402 case IMSG_CTL_SHOW_L2VPN_BINDING:
403 l2vpn_binding_ctl(imsg.hdr.pid);
404
405 lde_imsg_compose_ldpe(IMSG_CTL_END, 0,
406 imsg.hdr.pid, NULL, 0);
407 break;
408 default:
409 log_debug("%s: unexpected imsg %d", __func__,
410 imsg.hdr.type);
411 break;
412 }
413 imsg_free(&imsg);
414 }
415 if (!shut)
416 imsg_event_add(iev);
417 else {
418 /* this pipe is dead, so remove the event handlers and exit */
419 thread_cancel(&iev->ev_read);
420 thread_cancel(&iev->ev_write);
421 lde_shutdown();
422 }
423
424 return (0);
425 }
426
427 /* ARGSUSED */
428 static int
429 lde_dispatch_parent(struct thread *thread)
430 {
431 static struct ldpd_conf *nconf;
432 struct iface *iface, *niface;
433 struct tnbr *ntnbr;
434 struct nbr_params *nnbrp;
435 static struct l2vpn *l2vpn, *nl2vpn;
436 struct l2vpn_if *lif, *nlif;
437 struct l2vpn_pw *pw, *npw;
438 struct imsg imsg;
439 struct kif *kif;
440 struct kroute *kr;
441 int fd;
442 struct imsgev *iev = THREAD_ARG(thread);
443 struct imsgbuf *ibuf = &iev->ibuf;
444 ssize_t n;
445 int shut = 0;
446 struct fec fec;
447 struct ldp_access *laccess;
448 struct ldp_rlfa_node *rnode, *rntmp;
449 struct ldp_rlfa_client *rclient;
450 struct zapi_rlfa_request *rlfa_req;
451 struct zapi_rlfa_igp *rlfa_igp;
452
453 iev->ev_read = NULL;
454
455 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
456 fatal("imsg_read error");
457 if (n == 0) /* connection closed */
458 shut = 1;
459
460 for (;;) {
461 if ((n = imsg_get(ibuf, &imsg)) == -1)
462 fatal("lde_dispatch_parent: imsg_get error");
463 if (n == 0)
464 break;
465
466 switch (imsg.hdr.type) {
467 case IMSG_IFSTATUS:
468 if (imsg.hdr.len != IMSG_HEADER_SIZE +
469 sizeof(struct kif))
470 fatalx("IFSTATUS imsg with wrong len");
471 kif = imsg.data;
472
473 iface = if_lookup_name(ldeconf, kif->ifname);
474 if (iface) {
475 if_update_info(iface, kif);
476
477 /* if up see if any labels need to be updated */
478 if (kif->operative)
479 lde_route_update(iface, AF_UNSPEC);
480 break;
481 }
482
483 RB_FOREACH(l2vpn, l2vpn_head, &ldeconf->l2vpn_tree) {
484 lif = l2vpn_if_find(l2vpn, kif->ifname);
485 if (lif) {
486 l2vpn_if_update_info(lif, kif);
487 break;
488 }
489 pw = l2vpn_pw_find(l2vpn, kif->ifname);
490 if (pw) {
491 l2vpn_pw_update_info(pw, kif);
492 break;
493 }
494 }
495 break;
496 case IMSG_PW_UPDATE:
497 if (imsg.hdr.len != IMSG_HEADER_SIZE +
498 sizeof(struct zapi_pw_status))
499 fatalx("PW_UPDATE imsg with wrong len");
500
501 if (l2vpn_pw_status_update(imsg.data) != 0)
502 log_warnx("%s: error updating PW status",
503 __func__);
504 break;
505 case IMSG_NETWORK_ADD:
506 case IMSG_NETWORK_UPDATE:
507 if (imsg.hdr.len != IMSG_HEADER_SIZE +
508 sizeof(struct kroute)) {
509 log_warnx("%s: wrong imsg len", __func__);
510 break;
511 }
512 kr = imsg.data;
513
514 switch (kr->af) {
515 case AF_INET:
516 fec.type = FEC_TYPE_IPV4;
517 fec.u.ipv4.prefix = kr->prefix.v4;
518 fec.u.ipv4.prefixlen = kr->prefixlen;
519 break;
520 case AF_INET6:
521 fec.type = FEC_TYPE_IPV6;
522 fec.u.ipv6.prefix = kr->prefix.v6;
523 fec.u.ipv6.prefixlen = kr->prefixlen;
524 break;
525 default:
526 fatalx("lde_dispatch_parent: unknown af");
527 }
528
529 switch (imsg.hdr.type) {
530 case IMSG_NETWORK_ADD:
531 lde_kernel_insert(&fec, kr->af, &kr->nexthop,
532 kr->ifindex, kr->route_type,
533 kr->route_instance,
534 kr->flags & F_CONNECTED, NULL);
535 break;
536 case IMSG_NETWORK_UPDATE:
537 lde_kernel_update(&fec);
538 break;
539 }
540 break;
541 case IMSG_SOCKET_IPC:
542 if (iev_ldpe) {
543 log_warnx("%s: received unexpected imsg fd to ldpe", __func__);
544 break;
545 }
546 if ((fd = imsg.fd) == -1) {
547 log_warnx("%s: expected to receive imsg fd to ldpe but didn't receive any", __func__);
548 break;
549 }
550
551 if ((iev_ldpe = malloc(sizeof(struct imsgev))) == NULL)
552 fatal(NULL);
553 imsg_init(&iev_ldpe->ibuf, fd);
554 iev_ldpe->handler_read = lde_dispatch_imsg;
555 iev_ldpe->ev_read = NULL;
556 thread_add_read(master, iev_ldpe->handler_read, iev_ldpe, iev_ldpe->ibuf.fd,
557 &iev_ldpe->ev_read);
558 iev_ldpe->handler_write = ldp_write_handler;
559 iev_ldpe->ev_write = NULL;
560 break;
561 case IMSG_INIT:
562 if (imsg.hdr.len != IMSG_HEADER_SIZE +
563 sizeof(struct ldpd_init))
564 fatalx("INIT imsg with wrong len");
565
566 memcpy(&init, imsg.data, sizeof(init));
567 lde_init(&init);
568 break;
569 case IMSG_RECONF_CONF:
570 if ((nconf = malloc(sizeof(struct ldpd_conf))) ==
571 NULL)
572 fatal(NULL);
573 memcpy(nconf, imsg.data, sizeof(struct ldpd_conf));
574
575 RB_INIT(iface_head, &nconf->iface_tree);
576 RB_INIT(tnbr_head, &nconf->tnbr_tree);
577 RB_INIT(nbrp_head, &nconf->nbrp_tree);
578 RB_INIT(l2vpn_head, &nconf->l2vpn_tree);
579 break;
580 case IMSG_RECONF_IFACE:
581 if ((niface = malloc(sizeof(struct iface))) == NULL)
582 fatal(NULL);
583 memcpy(niface, imsg.data, sizeof(struct iface));
584
585 RB_INSERT(iface_head, &nconf->iface_tree, niface);
586 break;
587 case IMSG_RECONF_TNBR:
588 if ((ntnbr = malloc(sizeof(struct tnbr))) == NULL)
589 fatal(NULL);
590 memcpy(ntnbr, imsg.data, sizeof(struct tnbr));
591
592 RB_INSERT(tnbr_head, &nconf->tnbr_tree, ntnbr);
593 break;
594 case IMSG_RECONF_NBRP:
595 if ((nnbrp = malloc(sizeof(struct nbr_params))) == NULL)
596 fatal(NULL);
597 memcpy(nnbrp, imsg.data, sizeof(struct nbr_params));
598
599 RB_INSERT(nbrp_head, &nconf->nbrp_tree, nnbrp);
600 break;
601 case IMSG_RECONF_L2VPN:
602 if ((nl2vpn = malloc(sizeof(struct l2vpn))) == NULL)
603 fatal(NULL);
604 memcpy(nl2vpn, imsg.data, sizeof(struct l2vpn));
605
606 RB_INIT(l2vpn_if_head, &nl2vpn->if_tree);
607 RB_INIT(l2vpn_pw_head, &nl2vpn->pw_tree);
608 RB_INIT(l2vpn_pw_head, &nl2vpn->pw_inactive_tree);
609
610 RB_INSERT(l2vpn_head, &nconf->l2vpn_tree, nl2vpn);
611 break;
612 case IMSG_RECONF_L2VPN_IF:
613 if ((nlif = malloc(sizeof(struct l2vpn_if))) == NULL)
614 fatal(NULL);
615 memcpy(nlif, imsg.data, sizeof(struct l2vpn_if));
616
617 RB_INSERT(l2vpn_if_head, &nl2vpn->if_tree, nlif);
618 break;
619 case IMSG_RECONF_L2VPN_PW:
620 if ((npw = malloc(sizeof(struct l2vpn_pw))) == NULL)
621 fatal(NULL);
622 memcpy(npw, imsg.data, sizeof(struct l2vpn_pw));
623
624 RB_INSERT(l2vpn_pw_head, &nl2vpn->pw_tree, npw);
625 break;
626 case IMSG_RECONF_L2VPN_IPW:
627 if ((npw = malloc(sizeof(struct l2vpn_pw))) == NULL)
628 fatal(NULL);
629 memcpy(npw, imsg.data, sizeof(struct l2vpn_pw));
630
631 RB_INSERT(l2vpn_pw_head, &nl2vpn->pw_inactive_tree, npw);
632 break;
633 case IMSG_RECONF_END:
634 merge_config(ldeconf, nconf);
635 ldp_clear_config(nconf);
636 nconf = NULL;
637 break;
638 case IMSG_DEBUG_UPDATE:
639 if (imsg.hdr.len != IMSG_HEADER_SIZE +
640 sizeof(ldp_debug)) {
641 log_warnx("%s: wrong imsg len", __func__);
642 break;
643 }
644 memcpy(&ldp_debug, imsg.data, sizeof(ldp_debug));
645 break;
646 case IMSG_FILTER_UPDATE:
647 if (imsg.hdr.len != IMSG_HEADER_SIZE +
648 sizeof(struct ldp_access)) {
649 log_warnx("%s: wrong imsg len", __func__);
650 break;
651 }
652 laccess = imsg.data;
653 lde_check_filter_af(AF_INET, &ldeconf->ipv4,
654 laccess->name);
655 lde_check_filter_af(AF_INET6, &ldeconf->ipv6,
656 laccess->name);
657 break;
658 case IMSG_RLFA_REG:
659 if (imsg.hdr.len != IMSG_HEADER_SIZE +
660 sizeof(struct zapi_rlfa_request)) {
661 log_warnx("%s: wrong imsg len", __func__);
662 break;
663 }
664 rlfa_req = imsg.data;
665 rnode = rlfa_node_find(&rlfa_req->destination,
666 rlfa_req->pq_address);
667 if (!rnode)
668 rnode = rlfa_node_new(&rlfa_req->destination,
669 rlfa_req->pq_address);
670 rclient = rlfa_client_find(rnode, &rlfa_req->igp);
671 if (rclient)
672 /* RLFA already registered - do nothing */
673 break;
674 rclient = rlfa_client_new(rnode, &rlfa_req->igp);
675 lde_rlfa_check(rclient);
676 break;
677 case IMSG_RLFA_UNREG_ALL:
678 if (imsg.hdr.len != IMSG_HEADER_SIZE +
679 sizeof(struct zapi_rlfa_igp)) {
680 log_warnx("%s: wrong imsg len", __func__);
681 break;
682 }
683 rlfa_igp = imsg.data;
684
685 RB_FOREACH_SAFE (rnode, ldp_rlfa_node_head,
686 &rlfa_node_tree, rntmp) {
687 rclient = rlfa_client_find(rnode, rlfa_igp);
688 if (!rclient)
689 continue;
690
691 rlfa_client_del(rclient);
692 }
693 break;
694 default:
695 log_debug("%s: unexpected imsg %d", __func__,
696 imsg.hdr.type);
697 break;
698 }
699 imsg_free(&imsg);
700 }
701 if (!shut)
702 imsg_event_add(iev);
703 else {
704 /* this pipe is dead, so remove the event handlers and exit */
705 thread_cancel(&iev->ev_read);
706 thread_cancel(&iev->ev_write);
707 lde_shutdown();
708 }
709
710 return (0);
711 }
712
713 int
714 lde_acl_check(char *acl_name, int af, union ldpd_addr *addr, uint8_t prefixlen)
715 {
716 return ldp_acl_request(iev_main_sync, acl_name, af, addr, prefixlen);
717 }
718
719 static bool lde_fec_connected(const struct fec_node *fn)
720 {
721 struct fec_nh *fnh;
722
723 LIST_FOREACH(fnh, &fn->nexthops, entry)
724 if (fnh->flags & F_FEC_NH_CONNECTED)
725 return true;
726
727 return false;
728 }
729
730 static bool lde_fec_outside_mpls_network(const struct fec_node *fn)
731 {
732 struct fec_nh *fnh;
733
734 LIST_FOREACH(fnh, &fn->nexthops, entry)
735 if (!(fnh->flags & F_FEC_NH_NO_LDP))
736 return false;
737
738 return true;
739 }
740
741 uint32_t
742 lde_update_label(struct fec_node *fn)
743 {
744
745 /* should we allocate a label for this fec? */
746 switch (fn->fec.type) {
747 case FEC_TYPE_IPV4:
748 if ((ldeconf->ipv4.flags & F_LDPD_AF_ALLOCHOSTONLY) &&
749 fn->fec.u.ipv4.prefixlen != 32)
750 return (NO_LABEL);
751 if (lde_acl_check(ldeconf->ipv4.acl_label_allocate_for,
752 AF_INET, (union ldpd_addr *)&fn->fec.u.ipv4.prefix,
753 fn->fec.u.ipv4.prefixlen) != FILTER_PERMIT)
754 return (NO_LABEL);
755 break;
756 case FEC_TYPE_IPV6:
757 if ((ldeconf->ipv6.flags & F_LDPD_AF_ALLOCHOSTONLY) &&
758 fn->fec.u.ipv6.prefixlen != 128)
759 return (NO_LABEL);
760 if (lde_acl_check(ldeconf->ipv6.acl_label_allocate_for,
761 AF_INET6, (union ldpd_addr *)&fn->fec.u.ipv6.prefix,
762 fn->fec.u.ipv6.prefixlen) != FILTER_PERMIT)
763 return (NO_LABEL);
764 break;
765 default:
766 break;
767 }
768
769 /*
770 * If connected interface act as egress for fec.
771 * If LDP is not configured on an interface but there
772 * are other NHs with interfaces configured with LDP
773 * then don't act as an egress for the fec, otherwise
774 * act as an egress for the fec
775 */
776 if (lde_fec_connected(fn) || lde_fec_outside_mpls_network(fn)) {
777 /* choose implicit or explicit-null depending on configuration */
778 switch (fn->fec.type) {
779 case FEC_TYPE_IPV4:
780 if (!(ldeconf->ipv4.flags & F_LDPD_AF_EXPNULL))
781 return (MPLS_LABEL_IMPLICIT_NULL);
782 if (lde_acl_check(ldeconf->ipv4.acl_label_expnull_for,
783 AF_INET, (union ldpd_addr *)&fn->fec.u.ipv4.prefix,
784 fn->fec.u.ipv4.prefixlen) != FILTER_PERMIT)
785 return (MPLS_LABEL_IMPLICIT_NULL);
786 return MPLS_LABEL_IPV4_EXPLICIT_NULL;
787 case FEC_TYPE_IPV6:
788 if (!(ldeconf->ipv6.flags & F_LDPD_AF_EXPNULL))
789 return (MPLS_LABEL_IMPLICIT_NULL);
790 if (lde_acl_check(ldeconf->ipv6.acl_label_expnull_for,
791 AF_INET6, (union ldpd_addr *)&fn->fec.u.ipv6.prefix,
792 fn->fec.u.ipv6.prefixlen) != FILTER_PERMIT)
793 return (MPLS_LABEL_IMPLICIT_NULL);
794 return MPLS_LABEL_IPV6_EXPLICIT_NULL;
795 default:
796 break;
797 }
798 }
799
800 /* preserve current label if there's no need to update it */
801 if (fn->local_label != NO_LABEL &&
802 fn->local_label > MPLS_LABEL_RESERVED_MAX)
803 return (fn->local_label);
804
805 return (lde_get_next_label());
806 }
807
808 void
809 lde_send_change_klabel(struct fec_node *fn, struct fec_nh *fnh)
810 {
811 struct kroute kr;
812 struct zapi_pw zpw;
813 struct l2vpn_pw *pw;
814
815 /*
816 * Ordered Control: don't program label into HW until a
817 * labelmap msg has been received from upstream router
818 */
819 if (fnh->flags & F_FEC_NH_DEFER)
820 return;
821
822 switch (fn->fec.type) {
823 case FEC_TYPE_IPV4:
824 memset(&kr, 0, sizeof(kr));
825 kr.af = AF_INET;
826 kr.prefix.v4 = fn->fec.u.ipv4.prefix;
827 kr.prefixlen = fn->fec.u.ipv4.prefixlen;
828 kr.nexthop.v4 = fnh->nexthop.v4;
829 kr.ifindex = fnh->ifindex;
830 kr.local_label = fn->local_label;
831 kr.remote_label = fnh->remote_label;
832 kr.route_type = fnh->route_type;
833 kr.route_instance = fnh->route_instance;
834 lde_imsg_compose_parent(IMSG_KLABEL_CHANGE, 0, &kr,
835 sizeof(kr));
836 break;
837 case FEC_TYPE_IPV6:
838 memset(&kr, 0, sizeof(kr));
839 kr.af = AF_INET6;
840 kr.prefix.v6 = fn->fec.u.ipv6.prefix;
841 kr.prefixlen = fn->fec.u.ipv6.prefixlen;
842 kr.nexthop.v6 = fnh->nexthop.v6;
843 kr.ifindex = fnh->ifindex;
844 kr.local_label = fn->local_label;
845 kr.remote_label = fnh->remote_label;
846 kr.route_type = fnh->route_type;
847 kr.route_instance = fnh->route_instance;
848
849 lde_imsg_compose_parent(IMSG_KLABEL_CHANGE, 0, &kr,
850 sizeof(kr));
851 break;
852 case FEC_TYPE_PWID:
853 pw = (struct l2vpn_pw *) fn->data;
854 if (!pw || fn->local_label == NO_LABEL ||
855 fnh->remote_label == NO_LABEL)
856 return;
857
858 pw->enabled = true;
859 pw2zpw(pw, &zpw);
860 zpw.local_label = fn->local_label;
861 zpw.remote_label = fnh->remote_label;
862 lde_imsg_compose_parent(IMSG_KPW_SET, 0, &zpw, sizeof(zpw));
863 break;
864 }
865 }
866
867 void
868 lde_send_delete_klabel(struct fec_node *fn, struct fec_nh *fnh)
869 {
870 struct kroute kr;
871 struct zapi_pw zpw;
872 struct l2vpn_pw *pw;
873
874 switch (fn->fec.type) {
875 case FEC_TYPE_IPV4:
876 memset(&kr, 0, sizeof(kr));
877 kr.af = AF_INET;
878 kr.prefix.v4 = fn->fec.u.ipv4.prefix;
879 kr.prefixlen = fn->fec.u.ipv4.prefixlen;
880 kr.nexthop.v4 = fnh->nexthop.v4;
881 kr.ifindex = fnh->ifindex;
882 kr.local_label = fn->local_label;
883 kr.remote_label = fnh->remote_label;
884 kr.route_type = fnh->route_type;
885 kr.route_instance = fnh->route_instance;
886
887 lde_imsg_compose_parent(IMSG_KLABEL_DELETE, 0, &kr,
888 sizeof(kr));
889 break;
890 case FEC_TYPE_IPV6:
891 memset(&kr, 0, sizeof(kr));
892 kr.af = AF_INET6;
893 kr.prefix.v6 = fn->fec.u.ipv6.prefix;
894 kr.prefixlen = fn->fec.u.ipv6.prefixlen;
895 kr.nexthop.v6 = fnh->nexthop.v6;
896 kr.ifindex = fnh->ifindex;
897 kr.local_label = fn->local_label;
898 kr.remote_label = fnh->remote_label;
899 kr.route_type = fnh->route_type;
900 kr.route_instance = fnh->route_instance;
901
902 lde_imsg_compose_parent(IMSG_KLABEL_DELETE, 0, &kr,
903 sizeof(kr));
904 break;
905 case FEC_TYPE_PWID:
906 pw = (struct l2vpn_pw *) fn->data;
907 if (!pw)
908 return;
909
910 pw->enabled = false;
911 pw2zpw(pw, &zpw);
912 zpw.local_label = fn->local_label;
913 zpw.remote_label = fnh->remote_label;
914 lde_imsg_compose_parent(IMSG_KPW_UNSET, 0, &zpw, sizeof(zpw));
915 break;
916 }
917 }
918
919 void
920 lde_fec2prefix(const struct fec *fec, struct prefix *prefix)
921 {
922 memset(prefix, 0, sizeof(*prefix));
923 switch (fec->type) {
924 case FEC_TYPE_IPV4:
925 prefix->family = AF_INET;
926 prefix->u.prefix4 = fec->u.ipv4.prefix;
927 prefix->prefixlen = fec->u.ipv4.prefixlen;
928 break;
929 case FEC_TYPE_IPV6:
930 prefix->family = AF_INET6;
931 prefix->u.prefix6 = fec->u.ipv6.prefix;
932 prefix->prefixlen = fec->u.ipv6.prefixlen;
933 break;
934 default:
935 prefix->family = AF_UNSPEC;
936 break;
937 }
938 }
939
940 void
941 lde_prefix2fec(const struct prefix *prefix, struct fec *fec)
942 {
943 memset(fec, 0, sizeof(*fec));
944 switch (prefix->family) {
945 case AF_INET:
946 fec->type = FEC_TYPE_IPV4;
947 fec->u.ipv4.prefix = prefix->u.prefix4;
948 fec->u.ipv4.prefixlen = prefix->prefixlen;
949 break;
950 case AF_INET6:
951 fec->type = FEC_TYPE_IPV6;
952 fec->u.ipv6.prefix = prefix->u.prefix6;
953 fec->u.ipv6.prefixlen = prefix->prefixlen;
954 break;
955 default:
956 fatalx("lde_prefix2fec: unknown af");
957 break;
958 }
959 }
960
961 void
962 lde_fec2map(struct fec *fec, struct map *map)
963 {
964 memset(map, 0, sizeof(*map));
965
966 switch (fec->type) {
967 case FEC_TYPE_IPV4:
968 map->type = MAP_TYPE_PREFIX;
969 map->fec.prefix.af = AF_INET;
970 map->fec.prefix.prefix.v4 = fec->u.ipv4.prefix;
971 map->fec.prefix.prefixlen = fec->u.ipv4.prefixlen;
972 break;
973 case FEC_TYPE_IPV6:
974 map->type = MAP_TYPE_PREFIX;
975 map->fec.prefix.af = AF_INET6;
976 map->fec.prefix.prefix.v6 = fec->u.ipv6.prefix;
977 map->fec.prefix.prefixlen = fec->u.ipv6.prefixlen;
978 break;
979 case FEC_TYPE_PWID:
980 map->type = MAP_TYPE_PWID;
981 map->fec.pwid.type = fec->u.pwid.type;
982 map->fec.pwid.group_id = 0;
983 map->flags |= F_MAP_PW_ID;
984 map->fec.pwid.pwid = fec->u.pwid.pwid;
985 break;
986 }
987 }
988
989 void
990 lde_map2fec(struct map *map, struct in_addr lsr_id, struct fec *fec)
991 {
992 memset(fec, 0, sizeof(*fec));
993
994 switch (map->type) {
995 case MAP_TYPE_PREFIX:
996 switch (map->fec.prefix.af) {
997 case AF_INET:
998 fec->type = FEC_TYPE_IPV4;
999 fec->u.ipv4.prefix = map->fec.prefix.prefix.v4;
1000 fec->u.ipv4.prefixlen = map->fec.prefix.prefixlen;
1001 break;
1002 case AF_INET6:
1003 fec->type = FEC_TYPE_IPV6;
1004 fec->u.ipv6.prefix = map->fec.prefix.prefix.v6;
1005 fec->u.ipv6.prefixlen = map->fec.prefix.prefixlen;
1006 break;
1007 default:
1008 fatalx("lde_map2fec: unknown af");
1009 break;
1010 }
1011 break;
1012 case MAP_TYPE_PWID:
1013 fec->type = FEC_TYPE_PWID;
1014 fec->u.pwid.type = map->fec.pwid.type;
1015 fec->u.pwid.pwid = map->fec.pwid.pwid;
1016 fec->u.pwid.lsr_id = lsr_id;
1017 break;
1018 }
1019 }
1020
1021 void
1022 lde_send_labelmapping(struct lde_nbr *ln, struct fec_node *fn, int single)
1023 {
1024 struct lde_wdraw *lw;
1025 struct lde_map *me;
1026 struct lde_req *lre;
1027 struct map map;
1028 struct l2vpn_pw *pw;
1029 struct fec_nh *fnh;
1030 bool allow = false;
1031
1032 /*
1033 * Ordered Control: do not send a labelmap msg until
1034 * a labelmap message is received from downstream router
1035 * and don't send labelmap back to downstream router
1036 */
1037 if (ldeconf->flags & F_LDPD_ORDERED_CONTROL) {
1038 LIST_FOREACH(fnh, &fn->nexthops, entry) {
1039 if (fnh->flags & F_FEC_NH_DEFER)
1040 continue;
1041
1042 if (lde_address_find(ln, fnh->af, &fnh->nexthop))
1043 return;
1044 allow = true;
1045 break;
1046 }
1047 if (!allow)
1048 return;
1049 }
1050
1051 /*
1052 * We shouldn't send a new label mapping if we have a pending
1053 * label release to receive. In this case, schedule to send a
1054 * label mapping as soon as a label release is received.
1055 */
1056 lw = (struct lde_wdraw *)fec_find(&ln->sent_wdraw, &fn->fec);
1057 if (lw) {
1058 if (!fec_find(&ln->sent_map_pending, &fn->fec)) {
1059 debug_evt("%s: FEC %s: scheduling to send label mapping later (waiting for pending label release)",
1060 __func__, log_fec(&fn->fec));
1061 lde_map_pending_add(ln, fn);
1062 }
1063 return;
1064 }
1065
1066 /*
1067 * This function skips SL.1 - 3 and SL.9 - 14 because the label
1068 * allocation is done way earlier (because of the merging nature of
1069 * ldpd).
1070 */
1071
1072 lde_fec2map(&fn->fec, &map);
1073 switch (fn->fec.type) {
1074 case FEC_TYPE_IPV4:
1075 if (!ln->v4_enabled)
1076 return;
1077 if (lde_acl_check(ldeconf->ipv4.acl_label_advertise_to,
1078 AF_INET, (union ldpd_addr *)&ln->id, 32) != FILTER_PERMIT)
1079 return;
1080 if (lde_acl_check(ldeconf->ipv4.acl_label_advertise_for,
1081 AF_INET, (union ldpd_addr *)&fn->fec.u.ipv4.prefix,
1082 fn->fec.u.ipv4.prefixlen) != FILTER_PERMIT)
1083 return;
1084 break;
1085 case FEC_TYPE_IPV6:
1086 if (!ln->v6_enabled)
1087 return;
1088 if (lde_acl_check(ldeconf->ipv6.acl_label_advertise_to,
1089 AF_INET, (union ldpd_addr *)&ln->id, 32) != FILTER_PERMIT)
1090 return;
1091 if (lde_acl_check(ldeconf->ipv6.acl_label_advertise_for,
1092 AF_INET6, (union ldpd_addr *)&fn->fec.u.ipv6.prefix,
1093 fn->fec.u.ipv6.prefixlen) != FILTER_PERMIT)
1094 return;
1095 break;
1096 case FEC_TYPE_PWID:
1097 pw = (struct l2vpn_pw *) fn->data;
1098 if (pw == NULL || pw->lsr_id.s_addr != ln->id.s_addr)
1099 /* not the remote end of the pseudowire */
1100 return;
1101
1102 map.flags |= F_MAP_PW_IFMTU;
1103 map.fec.pwid.ifmtu = pw->l2vpn->mtu;
1104 if (pw->flags & F_PW_CWORD)
1105 map.flags |= F_MAP_PW_CWORD;
1106 if (pw->flags & F_PW_STATUSTLV) {
1107 map.flags |= F_MAP_PW_STATUS;
1108 map.pw_status = pw->local_status;
1109 }
1110 break;
1111 }
1112 map.label = fn->local_label;
1113
1114 /* SL.6: is there a pending request for this mapping? */
1115 lre = (struct lde_req *)fec_find(&ln->recv_req, &fn->fec);
1116 if (lre) {
1117 /* set label request msg id in the mapping response. */
1118 map.requestid = lre->msg_id;
1119 map.flags = F_MAP_REQ_ID;
1120
1121 /* SL.7: delete record of pending request */
1122 lde_req_del(ln, lre, 0);
1123 }
1124
1125 /* SL.4: send label mapping */
1126 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD, ln->peerid, 0,
1127 &map, sizeof(map));
1128 if (single)
1129 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END, ln->peerid, 0,
1130 NULL, 0);
1131
1132 /* SL.5: record sent label mapping */
1133 me = (struct lde_map *)fec_find(&ln->sent_map, &fn->fec);
1134 if (me == NULL)
1135 me = lde_map_add(ln, fn, 1);
1136 me->map = map;
1137 }
1138
1139 void
1140 lde_send_labelwithdraw(struct lde_nbr *ln, struct fec_node *fn,
1141 struct map *wcard, struct status_tlv *st)
1142 {
1143 struct lde_wdraw *lw;
1144 struct map map;
1145 struct fec *f;
1146 struct l2vpn_pw *pw;
1147
1148 if (fn) {
1149 lde_fec2map(&fn->fec, &map);
1150 switch (fn->fec.type) {
1151 case FEC_TYPE_IPV4:
1152 if (!ln->v4_enabled)
1153 return;
1154 break;
1155 case FEC_TYPE_IPV6:
1156 if (!ln->v6_enabled)
1157 return;
1158 break;
1159 case FEC_TYPE_PWID:
1160 pw = (struct l2vpn_pw *) fn->data;
1161 if (pw == NULL || pw->lsr_id.s_addr != ln->id.s_addr)
1162 /* not the remote end of the pseudowire */
1163 return;
1164
1165 if (pw->flags & F_PW_CWORD)
1166 map.flags |= F_MAP_PW_CWORD;
1167 break;
1168 }
1169 map.label = fn->local_label;
1170 } else
1171 memcpy(&map, wcard, sizeof(map));
1172
1173 if (st) {
1174 map.st.status_code = st->status_code;
1175 map.st.msg_id = st->msg_id;
1176 map.st.msg_type = st->msg_type;
1177 map.flags |= F_MAP_STATUS;
1178 }
1179
1180 /* SWd.1: send label withdraw. */
1181 lde_imsg_compose_ldpe(IMSG_WITHDRAW_ADD, ln->peerid, 0,
1182 &map, sizeof(map));
1183 lde_imsg_compose_ldpe(IMSG_WITHDRAW_ADD_END, ln->peerid, 0, NULL, 0);
1184
1185 /* SWd.2: record label withdraw. */
1186 if (fn) {
1187 lw = (struct lde_wdraw *)fec_find(&ln->sent_wdraw, &fn->fec);
1188 if (lw == NULL)
1189 lw = lde_wdraw_add(ln, fn);
1190 lw->label = map.label;
1191 } else {
1192 struct lde_map *me;
1193
1194 RB_FOREACH(f, fec_tree, &ft) {
1195 fn = (struct fec_node *)f;
1196 me = (struct lde_map *)fec_find(&ln->sent_map, &fn->fec);
1197 if (lde_wildcard_apply(wcard, &fn->fec, me) == 0)
1198 continue;
1199
1200 lw = (struct lde_wdraw *)fec_find(&ln->sent_wdraw,
1201 &fn->fec);
1202 if (lw == NULL)
1203 lw = lde_wdraw_add(ln, fn);
1204 lw->label = map.label;
1205 }
1206 }
1207 }
1208
1209 void
1210 lde_send_labelwithdraw_wcard(struct lde_nbr *ln, uint32_t label)
1211 {
1212 struct map wcard;
1213
1214 memset(&wcard, 0, sizeof(wcard));
1215 wcard.type = MAP_TYPE_WILDCARD;
1216 wcard.label = label;
1217 lde_send_labelwithdraw(ln, NULL, &wcard, NULL);
1218 }
1219
1220 void
1221 lde_send_labelwithdraw_twcard_prefix(struct lde_nbr *ln, uint16_t af,
1222 uint32_t label)
1223 {
1224 struct map wcard;
1225
1226 memset(&wcard, 0, sizeof(wcard));
1227 wcard.type = MAP_TYPE_TYPED_WCARD;
1228 wcard.fec.twcard.type = MAP_TYPE_PREFIX;
1229 wcard.fec.twcard.u.prefix_af = af;
1230 wcard.label = label;
1231 lde_send_labelwithdraw(ln, NULL, &wcard, NULL);
1232 }
1233
1234 void
1235 lde_send_labelwithdraw_twcard_pwid(struct lde_nbr *ln, uint16_t pw_type,
1236 uint32_t label)
1237 {
1238 struct map wcard;
1239
1240 memset(&wcard, 0, sizeof(wcard));
1241 wcard.type = MAP_TYPE_TYPED_WCARD;
1242 wcard.fec.twcard.type = MAP_TYPE_PWID;
1243 wcard.fec.twcard.u.pw_type = pw_type;
1244 wcard.label = label;
1245 lde_send_labelwithdraw(ln, NULL, &wcard, NULL);
1246 }
1247
1248 void
1249 lde_send_labelwithdraw_pwid_wcard(struct lde_nbr *ln, uint16_t pw_type,
1250 uint32_t group_id)
1251 {
1252 struct map wcard;
1253
1254 memset(&wcard, 0, sizeof(wcard));
1255 wcard.type = MAP_TYPE_PWID;
1256 wcard.fec.pwid.type = pw_type;
1257 wcard.fec.pwid.group_id = group_id;
1258 /* we can not append a Label TLV when using PWid group wildcards. */
1259 wcard.label = NO_LABEL;
1260 lde_send_labelwithdraw(ln, NULL, &wcard, NULL);
1261 }
1262
1263 void
1264 lde_send_labelrelease(struct lde_nbr *ln, struct fec_node *fn,
1265 struct map *wcard, uint32_t label)
1266 {
1267 struct map map;
1268 struct l2vpn_pw *pw;
1269
1270 if (fn) {
1271 lde_fec2map(&fn->fec, &map);
1272 switch (fn->fec.type) {
1273 case FEC_TYPE_IPV4:
1274 if (!ln->v4_enabled)
1275 return;
1276 break;
1277 case FEC_TYPE_IPV6:
1278 if (!ln->v6_enabled)
1279 return;
1280 break;
1281 case FEC_TYPE_PWID:
1282 pw = (struct l2vpn_pw *) fn->data;
1283 if (pw == NULL || pw->lsr_id.s_addr != ln->id.s_addr)
1284 /* not the remote end of the pseudowire */
1285 return;
1286
1287 if (pw->flags & F_PW_CWORD)
1288 map.flags |= F_MAP_PW_CWORD;
1289 break;
1290 }
1291 } else
1292 memcpy(&map, wcard, sizeof(map));
1293 map.label = label;
1294
1295 lde_imsg_compose_ldpe(IMSG_RELEASE_ADD, ln->peerid, 0,
1296 &map, sizeof(map));
1297 lde_imsg_compose_ldpe(IMSG_RELEASE_ADD_END, ln->peerid, 0, NULL, 0);
1298 }
1299
1300 void
1301 lde_send_labelrequest(struct lde_nbr *ln, struct fec_node *fn,
1302 struct map *wcard, int single)
1303 {
1304 struct map map;
1305 struct fec *f;
1306 struct lde_req *lre;
1307
1308 if (fn) {
1309 lde_fec2map(&fn->fec, &map);
1310 switch (fn->fec.type) {
1311 case FEC_TYPE_IPV4:
1312 if (!ln->v4_enabled)
1313 return;
1314 break;
1315 case FEC_TYPE_IPV6:
1316 if (!ln->v6_enabled)
1317 return;
1318 break;
1319 default:
1320 fatalx("lde_send_labelrequest: unknown af");
1321 }
1322 } else
1323 memcpy(&map, wcard, sizeof(map));
1324
1325 map.label = NO_LABEL;
1326
1327 if (fn) {
1328 /* SLR1.1: has label request for FEC been previously sent
1329 * and still outstanding just return,
1330 */
1331 lre = (struct lde_req *)fec_find(&ln->sent_req, &fn->fec);
1332 if (lre == NULL) {
1333 /* SLRq.3: send label request */
1334 lde_imsg_compose_ldpe(IMSG_REQUEST_ADD, ln->peerid, 0,
1335 &map, sizeof(map));
1336 if (single)
1337 lde_imsg_compose_ldpe(IMSG_REQUEST_ADD_END,
1338 ln->peerid, 0, NULL, 0);
1339
1340 /* SLRq.4: record sent request */
1341 lde_req_add(ln, &fn->fec, 1);
1342 }
1343 } else {
1344 /* if Wilcard just send label request */
1345 /* SLRq.3: send label request */
1346 lde_imsg_compose_ldpe(IMSG_REQUEST_ADD,
1347 ln->peerid, 0, &map, sizeof(map));
1348 if (single)
1349 lde_imsg_compose_ldpe(IMSG_REQUEST_ADD_END,
1350 ln->peerid, 0, NULL, 0);
1351
1352 /* SLRq.4: record sent request */
1353 RB_FOREACH(f, fec_tree, &ft) {
1354 fn = (struct fec_node *)f;
1355 lre = (struct lde_req *)fec_find(&ln->sent_req, &fn->fec);
1356 if (lde_wildcard_apply(wcard, &fn->fec, NULL) == 0)
1357 continue;
1358 if (lre == NULL)
1359 lde_req_add(ln, f, 1);
1360 }
1361 }
1362 }
1363
1364 void
1365 lde_send_labelrequest_wcard(struct lde_nbr *ln, uint16_t af)
1366 {
1367 struct map wcard;
1368
1369 memset(&wcard, 0, sizeof(wcard));
1370 wcard.type = MAP_TYPE_TYPED_WCARD;
1371 wcard.fec.twcard.type = MAP_TYPE_PREFIX;
1372 wcard.fec.twcard.u.prefix_af = af;
1373 lde_send_labelrequest(ln, NULL, &wcard, 1);
1374 }
1375
1376 void
1377 lde_send_notification(struct lde_nbr *ln, uint32_t status_code, uint32_t msg_id,
1378 uint16_t msg_type)
1379 {
1380 struct notify_msg nm;
1381
1382 memset(&nm, 0, sizeof(nm));
1383 nm.status_code = status_code;
1384 /* 'msg_id' and 'msg_type' should be in network byte order */
1385 nm.msg_id = msg_id;
1386 nm.msg_type = msg_type;
1387
1388 lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND, ln->peerid, 0,
1389 &nm, sizeof(nm));
1390 }
1391
1392 void
1393 lde_send_notification_eol_prefix(struct lde_nbr *ln, int af)
1394 {
1395 struct notify_msg nm;
1396
1397 memset(&nm, 0, sizeof(nm));
1398 nm.status_code = S_ENDOFLIB;
1399 nm.fec.type = MAP_TYPE_TYPED_WCARD;
1400 nm.fec.fec.twcard.type = MAP_TYPE_PREFIX;
1401 nm.fec.fec.twcard.u.prefix_af = af;
1402 nm.flags |= F_NOTIF_FEC;
1403
1404 lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND, ln->peerid, 0,
1405 &nm, sizeof(nm));
1406 }
1407
1408 void
1409 lde_send_notification_eol_pwid(struct lde_nbr *ln, uint16_t pw_type)
1410 {
1411 struct notify_msg nm;
1412
1413 memset(&nm, 0, sizeof(nm));
1414 nm.status_code = S_ENDOFLIB;
1415 nm.fec.type = MAP_TYPE_TYPED_WCARD;
1416 nm.fec.fec.twcard.type = MAP_TYPE_PWID;
1417 nm.fec.fec.twcard.u.pw_type = pw_type;
1418 nm.flags |= F_NOTIF_FEC;
1419
1420 lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND, ln->peerid, 0,
1421 &nm, sizeof(nm));
1422 }
1423
1424 static __inline int
1425 lde_nbr_compare(const struct lde_nbr *a, const struct lde_nbr *b)
1426 {
1427 return (a->peerid - b->peerid);
1428 }
1429
1430 static struct lde_nbr *
1431 lde_nbr_new(uint32_t peerid, struct lde_nbr *new)
1432 {
1433 struct lde_nbr *ln;
1434
1435 if ((ln = calloc(1, sizeof(*ln))) == NULL)
1436 fatal(__func__);
1437
1438 ln->id = new->id;
1439 ln->v4_enabled = new->v4_enabled;
1440 ln->v6_enabled = new->v6_enabled;
1441 ln->flags = new->flags;
1442 ln->peerid = peerid;
1443 fec_init(&ln->recv_map);
1444 fec_init(&ln->sent_map);
1445 fec_init(&ln->sent_map_pending);
1446 fec_init(&ln->recv_req);
1447 fec_init(&ln->sent_req);
1448 fec_init(&ln->sent_wdraw);
1449
1450 TAILQ_INIT(&ln->addr_list);
1451
1452 if (RB_INSERT(nbr_tree, &lde_nbrs, ln) != NULL)
1453 fatalx("lde_nbr_new: RB_INSERT failed");
1454
1455 return (ln);
1456 }
1457
1458 static void
1459 lde_nbr_del(struct lde_nbr *ln)
1460 {
1461 struct fec *f;
1462 struct fec_node *fn;
1463 struct fec_nh *fnh;
1464 struct l2vpn_pw *pw;
1465 struct lde_nbr *lnbr;
1466
1467 if (ln == NULL)
1468 return;
1469
1470 /* uninstall received mappings */
1471 RB_FOREACH(f, fec_tree, &ft) {
1472 fn = (struct fec_node *)f;
1473
1474 /* Update RLFA clients. */
1475 lde_rlfa_update_clients(f, ln, MPLS_INVALID_LABEL);
1476
1477 LIST_FOREACH(fnh, &fn->nexthops, entry) {
1478 switch (f->type) {
1479 case FEC_TYPE_IPV4:
1480 case FEC_TYPE_IPV6:
1481 if (!lde_address_find(ln, fnh->af,
1482 &fnh->nexthop))
1483 continue;
1484
1485 /*
1486 * Ordered Control: must mark any non-connected
1487 * NH to wait until we receive a labelmap msg
1488 * before installing in kernel and sending to
1489 * peer, must do this as NHs are not removed
1490 * when lsps go down. Also send label withdraw
1491 * to other neighbors for all fecs from neighbor
1492 * going down
1493 */
1494 if (ldeconf->flags & F_LDPD_ORDERED_CONTROL) {
1495 fnh->flags |= F_FEC_NH_DEFER;
1496
1497 RB_FOREACH(lnbr, nbr_tree, &lde_nbrs) {
1498 if (ln->peerid == lnbr->peerid)
1499 continue;
1500 lde_send_labelwithdraw(lnbr, fn, NULL, NULL);
1501 }
1502 }
1503 break;
1504 case FEC_TYPE_PWID:
1505 if (f->u.pwid.lsr_id.s_addr != ln->id.s_addr)
1506 continue;
1507 pw = (struct l2vpn_pw *) fn->data;
1508 if (pw) {
1509 pw->reason = F_PW_NO_REMOTE_LABEL;
1510 l2vpn_pw_reset(pw);
1511 }
1512 break;
1513 default:
1514 break;
1515 }
1516
1517 lde_send_delete_klabel(fn, fnh);
1518 fnh->remote_label = NO_LABEL;
1519 }
1520 }
1521
1522 lde_address_list_free(ln);
1523
1524 fec_clear(&ln->recv_map, lde_map_free);
1525 fec_clear(&ln->sent_map, lde_map_free);
1526 fec_clear(&ln->sent_map_pending, free);
1527 fec_clear(&ln->recv_req, free);
1528 fec_clear(&ln->sent_req, free);
1529 fec_clear(&ln->sent_wdraw, free);
1530
1531 RB_REMOVE(nbr_tree, &lde_nbrs, ln);
1532
1533 free(ln);
1534 }
1535
1536 static struct lde_nbr *
1537 lde_nbr_find(uint32_t peerid)
1538 {
1539 struct lde_nbr ln;
1540
1541 ln.peerid = peerid;
1542
1543 return (RB_FIND(nbr_tree, &lde_nbrs, &ln));
1544 }
1545
1546 struct lde_nbr *
1547 lde_nbr_find_by_lsrid(struct in_addr addr)
1548 {
1549 struct lde_nbr *ln;
1550
1551 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1552 if (ln->id.s_addr == addr.s_addr)
1553 return (ln);
1554
1555 return (NULL);
1556 }
1557
1558 struct lde_nbr *
1559 lde_nbr_find_by_addr(int af, union ldpd_addr *addr)
1560 {
1561 struct lde_nbr *ln;
1562
1563 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1564 if (lde_address_find(ln, af, addr) != NULL)
1565 return (ln);
1566
1567 return (NULL);
1568 }
1569
1570 static void
1571 lde_nbr_clear(void)
1572 {
1573 struct lde_nbr *ln;
1574
1575 while (!RB_EMPTY(nbr_tree, &lde_nbrs)) {
1576 ln = RB_ROOT(nbr_tree, &lde_nbrs);
1577
1578 lde_nbr_del(ln);
1579 }
1580 }
1581
1582 static void
1583 lde_nbr_addr_update(struct lde_nbr *ln, struct lde_addr *lde_addr, int removed)
1584 {
1585 struct fec *fec;
1586 struct fec_node *fn;
1587 struct fec_nh *fnh;
1588 struct lde_map *me;
1589
1590 RB_FOREACH(fec, fec_tree, &ln->recv_map) {
1591 switch (fec->type) {
1592 case FEC_TYPE_IPV4:
1593 if (lde_addr->af != AF_INET)
1594 continue;
1595 break;
1596 case FEC_TYPE_IPV6:
1597 if (lde_addr->af != AF_INET6)
1598 continue;
1599 break;
1600 default:
1601 continue;
1602 }
1603
1604 fn = (struct fec_node *)fec_find(&ft, fec);
1605 if (fn == NULL)
1606 /* shouldn't happen */
1607 continue;
1608
1609 LIST_FOREACH(fnh, &fn->nexthops, entry) {
1610 if (ldp_addrcmp(fnh->af, &fnh->nexthop,
1611 &lde_addr->addr))
1612 continue;
1613
1614 if (removed) {
1615 lde_send_delete_klabel(fn, fnh);
1616 fnh->remote_label = NO_LABEL;
1617 } else {
1618 me = (struct lde_map *)fec;
1619 fnh->remote_label = me->map.label;
1620 lde_send_change_klabel(fn, fnh);
1621 }
1622 break;
1623 }
1624 }
1625 }
1626
1627 static __inline int
1628 lde_map_compare(const struct lde_map *a, const struct lde_map *b)
1629 {
1630 return (ldp_addrcmp(AF_INET, (union ldpd_addr *)&a->nexthop->id,
1631 (union ldpd_addr *)&b->nexthop->id));
1632 }
1633
1634 struct lde_map *
1635 lde_map_add(struct lde_nbr *ln, struct fec_node *fn, int sent)
1636 {
1637 struct lde_map *me;
1638
1639 me = calloc(1, sizeof(*me));
1640 if (me == NULL)
1641 fatal(__func__);
1642
1643 me->fec = fn->fec;
1644 me->nexthop = ln;
1645
1646 if (sent) {
1647 RB_INSERT(lde_map_head, &fn->upstream, me);
1648 me->head = &fn->upstream;
1649 if (fec_insert(&ln->sent_map, &me->fec))
1650 log_warnx("failed to add %s to sent map",
1651 log_fec(&me->fec));
1652 /* XXX on failure more cleanup is needed */
1653 } else {
1654 RB_INSERT(lde_map_head, &fn->downstream, me);
1655 me->head = &fn->downstream;
1656 if (fec_insert(&ln->recv_map, &me->fec))
1657 log_warnx("failed to add %s to recv map",
1658 log_fec(&me->fec));
1659 }
1660
1661 return (me);
1662 }
1663
1664 void
1665 lde_map_del(struct lde_nbr *ln, struct lde_map *me, int sent)
1666 {
1667 if (sent)
1668 fec_remove(&ln->sent_map, &me->fec);
1669 else
1670 fec_remove(&ln->recv_map, &me->fec);
1671
1672 lde_map_free(me);
1673 }
1674
1675 static void
1676 lde_map_free(void *ptr)
1677 {
1678 struct lde_map *map = ptr;
1679
1680 RB_REMOVE(lde_map_head, map->head, map);
1681 free(map);
1682 }
1683
1684 struct fec *
1685 lde_map_pending_add(struct lde_nbr *ln, struct fec_node *fn)
1686 {
1687 struct fec *map;
1688
1689 map = calloc(1, sizeof(*map));
1690 if (map == NULL)
1691 fatal(__func__);
1692
1693 *map = fn->fec;
1694 if (fec_insert(&ln->sent_map_pending, map))
1695 log_warnx("failed to add %s to sent map (pending)",
1696 log_fec(map));
1697
1698 return (map);
1699 }
1700
1701 void
1702 lde_map_pending_del(struct lde_nbr *ln, struct fec *map)
1703 {
1704 fec_remove(&ln->sent_map_pending, map);
1705 free(map);
1706 }
1707
1708 struct lde_req *
1709 lde_req_add(struct lde_nbr *ln, struct fec *fec, int sent)
1710 {
1711 struct fec_tree *t;
1712 struct lde_req *lre;
1713
1714 t = sent ? &ln->sent_req : &ln->recv_req;
1715
1716 lre = calloc(1, sizeof(*lre));
1717 if (lre != NULL) {
1718 lre->fec = *fec;
1719
1720 if (fec_insert(t, &lre->fec)) {
1721 log_warnx("failed to add %s to %s req",
1722 log_fec(&lre->fec), sent ? "sent" : "recv");
1723 free(lre);
1724 return (NULL);
1725 }
1726 }
1727
1728 return (lre);
1729 }
1730
1731 void
1732 lde_req_del(struct lde_nbr *ln, struct lde_req *lre, int sent)
1733 {
1734 if (sent)
1735 fec_remove(&ln->sent_req, &lre->fec);
1736 else
1737 fec_remove(&ln->recv_req, &lre->fec);
1738
1739 free(lre);
1740 }
1741
1742 struct lde_wdraw *
1743 lde_wdraw_add(struct lde_nbr *ln, struct fec_node *fn)
1744 {
1745 struct lde_wdraw *lw;
1746
1747 lw = calloc(1, sizeof(*lw));
1748 if (lw == NULL)
1749 fatal(__func__);
1750
1751 lw->fec = fn->fec;
1752
1753 if (fec_insert(&ln->sent_wdraw, &lw->fec))
1754 log_warnx("failed to add %s to sent wdraw",
1755 log_fec(&lw->fec));
1756
1757 return (lw);
1758 }
1759
1760 void
1761 lde_wdraw_del(struct lde_nbr *ln, struct lde_wdraw *lw)
1762 {
1763 fec_remove(&ln->sent_wdraw, &lw->fec);
1764 free(lw);
1765 }
1766
1767 void
1768 lde_change_egress_label(int af)
1769 {
1770 struct lde_nbr *ln;
1771 struct fec *f;
1772 struct fec_node *fn;
1773
1774 /* explicitly withdraw all null labels */
1775 RB_FOREACH(ln, nbr_tree, &lde_nbrs) {
1776 lde_send_labelwithdraw_wcard(ln, MPLS_LABEL_IMPLICIT_NULL);
1777 if (ln->v4_enabled)
1778 lde_send_labelwithdraw_wcard(
1779 ln,
1780 MPLS_LABEL_IPV4_EXPLICIT_NULL);
1781 if (ln->v6_enabled)
1782 lde_send_labelwithdraw_wcard(
1783 ln,
1784 MPLS_LABEL_IPV6_EXPLICIT_NULL);
1785 }
1786
1787 /* update label of connected routes */
1788 RB_FOREACH(f, fec_tree, &ft) {
1789 fn = (struct fec_node *)f;
1790 if (fn->local_label > MPLS_LABEL_RESERVED_MAX)
1791 continue;
1792
1793 switch (af) {
1794 case AF_INET:
1795 if (fn->fec.type != FEC_TYPE_IPV4)
1796 continue;
1797 break;
1798 case AF_INET6:
1799 if (fn->fec.type != FEC_TYPE_IPV6)
1800 continue;
1801 break;
1802 default:
1803 fatalx("lde_change_egress_label: unknown af");
1804 }
1805
1806 fn->local_label = lde_update_label(fn);
1807 if (fn->local_label != NO_LABEL)
1808 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1809 lde_send_labelmapping(ln, fn, 0);
1810 }
1811 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1812 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END, ln->peerid, 0,
1813 NULL, 0);
1814 }
1815
1816 void
1817 lde_change_allocate_filter(int af)
1818 {
1819 struct lde_nbr *ln;
1820 struct fec *f;
1821 struct fec_node *fn;
1822 uint32_t new_label;
1823
1824 /* reallocate labels for fecs that match this filter */
1825 RB_FOREACH(f, fec_tree, &ft) {
1826 fn = (struct fec_node *)f;
1827
1828 switch (af) {
1829 case AF_INET:
1830 if (fn->fec.type != FEC_TYPE_IPV4)
1831 continue;
1832 break;
1833 case AF_INET6:
1834 if (fn->fec.type != FEC_TYPE_IPV6)
1835 continue;
1836 break;
1837 default:
1838 fatalx("lde_change_allocate_filter: unknown af");
1839 }
1840
1841 /*
1842 * If the local label has changed to NO_LABEL, send a label
1843 * withdraw to all peers.
1844 * If the local label has changed and it's different from
1845 * NO_LABEL, send a label mapping to all peers advertising
1846 * the new label.
1847 * If the local label hasn't changed, do nothing
1848 */
1849 new_label = lde_update_label(fn);
1850 if (fn->local_label != new_label) {
1851 if (new_label == NO_LABEL)
1852 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1853 lde_send_labelwithdraw(ln, fn,
1854 NULL, NULL);
1855
1856 fn->local_label = new_label;
1857 if (fn->local_label != NO_LABEL)
1858 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1859 lde_send_labelmapping(ln, fn, 0);
1860 }
1861 }
1862 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1863 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END, ln->peerid, 0,
1864 NULL, 0);
1865 }
1866
1867 void
1868 lde_change_advertise_filter(int af)
1869 {
1870 struct lde_nbr *ln;
1871 struct fec *f;
1872 struct fec_node *fn;
1873 char *acl_to_filter;
1874 char *acl_for_filter;
1875 union ldpd_addr *prefix;
1876 uint8_t plen;
1877 struct lde_map *me;
1878
1879 /* advertise label for fecs to neighbors if matches advertise filters */
1880 switch (af) {
1881 case AF_INET:
1882 acl_to_filter = ldeconf->ipv4.acl_label_advertise_to;
1883 acl_for_filter = ldeconf->ipv4.acl_label_advertise_for;
1884 break;
1885 case AF_INET6:
1886 acl_to_filter = ldeconf->ipv6.acl_label_advertise_to;
1887 acl_for_filter = ldeconf->ipv6.acl_label_advertise_for;
1888 break;
1889 default:
1890 fatalx("lde_change_advertise_filter: unknown af");
1891 }
1892
1893 RB_FOREACH(ln, nbr_tree, &lde_nbrs) {
1894 if (lde_acl_check(acl_to_filter, af, (union ldpd_addr *)&ln->id,
1895 IPV4_MAX_BITLEN) != FILTER_PERMIT)
1896 lde_send_labelwithdraw_wcard(ln, NO_LABEL);
1897 else {
1898 /* This neighbor is allowed in to_filter, so
1899 * send labels if fec also matches for_filter
1900 */
1901 RB_FOREACH(f, fec_tree, &ft) {
1902 fn = (struct fec_node *)f;
1903 switch (af) {
1904 case AF_INET:
1905 if (fn->fec.type != FEC_TYPE_IPV4)
1906 continue;
1907 prefix = (union ldpd_addr *)
1908 &fn->fec.u.ipv4.prefix;
1909 plen = fn->fec.u.ipv4.prefixlen;
1910 break;
1911 case FEC_TYPE_IPV6:
1912 if (fn->fec.type != FEC_TYPE_IPV6)
1913 continue;
1914 prefix = (union ldpd_addr *)
1915 &fn->fec.u.ipv6.prefix;
1916 plen = fn->fec.u.ipv6.prefixlen;
1917 break;
1918 default:
1919 continue;
1920 }
1921 if (lde_acl_check(acl_for_filter, af,
1922 prefix, plen) != FILTER_PERMIT) {
1923 me = (struct lde_map *)fec_find(
1924 &ln->sent_map, &fn->fec);
1925 if (me)
1926 /* fec filtered withdraw */
1927 lde_send_labelwithdraw(ln, fn,
1928 NULL, NULL);
1929 } else
1930 /* fec allowed send map */
1931 lde_send_labelmapping(ln, fn, 0);
1932 }
1933 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END,
1934 ln->peerid, 0, NULL, 0);
1935 }
1936 }
1937 }
1938
1939
1940 void
1941 lde_change_accept_filter(int af)
1942 {
1943 struct lde_nbr *ln;
1944 struct fec *f;
1945 struct fec_node *fn;
1946 char *acl_for_filter;
1947 char *acl_from_filter;
1948 union ldpd_addr *prefix;
1949 uint8_t plen;
1950 struct lde_map *me;
1951 enum fec_type type;
1952
1953 /* accept labels from neighbors specified in the from_filter and for
1954 * fecs defined in the for_filter
1955 */
1956 switch (af) {
1957 case AF_INET:
1958 acl_for_filter = ldeconf->ipv4.acl_label_accept_for;
1959 acl_from_filter = ldeconf->ipv4.acl_label_accept_from;
1960 type = FEC_TYPE_IPV4;
1961 break;
1962 case AF_INET6:
1963 acl_for_filter = ldeconf->ipv6.acl_label_accept_for;
1964 acl_from_filter = ldeconf->ipv6.acl_label_accept_from;
1965 type = FEC_TYPE_IPV6;
1966 break;
1967 default:
1968 fatalx("lde_change_accept_filter: unknown af");
1969 }
1970
1971 RB_FOREACH(ln, nbr_tree, &lde_nbrs) {
1972 if (lde_acl_check(acl_from_filter, AF_INET, (union ldpd_addr *)
1973 &ln->id, IPV4_MAX_BITLEN) != FILTER_PERMIT) {
1974 /* This neighbor is now filtered so remove fecs from
1975 * recv list
1976 */
1977 RB_FOREACH(f, fec_tree, &ft) {
1978 fn = (struct fec_node *)f;
1979 if (fn->fec.type == type) {
1980 me = (struct lde_map *)fec_find(
1981 &ln->recv_map, &fn->fec);
1982 if (me)
1983 lde_map_del(ln, me, 0);
1984 }
1985 }
1986 } else if (ln->flags & F_NBR_CAP_TWCARD) {
1987 /* This neighbor is allowed and supports type
1988 * wildcard so send a labelrequest
1989 * to get any new labels from neighbor
1990 * and make sure any fecs we currently have
1991 * match for_filter.
1992 */
1993 RB_FOREACH(f, fec_tree, &ft) {
1994 fn = (struct fec_node *)f;
1995 switch (af) {
1996 case AF_INET:
1997 if (fn->fec.type != FEC_TYPE_IPV4)
1998 continue;
1999 prefix = (union ldpd_addr *)
2000 &fn->fec.u.ipv4.prefix;
2001 plen = fn->fec.u.ipv4.prefixlen;
2002 break;
2003 case AF_INET6:
2004 if (fn->fec.type != FEC_TYPE_IPV6)
2005 continue;
2006 prefix = (union ldpd_addr *)
2007 &fn->fec.u.ipv6.prefix;
2008 plen = fn->fec.u.ipv6.prefixlen;
2009 break;
2010 default:
2011 continue;
2012 }
2013 if (lde_acl_check(acl_for_filter, af,
2014 prefix, plen) != FILTER_PERMIT) {
2015 me = (struct lde_map *)fec_find(
2016 &ln->recv_map, &fn->fec);
2017 if (me)
2018 lde_map_del(ln, me, 0);
2019 }
2020 }
2021 lde_send_labelrequest_wcard(ln, af);
2022 } else
2023 /* Type Wildcard is not supported so restart session */
2024 lde_imsg_compose_ldpe(IMSG_NBR_SHUTDOWN, ln->peerid, 0,
2025 NULL, 0);
2026 }
2027 }
2028
2029 void
2030 lde_change_expnull_for_filter(int af)
2031 {
2032 struct lde_nbr *ln;
2033 struct fec *f;
2034 struct fec_node *fn;
2035 char *acl_name;
2036 uint32_t exp_label;
2037 union ldpd_addr *prefix;
2038 uint8_t plen;
2039
2040 /* Configure explicit-null advertisement for all fecs in this filter */
2041 RB_FOREACH(f, fec_tree, &ft) {
2042 fn = (struct fec_node *)f;
2043
2044 switch (af) {
2045 case AF_INET:
2046 if (fn->fec.type != FEC_TYPE_IPV4)
2047 continue;
2048 acl_name = ldeconf->ipv4.acl_label_expnull_for;
2049 prefix = (union ldpd_addr *)&fn->fec.u.ipv4.prefix;
2050 plen = fn->fec.u.ipv4.prefixlen;
2051 exp_label = MPLS_LABEL_IPV4_EXPLICIT_NULL;
2052 break;
2053 case AF_INET6:
2054 if (fn->fec.type != FEC_TYPE_IPV6)
2055 continue;
2056 acl_name = ldeconf->ipv6.acl_label_expnull_for;
2057 prefix = (union ldpd_addr *)&fn->fec.u.ipv6.prefix;
2058 plen = fn->fec.u.ipv6.prefixlen;
2059 exp_label = MPLS_LABEL_IPV6_EXPLICIT_NULL;
2060 break;
2061 default:
2062 fatalx("lde_change_expnull_for_filter: unknown af");
2063 }
2064
2065 if (lde_acl_check(acl_name, af, prefix, plen) == FILTER_PERMIT) {
2066 /* for this fec change any imp-null to exp-null */
2067 if (fn->local_label == MPLS_LABEL_IMPLICIT_NULL) {
2068 fn->local_label= lde_update_label(fn);
2069 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
2070 lde_send_labelmapping(ln, fn, 0);
2071 }
2072 } else {
2073 /* for this fec change any exp-null back to imp-null */
2074 if (fn->local_label == exp_label) {
2075 fn->local_label = lde_update_label(fn);
2076 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
2077 lde_send_labelmapping(ln, fn, 0);
2078 }
2079 }
2080 }
2081 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
2082 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END, ln->peerid, 0,
2083 NULL, 0);
2084 }
2085
2086 static int
2087 lde_address_add(struct lde_nbr *ln, struct lde_addr *lde_addr)
2088 {
2089 struct lde_addr *new;
2090
2091 if (lde_address_find(ln, lde_addr->af, &lde_addr->addr) != NULL)
2092 return (-1);
2093
2094 if ((new = calloc(1, sizeof(*new))) == NULL)
2095 fatal(__func__);
2096
2097 new->af = lde_addr->af;
2098 new->addr = lde_addr->addr;
2099 TAILQ_INSERT_TAIL(&ln->addr_list, new, entry);
2100
2101 /* reevaluate the previously received mappings from this neighbor */
2102 lde_nbr_addr_update(ln, lde_addr, 0);
2103
2104 return (0);
2105 }
2106
2107 static int
2108 lde_address_del(struct lde_nbr *ln, struct lde_addr *lde_addr)
2109 {
2110 lde_addr = lde_address_find(ln, lde_addr->af, &lde_addr->addr);
2111 if (lde_addr == NULL)
2112 return (-1);
2113
2114 /* reevaluate the previously received mappings from this neighbor */
2115 lde_nbr_addr_update(ln, lde_addr, 1);
2116
2117 TAILQ_REMOVE(&ln->addr_list, lde_addr, entry);
2118 free(lde_addr);
2119
2120 return (0);
2121 }
2122
2123 struct lde_addr *
2124 lde_address_find(struct lde_nbr *ln, int af, union ldpd_addr *addr)
2125 {
2126 struct lde_addr *lde_addr;
2127
2128 TAILQ_FOREACH(lde_addr, &ln->addr_list, entry)
2129 if (lde_addr->af == af &&
2130 ldp_addrcmp(af, &lde_addr->addr, addr) == 0)
2131 return (lde_addr);
2132
2133 return (NULL);
2134 }
2135
2136 static void
2137 lde_address_list_free(struct lde_nbr *ln)
2138 {
2139 struct lde_addr *lde_addr;
2140
2141 while ((lde_addr = TAILQ_POP_FIRST(&ln->addr_list, entry)) != NULL)
2142 free(lde_addr);
2143 }
2144
2145 /*
2146 * Event callback used to retry the label-manager sync zapi session.
2147 */
2148 static int zclient_sync_retry(struct thread *thread)
2149 {
2150 zclient_sync_init();
2151
2152 return 0;
2153 }
2154
2155 /*
2156 * Initialize and open a synchronous zapi session. This is used by label chunk
2157 * management code, which acquires and releases blocks of labels from the
2158 * zebra label-manager module.
2159 */
2160 static void zclient_sync_init(void)
2161 {
2162 struct zclient_options options = zclient_options_default;
2163
2164 options.synchronous = true;
2165
2166 /* Initialize special zclient for synchronous message exchanges. */
2167 zclient_sync = zclient_new(master, &options);
2168 zclient_sync->sock = -1;
2169 zclient_sync->redist_default = ZEBRA_ROUTE_LDP;
2170 zclient_sync->session_id = 1; /* Distinguish from main session */
2171 zclient_sync->privs = &lde_privs;
2172
2173 if (zclient_socket_connect(zclient_sync) < 0) {
2174 log_warnx("Error connecting synchronous zclient!");
2175 goto retry;
2176 }
2177 /* make socket non-blocking */
2178 sock_set_nonblock(zclient_sync->sock);
2179
2180 /* Send hello to notify zebra this is a synchronous client */
2181 if (zclient_send_hello(zclient_sync) == ZCLIENT_SEND_FAILURE) {
2182 log_warnx("Error sending hello for synchronous zclient!");
2183 goto retry;
2184 }
2185
2186 /* Connect to label manager */
2187 if (lm_label_manager_connect(zclient_sync, 0) != 0) {
2188 log_warnx("Error connecting to label manager!");
2189 goto retry;
2190 }
2191
2192 /* Finish label-manager init once the LM session is running */
2193 lde_label_list_init();
2194
2195 return;
2196
2197 retry:
2198
2199 /* Discard failed zclient object */
2200 zclient_stop(zclient_sync);
2201 zclient_free(zclient_sync);
2202 zclient_sync = NULL;
2203
2204 /* Retry using a timer */
2205 thread_add_timer(master, zclient_sync_retry, NULL, 1, NULL);
2206 }
2207
2208 static void
2209 lde_del_label_chunk(void *val)
2210 {
2211 free(val);
2212 }
2213
2214 static int
2215 lde_release_label_chunk(uint32_t start, uint32_t end)
2216 {
2217 int ret;
2218
2219 ret = lm_release_label_chunk(zclient_sync, start, end);
2220 if (ret < 0) {
2221 log_warnx("Error releasing label chunk!");
2222 return (-1);
2223 }
2224 return (0);
2225 }
2226
2227 static int
2228 lde_get_label_chunk(void)
2229 {
2230 int ret;
2231 uint32_t start, end;
2232
2233 debug_labels("getting label chunk (size %u)", CHUNK_SIZE);
2234 ret = lm_get_label_chunk(zclient_sync, 0, MPLS_LABEL_BASE_ANY,
2235 CHUNK_SIZE, &start, &end);
2236 if (ret < 0) {
2237 log_warnx("Error getting label chunk!");
2238 return -1;
2239 }
2240
2241 on_get_label_chunk_response(start, end);
2242
2243 return (0);
2244 }
2245
2246 static void
2247 lde_label_list_init(void)
2248 {
2249 label_chunk_list = list_new();
2250 label_chunk_list->del = lde_del_label_chunk;
2251
2252 /* get first chunk */
2253 while (lde_get_label_chunk () != 0) {
2254 log_warnx("Error getting first label chunk!");
2255 sleep(1);
2256 }
2257 }
2258
2259 static void
2260 on_get_label_chunk_response(uint32_t start, uint32_t end)
2261 {
2262 struct label_chunk *new_label_chunk;
2263
2264 debug_labels("label chunk assign: %u - %u", start, end);
2265
2266 new_label_chunk = calloc(1, sizeof(struct label_chunk));
2267 if (!new_label_chunk) {
2268 log_warn("Error trying to allocate label chunk %u - %u", start, end);
2269 return;
2270 }
2271
2272 new_label_chunk->start = start;
2273 new_label_chunk->end = end;
2274 new_label_chunk->used_mask = 0;
2275
2276 listnode_add(label_chunk_list, (void *)new_label_chunk);
2277
2278 /* let's update current if needed */
2279 if (!current_label_chunk)
2280 current_label_chunk = listtail(label_chunk_list);
2281 }
2282
2283 void
2284 lde_free_label(uint32_t label)
2285 {
2286 struct listnode *node;
2287 struct label_chunk *label_chunk;
2288 uint64_t pos;
2289
2290 for (ALL_LIST_ELEMENTS_RO(label_chunk_list, node, label_chunk)) {
2291 if (label <= label_chunk->end && label >= label_chunk->start) {
2292 pos = 1ULL << (label - label_chunk->start);
2293 label_chunk->used_mask &= ~pos;
2294 /* if nobody is using this chunk and it's not current_label_chunk, then free it */
2295 if (!label_chunk->used_mask && (current_label_chunk != node)) {
2296 if (lde_release_label_chunk(label_chunk->start, label_chunk->end) != 0)
2297 log_warnx("%s: Error releasing label chunk!", __func__);
2298 else {
2299 listnode_delete(label_chunk_list, label_chunk);
2300 lde_del_label_chunk(label_chunk);
2301 }
2302 }
2303 break;
2304 }
2305 }
2306 return;
2307 }
2308
2309 static uint32_t
2310 lde_get_next_label(void)
2311 {
2312 struct label_chunk *label_chunk;
2313 uint32_t i, size;
2314 uint64_t pos;
2315 uint32_t label = NO_LABEL;
2316
2317 while (current_label_chunk) {
2318 label_chunk = listgetdata(current_label_chunk);
2319 if (!label_chunk)
2320 goto end;
2321
2322 /* try to get next free label in currently used label chunk */
2323 size = label_chunk->end - label_chunk->start + 1;
2324 for (i = 0, pos = 1; i < size; i++, pos <<= 1) {
2325 if (!(pos & label_chunk->used_mask)) {
2326 label_chunk->used_mask |= pos;
2327 label = label_chunk->start + i;
2328 goto end;
2329 }
2330 }
2331 current_label_chunk = listnextnode(current_label_chunk);
2332 }
2333
2334 end:
2335 /* we moved till the last chunk, or were not able to find a label,
2336 so let's ask for another one */
2337 if (!current_label_chunk ||
2338 current_label_chunk == listtail(label_chunk_list) ||
2339 label == NO_LABEL) {
2340 if (lde_get_label_chunk() != 0)
2341 log_warn("%s: Error getting label chunk!", __func__);
2342
2343 }
2344
2345 return (label);
2346 }
2347
2348 static void
2349 lde_check_filter_af(int af, struct ldpd_af_conf *af_conf,
2350 const char *filter_name)
2351 {
2352 if (strcmp(af_conf->acl_label_allocate_for, filter_name) == 0)
2353 lde_change_allocate_filter(af);
2354 if ((strcmp(af_conf->acl_label_advertise_to, filter_name) == 0)
2355 || (strcmp(af_conf->acl_label_advertise_for, filter_name) == 0))
2356 lde_change_advertise_filter(af);
2357 if ((strcmp(af_conf->acl_label_accept_for, filter_name) == 0)
2358 || (strcmp(af_conf->acl_label_accept_from, filter_name) == 0))
2359 lde_change_accept_filter(af);
2360 if (strcmp(af_conf->acl_label_expnull_for, filter_name) == 0)
2361 lde_change_expnull_for_filter(af);
2362 }
2363
2364 void lde_route_update(struct iface *iface, int af)
2365 {
2366 struct fec *f;
2367 struct fec_node *fn;
2368 struct fec_nh *fnh;
2369 struct lde_nbr *ln;
2370
2371 /* update label of non-connected routes */
2372 log_debug("update labels for interface %s", iface->name);
2373 RB_FOREACH(f, fec_tree, &ft) {
2374 fn = (struct fec_node *)f;
2375 if (IS_MPLS_UNRESERVED_LABEL(fn->local_label))
2376 continue;
2377
2378 switch (af) {
2379 case AF_INET:
2380 if (fn->fec.type != FEC_TYPE_IPV4)
2381 continue;
2382 break;
2383 case AF_INET6:
2384 if (fn->fec.type != FEC_TYPE_IPV6)
2385 continue;
2386 break;
2387 default:
2388 /* unspecified so process both address families */
2389 break;
2390 }
2391
2392 LIST_FOREACH(fnh, &fn->nexthops, entry) {
2393 /*
2394 * If connected leave existing label. If LDP
2395 * configured on interface or a static route
2396 * may need new label. If no LDP configured
2397 * treat fec as a connected route
2398 */
2399 if (fnh->flags & F_FEC_NH_CONNECTED)
2400 break;
2401
2402 if (fnh->ifindex != iface->ifindex)
2403 continue;
2404
2405 fnh->flags &= ~F_FEC_NH_NO_LDP;
2406 if (IS_MPLS_RESERVED_LABEL(fn->local_label)) {
2407 fn->local_label = NO_LABEL;
2408 fn->local_label = lde_update_label(fn);
2409 if (fn->local_label != NO_LABEL)
2410 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
2411 lde_send_labelmapping(
2412 ln, fn, 0);
2413 }
2414 break;
2415 }
2416 }
2417 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
2418 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END, ln->peerid,
2419 0, NULL, 0);
2420 }
2421
2422 void lde_route_update_release(struct iface *iface, int af)
2423 {
2424 struct lde_nbr *ln;
2425 struct fec *f;
2426 struct fec_node *fn;
2427 struct fec_nh *fnh;
2428
2429 /* update label of interfaces no longer running LDP */
2430 log_debug("release all labels for interface %s af %s", iface->name,
2431 af == AF_INET ? "ipv4" : "ipv6");
2432 RB_FOREACH(f, fec_tree, &ft) {
2433 fn = (struct fec_node *)f;
2434
2435 switch (af) {
2436 case AF_INET:
2437 if (fn->fec.type != FEC_TYPE_IPV4)
2438 continue;
2439 break;
2440 case AF_INET6:
2441 if (fn->fec.type != FEC_TYPE_IPV6)
2442 continue;
2443 break;
2444 default:
2445 fatalx("lde_route_update_release: unknown af");
2446 }
2447
2448 if (fn->local_label == NO_LABEL)
2449 continue;
2450
2451 LIST_FOREACH(fnh, &fn->nexthops, entry) {
2452 /*
2453 * If connected leave existing label. If LDP
2454 * removed from interface may need new label
2455 * and would be treated as a connected route
2456 */
2457 if (fnh->flags & F_FEC_NH_CONNECTED)
2458 break;
2459
2460 if (fnh->ifindex != iface->ifindex)
2461 continue;
2462
2463 fnh->flags |= F_FEC_NH_NO_LDP;
2464 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
2465 lde_send_labelwithdraw(ln, fn, NULL, NULL);
2466 lde_free_label(fn->local_label);
2467 fn->local_label = NO_LABEL;
2468 fn->local_label = lde_update_label(fn);
2469 if (fn->local_label != NO_LABEL)
2470 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
2471 lde_send_labelmapping(ln, fn, 0);
2472 break;
2473 }
2474 }
2475 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
2476 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END, ln->peerid,
2477 0, NULL, 0);
2478 }
2479
2480 void lde_route_update_release_all(int af)
2481 {
2482 struct lde_nbr *ln;
2483 struct fec *f;
2484 struct fec_node *fn;
2485 struct fec_nh *fnh;
2486
2487 /* remove labels from all interfaces as LDP is no longer running for
2488 * this address family
2489 */
2490 log_debug("release all labels for address family %s",
2491 af == AF_INET ? "ipv4" : "ipv6");
2492 RB_FOREACH(f, fec_tree, &ft) {
2493 fn = (struct fec_node *)f;
2494 switch (af) {
2495 case AF_INET:
2496 if (fn->fec.type != FEC_TYPE_IPV4)
2497 continue;
2498 break;
2499 case AF_INET6:
2500 if (fn->fec.type != FEC_TYPE_IPV6)
2501 continue;
2502 break;
2503 default:
2504 fatalx("lde_route_update_release: unknown af");
2505 }
2506
2507 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
2508 lde_send_labelwithdraw(ln, fn, NULL, NULL);
2509
2510 LIST_FOREACH(fnh, &fn->nexthops, entry) {
2511 fnh->flags |= F_FEC_NH_NO_LDP;
2512 lde_send_delete_klabel(fn, fnh);
2513 }
2514 }
2515 }
FRRouting mirror