1 // SPDX-License-Identifier: ISC
5 * Copyright (c) 2013, 2016 Renato Westphal <renato@openbsd.org>
6 * Copyright (c) 2004, 2005 Claudio Jeker <claudio@openbsd.org>
7 * Copyright (c) 2004 Esben Norby <norby@openbsd.org>
8 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
18 #include "ldp_debug.h"
26 #include <lib/linklist.h>
32 static void lde_shutdown(void);
33 static void lde_dispatch_imsg(struct thread
*thread
);
34 static void lde_dispatch_parent(struct thread
*thread
);
35 static __inline
int lde_nbr_compare(const struct lde_nbr
*,
36 const struct lde_nbr
*);
37 static struct lde_nbr
*lde_nbr_new(uint32_t, struct lde_nbr
*);
38 static void lde_nbr_del(struct lde_nbr
*);
39 static struct lde_nbr
*lde_nbr_find(uint32_t);
40 static void lde_nbr_clear(void);
41 static void lde_nbr_addr_update(struct lde_nbr
*,
42 struct lde_addr
*, int);
43 static __inline
int lde_map_compare(const struct lde_map
*,
44 const struct lde_map
*);
45 static void lde_map_free(void *);
46 static int lde_address_add(struct lde_nbr
*, struct lde_addr
*);
47 static int lde_address_del(struct lde_nbr
*, struct lde_addr
*);
48 static void lde_address_list_free(struct lde_nbr
*);
49 static void zclient_sync_init(void);
50 static void lde_label_list_init(void);
51 static int lde_get_label_chunk(void);
52 static void on_get_label_chunk_response(uint32_t start
, uint32_t end
);
53 static uint32_t lde_get_next_label(void);
54 static bool lde_fec_connected(const struct fec_node
*);
55 static bool lde_fec_outside_mpls_network(const struct fec_node
*);
56 static void lde_check_filter_af(int, struct ldpd_af_conf
*,
59 RB_GENERATE(nbr_tree
, lde_nbr
, entry
, lde_nbr_compare
)
60 RB_GENERATE(lde_map_head
, lde_map
, entry
, lde_map_compare
)
62 struct ldpd_conf
*ldeconf
;
63 struct nbr_tree lde_nbrs
= RB_INITIALIZER(&lde_nbrs
);
65 static struct imsgev
*iev_ldpe
;
66 static struct imsgev iev_main_sync_data
;
67 static struct imsgev
*iev_main
, *iev_main_sync
;
70 static zebra_capabilities_t _caps_p
[] =
75 static struct zebra_privs_t lde_privs
=
77 #if defined(VTY_GROUP)
78 .vty_group
= VTY_GROUP
,
81 .cap_num_p
= array_size(_caps_p
),
85 /* List of chunks of labels externally assigned by Zebra */
86 static struct list
*label_chunk_list
;
87 static struct listnode
*current_label_chunk
;
89 /* Synchronous zclient to request labels */
90 static struct zclient
*zclient_sync
;
92 /* SIGINT / SIGTERM handler. */
99 static struct frr_signal_t lde_signals
[] =
115 /* label decision engine */
119 #ifdef HAVE_SETPROCTITLE
120 setproctitle("label decision engine");
122 ldpd_process
= PROC_LDE_ENGINE
;
123 log_procname
= log_procnames
[PROC_LDE_ENGINE
];
126 /* no frr_config_fork() here, allow frr_pthread to create threads */
127 frr_is_after_fork
= true;
129 /* setup signal handler */
130 signal_init(master
, array_size(lde_signals
), lde_signals
);
132 /* setup pipes and event handlers to the parent process */
133 if ((iev_main
= calloc(1, sizeof(struct imsgev
))) == NULL
)
135 imsg_init(&iev_main
->ibuf
, LDPD_FD_ASYNC
);
136 iev_main
->handler_read
= lde_dispatch_parent
;
137 thread_add_read(master
, iev_main
->handler_read
, iev_main
, iev_main
->ibuf
.fd
,
139 iev_main
->handler_write
= ldp_write_handler
;
141 memset(&iev_main_sync_data
, 0, sizeof(iev_main_sync_data
));
142 iev_main_sync
= &iev_main_sync_data
;
143 imsg_init(&iev_main_sync
->ibuf
, LDPD_FD_SYNC
);
145 /* create base configuration */
146 ldeconf
= config_new_empty();
148 struct thread thread
;
149 while (thread_fetch(master
, &thread
))
150 thread_call(&thread
);
157 lde_init(struct ldpd_init
*init
)
159 /* drop privileges */
160 lde_privs
.user
= init
->user
;
161 lde_privs
.group
= init
->group
;
162 zprivs_preinit(&lde_privs
);
163 zprivs_init(&lde_privs
);
165 /* start the LIB garbage collector */
166 lde_gc_start_timer();
168 /* Init synchronous zclient and label list */
169 frr_zclient_addr(&zclient_addr
, &zclient_addr_len
,
170 init
->zclient_serv_path
);
179 msgbuf_clear(&iev_ldpe
->ibuf
.w
);
180 close(iev_ldpe
->ibuf
.fd
);
181 iev_ldpe
->ibuf
.fd
= -1;
183 msgbuf_clear(&iev_main
->ibuf
.w
);
184 close(iev_main
->ibuf
.fd
);
185 iev_main
->ibuf
.fd
= -1;
186 msgbuf_clear(&iev_main_sync
->ibuf
.w
);
187 close(iev_main_sync
->ibuf
.fd
);
188 iev_main_sync
->ibuf
.fd
= -1;
194 config_clear(ldeconf
);
200 log_info("label decision engine exiting");
208 lde_imsg_compose_parent(int type
, pid_t pid
, void *data
, uint16_t datalen
)
210 if (iev_main
->ibuf
.fd
== -1)
212 return (imsg_compose_event(iev_main
, type
, 0, pid
, -1, data
, datalen
));
216 lde_imsg_compose_parent_sync(int type
, pid_t pid
, void *data
, uint16_t datalen
)
218 if (iev_main_sync
->ibuf
.fd
== -1)
220 imsg_compose_event(iev_main_sync
, type
, 0, pid
, -1, data
, datalen
);
221 imsg_flush(&iev_main_sync
->ibuf
);
225 lde_imsg_compose_ldpe(int type
, uint32_t peerid
, pid_t pid
, void *data
,
228 if (iev_ldpe
->ibuf
.fd
== -1)
230 return (imsg_compose_event(iev_ldpe
, type
, peerid
, pid
,
235 static void lde_dispatch_imsg(struct thread
*thread
)
237 struct imsgev
*iev
= THREAD_ARG(thread
);
238 struct imsgbuf
*ibuf
= &iev
->ibuf
;
242 struct lde_addr
*lde_addr
;
243 struct notify_msg
*nm
;
249 if ((n
= imsg_read(ibuf
)) == -1 && errno
!= EAGAIN
)
250 fatal("imsg_read error");
251 if (n
== 0) /* connection closed */
255 if ((n
= imsg_get(ibuf
, &imsg
)) == -1)
256 fatal("lde_dispatch_imsg: imsg_get error");
260 switch (imsg
.hdr
.type
) {
261 case IMSG_LABEL_MAPPING_FULL
:
262 ln
= lde_nbr_find(imsg
.hdr
.peerid
);
264 log_debug("%s: cannot find lde neighbor",
271 case IMSG_LABEL_MAPPING
:
272 case IMSG_LABEL_REQUEST
:
273 case IMSG_LABEL_RELEASE
:
274 case IMSG_LABEL_WITHDRAW
:
275 case IMSG_LABEL_ABORT
:
276 if (imsg
.hdr
.len
- IMSG_HEADER_SIZE
!=
278 fatalx("lde_dispatch_imsg: wrong imsg len");
281 ln
= lde_nbr_find(imsg
.hdr
.peerid
);
283 log_debug("%s: cannot find lde neighbor",
288 switch (imsg
.hdr
.type
) {
289 case IMSG_LABEL_MAPPING
:
290 lde_check_mapping(map
, ln
, 1);
292 case IMSG_LABEL_REQUEST
:
293 lde_check_request(map
, ln
);
295 case IMSG_LABEL_RELEASE
:
296 lde_check_release(map
, ln
);
298 case IMSG_LABEL_WITHDRAW
:
299 lde_check_withdraw(map
, ln
);
301 case IMSG_LABEL_ABORT
:
306 case IMSG_ADDRESS_ADD
:
307 if (imsg
.hdr
.len
- IMSG_HEADER_SIZE
!=
308 sizeof(struct lde_addr
))
309 fatalx("lde_dispatch_imsg: wrong imsg len");
310 lde_addr
= imsg
.data
;
312 ln
= lde_nbr_find(imsg
.hdr
.peerid
);
314 log_debug("%s: cannot find lde neighbor",
318 if (lde_address_add(ln
, lde_addr
) < 0) {
319 log_debug("%s: cannot add address %s, it already exists", __func__
,
320 log_addr(lde_addr
->af
, &lde_addr
->addr
));
323 case IMSG_ADDRESS_DEL
:
324 if (imsg
.hdr
.len
- IMSG_HEADER_SIZE
!=
325 sizeof(struct lde_addr
))
326 fatalx("lde_dispatch_imsg: wrong imsg len");
327 lde_addr
= imsg
.data
;
329 ln
= lde_nbr_find(imsg
.hdr
.peerid
);
331 log_debug("%s: cannot find lde neighbor",
335 if (lde_address_del(ln
, lde_addr
) < 0) {
336 log_debug("%s: cannot delete address %s, it does not exist", __func__
,
337 log_addr(lde_addr
->af
, &lde_addr
->addr
));
340 case IMSG_NOTIFICATION
:
341 if (imsg
.hdr
.len
- IMSG_HEADER_SIZE
!=
342 sizeof(struct notify_msg
))
343 fatalx("lde_dispatch_imsg: wrong imsg len");
346 ln
= lde_nbr_find(imsg
.hdr
.peerid
);
348 log_debug("%s: cannot find lde neighbor",
353 switch (nm
->status_code
) {
355 l2vpn_recv_pw_status(ln
, nm
);
359 * Do nothing for now. Should be useful in
360 * the future when we implement LDP-IGP
361 * Synchronization (RFC 5443) and Graceful
362 * Restart (RFC 3478).
368 case IMSG_NEIGHBOR_UP
:
369 if (imsg
.hdr
.len
- IMSG_HEADER_SIZE
!=
370 sizeof(struct lde_nbr
))
371 fatalx("lde_dispatch_imsg: wrong imsg len");
373 if (lde_nbr_find(imsg
.hdr
.peerid
))
374 fatalx("lde_dispatch_imsg: neighbor already exists");
375 lde_nbr_new(imsg
.hdr
.peerid
, imsg
.data
);
377 case IMSG_NEIGHBOR_DOWN
:
378 lde_nbr_del(lde_nbr_find(imsg
.hdr
.peerid
));
380 case IMSG_CTL_SHOW_LIB
:
381 rt_dump(imsg
.hdr
.pid
);
383 lde_imsg_compose_ldpe(IMSG_CTL_END
, 0,
384 imsg
.hdr
.pid
, NULL
, 0);
386 case IMSG_CTL_SHOW_L2VPN_PW
:
387 l2vpn_pw_ctl(imsg
.hdr
.pid
);
389 lde_imsg_compose_ldpe(IMSG_CTL_END
, 0,
390 imsg
.hdr
.pid
, NULL
, 0);
392 case IMSG_CTL_SHOW_L2VPN_BINDING
:
393 l2vpn_binding_ctl(imsg
.hdr
.pid
);
395 lde_imsg_compose_ldpe(IMSG_CTL_END
, 0,
396 imsg
.hdr
.pid
, NULL
, 0);
399 log_debug("%s: unexpected imsg %d", __func__
,
408 /* this pipe is dead, so remove the event handlers and exit */
409 THREAD_OFF(iev
->ev_read
);
410 THREAD_OFF(iev
->ev_write
);
416 static void lde_dispatch_parent(struct thread
*thread
)
418 static struct ldpd_conf
*nconf
;
419 struct iface
*iface
, *niface
;
421 struct nbr_params
*nnbrp
;
422 static struct l2vpn
*l2vpn
, *nl2vpn
;
423 struct l2vpn_if
*lif
, *nlif
;
424 struct l2vpn_pw
*pw
, *npw
;
429 struct imsgev
*iev
= THREAD_ARG(thread
);
430 struct imsgbuf
*ibuf
= &iev
->ibuf
;
434 struct ldp_access
*laccess
;
435 struct ldp_rlfa_node
*rnode
, *rntmp
;
436 struct ldp_rlfa_client
*rclient
;
437 struct zapi_rlfa_request
*rlfa_req
;
438 struct zapi_rlfa_igp
*rlfa_igp
;
442 if ((n
= imsg_read(ibuf
)) == -1 && errno
!= EAGAIN
)
443 fatal("imsg_read error");
444 if (n
== 0) /* connection closed */
448 if ((n
= imsg_get(ibuf
, &imsg
)) == -1)
449 fatal("lde_dispatch_parent: imsg_get error");
453 switch (imsg
.hdr
.type
) {
455 if (imsg
.hdr
.len
!= IMSG_HEADER_SIZE
+
457 fatalx("IFSTATUS imsg with wrong len");
460 iface
= if_lookup_name(ldeconf
, kif
->ifname
);
462 if_update_info(iface
, kif
);
464 /* if up see if any labels need to be updated */
466 lde_route_update(iface
, AF_UNSPEC
);
470 RB_FOREACH(l2vpn
, l2vpn_head
, &ldeconf
->l2vpn_tree
) {
471 lif
= l2vpn_if_find(l2vpn
, kif
->ifname
);
473 l2vpn_if_update_info(lif
, kif
);
476 pw
= l2vpn_pw_find(l2vpn
, kif
->ifname
);
478 l2vpn_pw_update_info(pw
, kif
);
484 if (imsg
.hdr
.len
!= IMSG_HEADER_SIZE
+
485 sizeof(struct zapi_pw_status
))
486 fatalx("PW_UPDATE imsg with wrong len");
488 if (l2vpn_pw_status_update(imsg
.data
) != 0)
489 log_warnx("%s: error updating PW status",
492 case IMSG_NETWORK_ADD
:
493 case IMSG_NETWORK_UPDATE
:
494 if (imsg
.hdr
.len
!= IMSG_HEADER_SIZE
+
495 sizeof(struct kroute
)) {
496 log_warnx("%s: wrong imsg len", __func__
);
503 fec
.type
= FEC_TYPE_IPV4
;
504 fec
.u
.ipv4
.prefix
= kr
->prefix
.v4
;
505 fec
.u
.ipv4
.prefixlen
= kr
->prefixlen
;
508 fec
.type
= FEC_TYPE_IPV6
;
509 fec
.u
.ipv6
.prefix
= kr
->prefix
.v6
;
510 fec
.u
.ipv6
.prefixlen
= kr
->prefixlen
;
513 fatalx("lde_dispatch_parent: unknown af");
516 switch (imsg
.hdr
.type
) {
517 case IMSG_NETWORK_ADD
:
518 lde_kernel_insert(&fec
, kr
->af
, &kr
->nexthop
,
519 kr
->ifindex
, kr
->route_type
,
521 kr
->flags
& F_CONNECTED
, NULL
);
523 case IMSG_NETWORK_UPDATE
:
524 lde_kernel_update(&fec
);
528 case IMSG_SOCKET_IPC
:
530 log_warnx("%s: received unexpected imsg fd to ldpe", __func__
);
533 if ((fd
= imsg
.fd
) == -1) {
534 log_warnx("%s: expected to receive imsg fd to ldpe but didn't receive any", __func__
);
538 if ((iev_ldpe
= malloc(sizeof(struct imsgev
))) == NULL
)
540 imsg_init(&iev_ldpe
->ibuf
, fd
);
541 iev_ldpe
->handler_read
= lde_dispatch_imsg
;
542 thread_add_read(master
, iev_ldpe
->handler_read
, iev_ldpe
, iev_ldpe
->ibuf
.fd
,
544 iev_ldpe
->handler_write
= ldp_write_handler
;
545 iev_ldpe
->ev_write
= NULL
;
548 if (imsg
.hdr
.len
!= IMSG_HEADER_SIZE
+
549 sizeof(struct ldpd_init
))
550 fatalx("INIT imsg with wrong len");
552 memcpy(&init
, imsg
.data
, sizeof(init
));
555 case IMSG_AGENTX_ENABLED
:
556 ldp_agentx_enabled();
558 case IMSG_RECONF_CONF
:
559 if ((nconf
= malloc(sizeof(struct ldpd_conf
))) ==
562 memcpy(nconf
, imsg
.data
, sizeof(struct ldpd_conf
));
564 RB_INIT(iface_head
, &nconf
->iface_tree
);
565 RB_INIT(tnbr_head
, &nconf
->tnbr_tree
);
566 RB_INIT(nbrp_head
, &nconf
->nbrp_tree
);
567 RB_INIT(l2vpn_head
, &nconf
->l2vpn_tree
);
569 case IMSG_RECONF_IFACE
:
570 if ((niface
= malloc(sizeof(struct iface
))) == NULL
)
572 memcpy(niface
, imsg
.data
, sizeof(struct iface
));
574 RB_INSERT(iface_head
, &nconf
->iface_tree
, niface
);
576 case IMSG_RECONF_TNBR
:
577 if ((ntnbr
= malloc(sizeof(struct tnbr
))) == NULL
)
579 memcpy(ntnbr
, imsg
.data
, sizeof(struct tnbr
));
581 RB_INSERT(tnbr_head
, &nconf
->tnbr_tree
, ntnbr
);
583 case IMSG_RECONF_NBRP
:
584 if ((nnbrp
= malloc(sizeof(struct nbr_params
))) == NULL
)
586 memcpy(nnbrp
, imsg
.data
, sizeof(struct nbr_params
));
588 RB_INSERT(nbrp_head
, &nconf
->nbrp_tree
, nnbrp
);
590 case IMSG_RECONF_L2VPN
:
591 if ((nl2vpn
= malloc(sizeof(struct l2vpn
))) == NULL
)
593 memcpy(nl2vpn
, imsg
.data
, sizeof(struct l2vpn
));
595 RB_INIT(l2vpn_if_head
, &nl2vpn
->if_tree
);
596 RB_INIT(l2vpn_pw_head
, &nl2vpn
->pw_tree
);
597 RB_INIT(l2vpn_pw_head
, &nl2vpn
->pw_inactive_tree
);
599 RB_INSERT(l2vpn_head
, &nconf
->l2vpn_tree
, nl2vpn
);
601 case IMSG_RECONF_L2VPN_IF
:
602 if ((nlif
= malloc(sizeof(struct l2vpn_if
))) == NULL
)
604 memcpy(nlif
, imsg
.data
, sizeof(struct l2vpn_if
));
606 RB_INSERT(l2vpn_if_head
, &nl2vpn
->if_tree
, nlif
);
608 case IMSG_RECONF_L2VPN_PW
:
609 if ((npw
= malloc(sizeof(struct l2vpn_pw
))) == NULL
)
611 memcpy(npw
, imsg
.data
, sizeof(struct l2vpn_pw
));
613 RB_INSERT(l2vpn_pw_head
, &nl2vpn
->pw_tree
, npw
);
615 case IMSG_RECONF_L2VPN_IPW
:
616 if ((npw
= malloc(sizeof(struct l2vpn_pw
))) == NULL
)
618 memcpy(npw
, imsg
.data
, sizeof(struct l2vpn_pw
));
620 RB_INSERT(l2vpn_pw_head
, &nl2vpn
->pw_inactive_tree
, npw
);
622 case IMSG_RECONF_END
:
623 merge_config(ldeconf
, nconf
);
624 ldp_clear_config(nconf
);
627 case IMSG_DEBUG_UPDATE
:
628 if (imsg
.hdr
.len
!= IMSG_HEADER_SIZE
+
630 log_warnx("%s: wrong imsg len", __func__
);
633 memcpy(&ldp_debug
, imsg
.data
, sizeof(ldp_debug
));
635 case IMSG_FILTER_UPDATE
:
636 if (imsg
.hdr
.len
!= IMSG_HEADER_SIZE
+
637 sizeof(struct ldp_access
)) {
638 log_warnx("%s: wrong imsg len", __func__
);
642 lde_check_filter_af(AF_INET
, &ldeconf
->ipv4
,
644 lde_check_filter_af(AF_INET6
, &ldeconf
->ipv6
,
648 if (imsg
.hdr
.len
!= IMSG_HEADER_SIZE
+
649 sizeof(struct zapi_rlfa_request
)) {
650 log_warnx("%s: wrong imsg len", __func__
);
653 rlfa_req
= imsg
.data
;
654 rnode
= rlfa_node_find(&rlfa_req
->destination
,
655 rlfa_req
->pq_address
);
657 rnode
= rlfa_node_new(&rlfa_req
->destination
,
658 rlfa_req
->pq_address
);
659 rclient
= rlfa_client_find(rnode
, &rlfa_req
->igp
);
661 /* RLFA already registered - do nothing */
663 rclient
= rlfa_client_new(rnode
, &rlfa_req
->igp
);
664 lde_rlfa_check(rclient
);
666 case IMSG_RLFA_UNREG_ALL
:
667 if (imsg
.hdr
.len
!= IMSG_HEADER_SIZE
+
668 sizeof(struct zapi_rlfa_igp
)) {
669 log_warnx("%s: wrong imsg len", __func__
);
672 rlfa_igp
= imsg
.data
;
674 RB_FOREACH_SAFE (rnode
, ldp_rlfa_node_head
,
675 &rlfa_node_tree
, rntmp
) {
676 rclient
= rlfa_client_find(rnode
, rlfa_igp
);
680 rlfa_client_del(rclient
);
684 log_debug("%s: unexpected imsg %d", __func__
,
693 /* this pipe is dead, so remove the event handlers and exit */
694 THREAD_OFF(iev
->ev_read
);
695 THREAD_OFF(iev
->ev_write
);
701 lde_acl_check(char *acl_name
, int af
, union ldpd_addr
*addr
, uint8_t prefixlen
)
703 return ldp_acl_request(iev_main_sync
, acl_name
, af
, addr
, prefixlen
);
706 static bool lde_fec_connected(const struct fec_node
*fn
)
710 LIST_FOREACH(fnh
, &fn
->nexthops
, entry
)
711 if (fnh
->flags
& F_FEC_NH_CONNECTED
)
717 static bool lde_fec_outside_mpls_network(const struct fec_node
*fn
)
721 LIST_FOREACH(fnh
, &fn
->nexthops
, entry
)
722 if (!(fnh
->flags
& F_FEC_NH_NO_LDP
))
729 lde_update_label(struct fec_node
*fn
)
732 /* should we allocate a label for this fec? */
733 switch (fn
->fec
.type
) {
735 if ((ldeconf
->ipv4
.flags
& F_LDPD_AF_ALLOCHOSTONLY
)
736 && fn
->fec
.u
.ipv4
.prefixlen
!= IPV4_MAX_BITLEN
)
738 if (lde_acl_check(ldeconf
->ipv4
.acl_label_allocate_for
,
739 AF_INET
, (union ldpd_addr
*)&fn
->fec
.u
.ipv4
.prefix
,
740 fn
->fec
.u
.ipv4
.prefixlen
) != FILTER_PERMIT
)
744 if ((ldeconf
->ipv6
.flags
& F_LDPD_AF_ALLOCHOSTONLY
)
745 && fn
->fec
.u
.ipv6
.prefixlen
!= IPV6_MAX_BITLEN
)
747 if (lde_acl_check(ldeconf
->ipv6
.acl_label_allocate_for
,
748 AF_INET6
, (union ldpd_addr
*)&fn
->fec
.u
.ipv6
.prefix
,
749 fn
->fec
.u
.ipv6
.prefixlen
) != FILTER_PERMIT
)
757 * If connected interface act as egress for fec.
758 * If LDP is not configured on an interface but there
759 * are other NHs with interfaces configured with LDP
760 * then don't act as an egress for the fec, otherwise
761 * act as an egress for the fec
763 if (lde_fec_connected(fn
) || lde_fec_outside_mpls_network(fn
)) {
764 /* choose implicit or explicit-null depending on configuration */
765 switch (fn
->fec
.type
) {
767 if (!(ldeconf
->ipv4
.flags
& F_LDPD_AF_EXPNULL
))
768 return (MPLS_LABEL_IMPLICIT_NULL
);
769 if (lde_acl_check(ldeconf
->ipv4
.acl_label_expnull_for
,
770 AF_INET
, (union ldpd_addr
*)&fn
->fec
.u
.ipv4
.prefix
,
771 fn
->fec
.u
.ipv4
.prefixlen
) != FILTER_PERMIT
)
772 return (MPLS_LABEL_IMPLICIT_NULL
);
773 return MPLS_LABEL_IPV4_EXPLICIT_NULL
;
775 if (!(ldeconf
->ipv6
.flags
& F_LDPD_AF_EXPNULL
))
776 return (MPLS_LABEL_IMPLICIT_NULL
);
777 if (lde_acl_check(ldeconf
->ipv6
.acl_label_expnull_for
,
778 AF_INET6
, (union ldpd_addr
*)&fn
->fec
.u
.ipv6
.prefix
,
779 fn
->fec
.u
.ipv6
.prefixlen
) != FILTER_PERMIT
)
780 return (MPLS_LABEL_IMPLICIT_NULL
);
781 return MPLS_LABEL_IPV6_EXPLICIT_NULL
;
787 /* preserve current label if there's no need to update it */
788 if (fn
->local_label
!= NO_LABEL
&&
789 fn
->local_label
> MPLS_LABEL_RESERVED_MAX
)
790 return (fn
->local_label
);
792 return (lde_get_next_label());
796 lde_send_change_klabel(struct fec_node
*fn
, struct fec_nh
*fnh
)
803 * Ordered Control: don't program label into HW until a
804 * labelmap msg has been received from upstream router
806 if (fnh
->flags
& F_FEC_NH_DEFER
)
809 switch (fn
->fec
.type
) {
811 memset(&kr
, 0, sizeof(kr
));
813 kr
.prefix
.v4
= fn
->fec
.u
.ipv4
.prefix
;
814 kr
.prefixlen
= fn
->fec
.u
.ipv4
.prefixlen
;
815 kr
.nexthop
.v4
= fnh
->nexthop
.v4
;
816 kr
.ifindex
= fnh
->ifindex
;
817 kr
.local_label
= fn
->local_label
;
818 kr
.remote_label
= fnh
->remote_label
;
819 kr
.route_type
= fnh
->route_type
;
820 kr
.route_instance
= fnh
->route_instance
;
821 lde_imsg_compose_parent(IMSG_KLABEL_CHANGE
, 0, &kr
,
825 memset(&kr
, 0, sizeof(kr
));
827 kr
.prefix
.v6
= fn
->fec
.u
.ipv6
.prefix
;
828 kr
.prefixlen
= fn
->fec
.u
.ipv6
.prefixlen
;
829 kr
.nexthop
.v6
= fnh
->nexthop
.v6
;
830 kr
.ifindex
= fnh
->ifindex
;
831 kr
.local_label
= fn
->local_label
;
832 kr
.remote_label
= fnh
->remote_label
;
833 kr
.route_type
= fnh
->route_type
;
834 kr
.route_instance
= fnh
->route_instance
;
836 lde_imsg_compose_parent(IMSG_KLABEL_CHANGE
, 0, &kr
,
840 pw
= (struct l2vpn_pw
*) fn
->data
;
841 if (!pw
|| fn
->local_label
== NO_LABEL
||
842 fnh
->remote_label
== NO_LABEL
)
847 zpw
.local_label
= fn
->local_label
;
848 zpw
.remote_label
= fnh
->remote_label
;
849 lde_imsg_compose_parent(IMSG_KPW_SET
, 0, &zpw
, sizeof(zpw
));
855 lde_send_delete_klabel(struct fec_node
*fn
, struct fec_nh
*fnh
)
861 switch (fn
->fec
.type
) {
863 memset(&kr
, 0, sizeof(kr
));
865 kr
.prefix
.v4
= fn
->fec
.u
.ipv4
.prefix
;
866 kr
.prefixlen
= fn
->fec
.u
.ipv4
.prefixlen
;
867 kr
.nexthop
.v4
= fnh
->nexthop
.v4
;
868 kr
.ifindex
= fnh
->ifindex
;
869 kr
.local_label
= fn
->local_label
;
870 kr
.remote_label
= fnh
->remote_label
;
871 kr
.route_type
= fnh
->route_type
;
872 kr
.route_instance
= fnh
->route_instance
;
874 lde_imsg_compose_parent(IMSG_KLABEL_DELETE
, 0, &kr
,
878 memset(&kr
, 0, sizeof(kr
));
880 kr
.prefix
.v6
= fn
->fec
.u
.ipv6
.prefix
;
881 kr
.prefixlen
= fn
->fec
.u
.ipv6
.prefixlen
;
882 kr
.nexthop
.v6
= fnh
->nexthop
.v6
;
883 kr
.ifindex
= fnh
->ifindex
;
884 kr
.local_label
= fn
->local_label
;
885 kr
.remote_label
= fnh
->remote_label
;
886 kr
.route_type
= fnh
->route_type
;
887 kr
.route_instance
= fnh
->route_instance
;
889 lde_imsg_compose_parent(IMSG_KLABEL_DELETE
, 0, &kr
,
893 pw
= (struct l2vpn_pw
*) fn
->data
;
899 zpw
.local_label
= fn
->local_label
;
900 zpw
.remote_label
= fnh
->remote_label
;
901 lde_imsg_compose_parent(IMSG_KPW_UNSET
, 0, &zpw
, sizeof(zpw
));
907 lde_fec2prefix(const struct fec
*fec
, struct prefix
*prefix
)
909 memset(prefix
, 0, sizeof(*prefix
));
912 prefix
->family
= AF_INET
;
913 prefix
->u
.prefix4
= fec
->u
.ipv4
.prefix
;
914 prefix
->prefixlen
= fec
->u
.ipv4
.prefixlen
;
917 prefix
->family
= AF_INET6
;
918 prefix
->u
.prefix6
= fec
->u
.ipv6
.prefix
;
919 prefix
->prefixlen
= fec
->u
.ipv6
.prefixlen
;
922 prefix
->family
= AF_UNSPEC
;
928 lde_prefix2fec(const struct prefix
*prefix
, struct fec
*fec
)
930 memset(fec
, 0, sizeof(*fec
));
931 switch (prefix
->family
) {
933 fec
->type
= FEC_TYPE_IPV4
;
934 fec
->u
.ipv4
.prefix
= prefix
->u
.prefix4
;
935 fec
->u
.ipv4
.prefixlen
= prefix
->prefixlen
;
938 fec
->type
= FEC_TYPE_IPV6
;
939 fec
->u
.ipv6
.prefix
= prefix
->u
.prefix6
;
940 fec
->u
.ipv6
.prefixlen
= prefix
->prefixlen
;
943 fatalx("lde_prefix2fec: unknown af");
949 lde_fec2map(struct fec
*fec
, struct map
*map
)
951 memset(map
, 0, sizeof(*map
));
955 map
->type
= MAP_TYPE_PREFIX
;
956 map
->fec
.prefix
.af
= AF_INET
;
957 map
->fec
.prefix
.prefix
.v4
= fec
->u
.ipv4
.prefix
;
958 map
->fec
.prefix
.prefixlen
= fec
->u
.ipv4
.prefixlen
;
961 map
->type
= MAP_TYPE_PREFIX
;
962 map
->fec
.prefix
.af
= AF_INET6
;
963 map
->fec
.prefix
.prefix
.v6
= fec
->u
.ipv6
.prefix
;
964 map
->fec
.prefix
.prefixlen
= fec
->u
.ipv6
.prefixlen
;
967 map
->type
= MAP_TYPE_PWID
;
968 map
->fec
.pwid
.type
= fec
->u
.pwid
.type
;
969 map
->fec
.pwid
.group_id
= 0;
970 map
->flags
|= F_MAP_PW_ID
;
971 map
->fec
.pwid
.pwid
= fec
->u
.pwid
.pwid
;
977 lde_map2fec(struct map
*map
, struct in_addr lsr_id
, struct fec
*fec
)
979 memset(fec
, 0, sizeof(*fec
));
982 case MAP_TYPE_PREFIX
:
983 switch (map
->fec
.prefix
.af
) {
985 fec
->type
= FEC_TYPE_IPV4
;
986 fec
->u
.ipv4
.prefix
= map
->fec
.prefix
.prefix
.v4
;
987 fec
->u
.ipv4
.prefixlen
= map
->fec
.prefix
.prefixlen
;
990 fec
->type
= FEC_TYPE_IPV6
;
991 fec
->u
.ipv6
.prefix
= map
->fec
.prefix
.prefix
.v6
;
992 fec
->u
.ipv6
.prefixlen
= map
->fec
.prefix
.prefixlen
;
995 fatalx("lde_map2fec: unknown af");
1000 fec
->type
= FEC_TYPE_PWID
;
1001 fec
->u
.pwid
.type
= map
->fec
.pwid
.type
;
1002 fec
->u
.pwid
.pwid
= map
->fec
.pwid
.pwid
;
1003 fec
->u
.pwid
.lsr_id
= lsr_id
;
1009 lde_send_labelmapping(struct lde_nbr
*ln
, struct fec_node
*fn
, int single
)
1011 struct lde_wdraw
*lw
;
1013 struct lde_req
*lre
;
1015 struct l2vpn_pw
*pw
;
1020 * Ordered Control: do not send a labelmap msg until
1021 * a labelmap message is received from downstream router
1022 * and don't send labelmap back to downstream router
1024 if (ldeconf
->flags
& F_LDPD_ORDERED_CONTROL
) {
1025 LIST_FOREACH(fnh
, &fn
->nexthops
, entry
) {
1026 if (fnh
->flags
& F_FEC_NH_DEFER
)
1029 if (lde_address_find(ln
, fnh
->af
, &fnh
->nexthop
))
1039 * We shouldn't send a new label mapping if we have a pending
1040 * label release to receive. In this case, schedule to send a
1041 * label mapping as soon as a label release is received.
1043 lw
= (struct lde_wdraw
*)fec_find(&ln
->sent_wdraw
, &fn
->fec
);
1045 if (!fec_find(&ln
->sent_map_pending
, &fn
->fec
)) {
1046 debug_evt("%s: FEC %s: scheduling to send label mapping later (waiting for pending label release)",
1047 __func__
, log_fec(&fn
->fec
));
1048 lde_map_pending_add(ln
, fn
);
1054 * This function skips SL.1 - 3 and SL.9 - 14 because the label
1055 * allocation is done way earlier (because of the merging nature of
1059 lde_fec2map(&fn
->fec
, &map
);
1060 switch (fn
->fec
.type
) {
1062 if (!ln
->v4_enabled
)
1064 if (lde_acl_check(ldeconf
->ipv4
.acl_label_advertise_to
,
1065 AF_INET
, (union ldpd_addr
*)&ln
->id
, 32) != FILTER_PERMIT
)
1067 if (lde_acl_check(ldeconf
->ipv4
.acl_label_advertise_for
,
1068 AF_INET
, (union ldpd_addr
*)&fn
->fec
.u
.ipv4
.prefix
,
1069 fn
->fec
.u
.ipv4
.prefixlen
) != FILTER_PERMIT
)
1073 if (!ln
->v6_enabled
)
1075 if (lde_acl_check(ldeconf
->ipv6
.acl_label_advertise_to
,
1076 AF_INET
, (union ldpd_addr
*)&ln
->id
, 32) != FILTER_PERMIT
)
1078 if (lde_acl_check(ldeconf
->ipv6
.acl_label_advertise_for
,
1079 AF_INET6
, (union ldpd_addr
*)&fn
->fec
.u
.ipv6
.prefix
,
1080 fn
->fec
.u
.ipv6
.prefixlen
) != FILTER_PERMIT
)
1084 pw
= (struct l2vpn_pw
*) fn
->data
;
1085 if (pw
== NULL
|| pw
->lsr_id
.s_addr
!= ln
->id
.s_addr
)
1086 /* not the remote end of the pseudowire */
1089 map
.flags
|= F_MAP_PW_IFMTU
;
1090 map
.fec
.pwid
.ifmtu
= pw
->l2vpn
->mtu
;
1091 if (pw
->flags
& F_PW_CWORD
)
1092 map
.flags
|= F_MAP_PW_CWORD
;
1093 if (pw
->flags
& F_PW_STATUSTLV
) {
1094 map
.flags
|= F_MAP_PW_STATUS
;
1095 map
.pw_status
= pw
->local_status
;
1099 map
.label
= fn
->local_label
;
1101 /* SL.6: is there a pending request for this mapping? */
1102 lre
= (struct lde_req
*)fec_find(&ln
->recv_req
, &fn
->fec
);
1104 /* set label request msg id in the mapping response. */
1105 map
.requestid
= lre
->msg_id
;
1106 map
.flags
= F_MAP_REQ_ID
;
1108 /* SL.7: delete record of pending request */
1109 lde_req_del(ln
, lre
, 0);
1112 /* SL.4: send label mapping */
1113 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD
, ln
->peerid
, 0,
1116 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END
, ln
->peerid
, 0,
1119 /* SL.5: record sent label mapping */
1120 me
= (struct lde_map
*)fec_find(&ln
->sent_map
, &fn
->fec
);
1122 me
= lde_map_add(ln
, fn
, 1);
1127 lde_send_labelwithdraw(struct lde_nbr
*ln
, struct fec_node
*fn
,
1128 struct map
*wcard
, struct status_tlv
*st
)
1130 struct lde_wdraw
*lw
;
1133 struct l2vpn_pw
*pw
;
1136 lde_fec2map(&fn
->fec
, &map
);
1137 switch (fn
->fec
.type
) {
1139 if (!ln
->v4_enabled
)
1143 if (!ln
->v6_enabled
)
1147 pw
= (struct l2vpn_pw
*) fn
->data
;
1148 if (pw
== NULL
|| pw
->lsr_id
.s_addr
!= ln
->id
.s_addr
)
1149 /* not the remote end of the pseudowire */
1152 if (pw
->flags
& F_PW_CWORD
)
1153 map
.flags
|= F_MAP_PW_CWORD
;
1156 map
.label
= fn
->local_label
;
1158 memcpy(&map
, wcard
, sizeof(map
));
1161 map
.st
.status_code
= st
->status_code
;
1162 map
.st
.msg_id
= st
->msg_id
;
1163 map
.st
.msg_type
= st
->msg_type
;
1164 map
.flags
|= F_MAP_STATUS
;
1167 /* SWd.1: send label withdraw. */
1168 lde_imsg_compose_ldpe(IMSG_WITHDRAW_ADD
, ln
->peerid
, 0,
1170 lde_imsg_compose_ldpe(IMSG_WITHDRAW_ADD_END
, ln
->peerid
, 0, NULL
, 0);
1172 /* SWd.2: record label withdraw. */
1174 lw
= (struct lde_wdraw
*)fec_find(&ln
->sent_wdraw
, &fn
->fec
);
1176 lw
= lde_wdraw_add(ln
, fn
);
1177 lw
->label
= map
.label
;
1181 RB_FOREACH(f
, fec_tree
, &ft
) {
1182 fn
= (struct fec_node
*)f
;
1183 me
= (struct lde_map
*)fec_find(&ln
->sent_map
, &fn
->fec
);
1184 if (lde_wildcard_apply(wcard
, &fn
->fec
, me
) == 0)
1187 lw
= (struct lde_wdraw
*)fec_find(&ln
->sent_wdraw
,
1190 lw
= lde_wdraw_add(ln
, fn
);
1191 lw
->label
= map
.label
;
1197 lde_send_labelwithdraw_wcard(struct lde_nbr
*ln
, uint32_t label
)
1201 memset(&wcard
, 0, sizeof(wcard
));
1202 wcard
.type
= MAP_TYPE_WILDCARD
;
1203 wcard
.label
= label
;
1204 lde_send_labelwithdraw(ln
, NULL
, &wcard
, NULL
);
1208 lde_send_labelwithdraw_twcard_prefix(struct lde_nbr
*ln
, uint16_t af
,
1213 memset(&wcard
, 0, sizeof(wcard
));
1214 wcard
.type
= MAP_TYPE_TYPED_WCARD
;
1215 wcard
.fec
.twcard
.type
= MAP_TYPE_PREFIX
;
1216 wcard
.fec
.twcard
.u
.prefix_af
= af
;
1217 wcard
.label
= label
;
1218 lde_send_labelwithdraw(ln
, NULL
, &wcard
, NULL
);
1222 lde_send_labelwithdraw_twcard_pwid(struct lde_nbr
*ln
, uint16_t pw_type
,
1227 memset(&wcard
, 0, sizeof(wcard
));
1228 wcard
.type
= MAP_TYPE_TYPED_WCARD
;
1229 wcard
.fec
.twcard
.type
= MAP_TYPE_PWID
;
1230 wcard
.fec
.twcard
.u
.pw_type
= pw_type
;
1231 wcard
.label
= label
;
1232 lde_send_labelwithdraw(ln
, NULL
, &wcard
, NULL
);
1236 lde_send_labelwithdraw_pwid_wcard(struct lde_nbr
*ln
, uint16_t pw_type
,
1241 memset(&wcard
, 0, sizeof(wcard
));
1242 wcard
.type
= MAP_TYPE_PWID
;
1243 wcard
.fec
.pwid
.type
= pw_type
;
1244 wcard
.fec
.pwid
.group_id
= group_id
;
1245 /* we can not append a Label TLV when using PWid group wildcards. */
1246 wcard
.label
= NO_LABEL
;
1247 lde_send_labelwithdraw(ln
, NULL
, &wcard
, NULL
);
1251 lde_send_labelrelease(struct lde_nbr
*ln
, struct fec_node
*fn
,
1252 struct map
*wcard
, uint32_t label
)
1255 struct l2vpn_pw
*pw
;
1258 lde_fec2map(&fn
->fec
, &map
);
1259 switch (fn
->fec
.type
) {
1261 if (!ln
->v4_enabled
)
1265 if (!ln
->v6_enabled
)
1269 pw
= (struct l2vpn_pw
*) fn
->data
;
1270 if (pw
== NULL
|| pw
->lsr_id
.s_addr
!= ln
->id
.s_addr
)
1271 /* not the remote end of the pseudowire */
1274 if (pw
->flags
& F_PW_CWORD
)
1275 map
.flags
|= F_MAP_PW_CWORD
;
1279 memcpy(&map
, wcard
, sizeof(map
));
1282 lde_imsg_compose_ldpe(IMSG_RELEASE_ADD
, ln
->peerid
, 0,
1284 lde_imsg_compose_ldpe(IMSG_RELEASE_ADD_END
, ln
->peerid
, 0, NULL
, 0);
1288 lde_send_labelrequest(struct lde_nbr
*ln
, struct fec_node
*fn
,
1289 struct map
*wcard
, int single
)
1293 struct lde_req
*lre
;
1296 lde_fec2map(&fn
->fec
, &map
);
1297 switch (fn
->fec
.type
) {
1299 if (!ln
->v4_enabled
)
1303 if (!ln
->v6_enabled
)
1307 fatalx("lde_send_labelrequest: unknown af");
1310 memcpy(&map
, wcard
, sizeof(map
));
1312 map
.label
= NO_LABEL
;
1315 /* SLR1.1: has label request for FEC been previously sent
1316 * and still outstanding just return,
1318 lre
= (struct lde_req
*)fec_find(&ln
->sent_req
, &fn
->fec
);
1320 /* SLRq.3: send label request */
1321 lde_imsg_compose_ldpe(IMSG_REQUEST_ADD
, ln
->peerid
, 0,
1324 lde_imsg_compose_ldpe(IMSG_REQUEST_ADD_END
,
1325 ln
->peerid
, 0, NULL
, 0);
1327 /* SLRq.4: record sent request */
1328 lde_req_add(ln
, &fn
->fec
, 1);
1331 /* if Wilcard just send label request */
1332 /* SLRq.3: send label request */
1333 lde_imsg_compose_ldpe(IMSG_REQUEST_ADD
,
1334 ln
->peerid
, 0, &map
, sizeof(map
));
1336 lde_imsg_compose_ldpe(IMSG_REQUEST_ADD_END
,
1337 ln
->peerid
, 0, NULL
, 0);
1339 /* SLRq.4: record sent request */
1340 RB_FOREACH(f
, fec_tree
, &ft
) {
1341 fn
= (struct fec_node
*)f
;
1342 lre
= (struct lde_req
*)fec_find(&ln
->sent_req
, &fn
->fec
);
1343 if (lde_wildcard_apply(wcard
, &fn
->fec
, NULL
) == 0)
1346 lde_req_add(ln
, f
, 1);
1352 lde_send_labelrequest_wcard(struct lde_nbr
*ln
, uint16_t af
)
1356 memset(&wcard
, 0, sizeof(wcard
));
1357 wcard
.type
= MAP_TYPE_TYPED_WCARD
;
1358 wcard
.fec
.twcard
.type
= MAP_TYPE_PREFIX
;
1359 wcard
.fec
.twcard
.u
.prefix_af
= af
;
1360 lde_send_labelrequest(ln
, NULL
, &wcard
, 1);
1364 lde_send_notification(struct lde_nbr
*ln
, uint32_t status_code
, uint32_t msg_id
,
1367 struct notify_msg nm
;
1369 memset(&nm
, 0, sizeof(nm
));
1370 nm
.status_code
= status_code
;
1371 /* 'msg_id' and 'msg_type' should be in network byte order */
1373 nm
.msg_type
= msg_type
;
1375 lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND
, ln
->peerid
, 0,
1380 lde_send_notification_eol_prefix(struct lde_nbr
*ln
, int af
)
1382 struct notify_msg nm
;
1384 memset(&nm
, 0, sizeof(nm
));
1385 nm
.status_code
= S_ENDOFLIB
;
1386 nm
.fec
.type
= MAP_TYPE_TYPED_WCARD
;
1387 nm
.fec
.fec
.twcard
.type
= MAP_TYPE_PREFIX
;
1388 nm
.fec
.fec
.twcard
.u
.prefix_af
= af
;
1389 nm
.flags
|= F_NOTIF_FEC
;
1391 lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND
, ln
->peerid
, 0,
1396 lde_send_notification_eol_pwid(struct lde_nbr
*ln
, uint16_t pw_type
)
1398 struct notify_msg nm
;
1400 memset(&nm
, 0, sizeof(nm
));
1401 nm
.status_code
= S_ENDOFLIB
;
1402 nm
.fec
.type
= MAP_TYPE_TYPED_WCARD
;
1403 nm
.fec
.fec
.twcard
.type
= MAP_TYPE_PWID
;
1404 nm
.fec
.fec
.twcard
.u
.pw_type
= pw_type
;
1405 nm
.flags
|= F_NOTIF_FEC
;
1407 lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND
, ln
->peerid
, 0,
1412 lde_nbr_compare(const struct lde_nbr
*a
, const struct lde_nbr
*b
)
1414 return (a
->peerid
- b
->peerid
);
1417 static struct lde_nbr
*
1418 lde_nbr_new(uint32_t peerid
, struct lde_nbr
*new)
1422 if ((ln
= calloc(1, sizeof(*ln
))) == NULL
)
1426 ln
->v4_enabled
= new->v4_enabled
;
1427 ln
->v6_enabled
= new->v6_enabled
;
1428 ln
->flags
= new->flags
;
1429 ln
->peerid
= peerid
;
1430 fec_init(&ln
->recv_map
);
1431 fec_init(&ln
->sent_map
);
1432 fec_init(&ln
->sent_map_pending
);
1433 fec_init(&ln
->recv_req
);
1434 fec_init(&ln
->sent_req
);
1435 fec_init(&ln
->sent_wdraw
);
1437 TAILQ_INIT(&ln
->addr_list
);
1439 if (RB_INSERT(nbr_tree
, &lde_nbrs
, ln
) != NULL
)
1440 fatalx("lde_nbr_new: RB_INSERT failed");
1446 lde_nbr_del(struct lde_nbr
*ln
)
1449 struct fec_node
*fn
;
1451 struct l2vpn_pw
*pw
;
1452 struct lde_nbr
*lnbr
;
1457 /* uninstall received mappings */
1458 RB_FOREACH(f
, fec_tree
, &ft
) {
1459 fn
= (struct fec_node
*)f
;
1461 /* Update RLFA clients. */
1462 lde_rlfa_update_clients(f
, ln
, MPLS_INVALID_LABEL
);
1464 LIST_FOREACH(fnh
, &fn
->nexthops
, entry
) {
1468 if (!lde_address_find(ln
, fnh
->af
,
1473 * Ordered Control: must mark any non-connected
1474 * NH to wait until we receive a labelmap msg
1475 * before installing in kernel and sending to
1476 * peer, must do this as NHs are not removed
1477 * when lsps go down. Also send label withdraw
1478 * to other neighbors for all fecs from neighbor
1481 if (ldeconf
->flags
& F_LDPD_ORDERED_CONTROL
) {
1482 fnh
->flags
|= F_FEC_NH_DEFER
;
1484 RB_FOREACH(lnbr
, nbr_tree
, &lde_nbrs
) {
1485 if (ln
->peerid
== lnbr
->peerid
)
1487 lde_send_labelwithdraw(lnbr
, fn
, NULL
, NULL
);
1492 if (f
->u
.pwid
.lsr_id
.s_addr
!= ln
->id
.s_addr
)
1494 pw
= (struct l2vpn_pw
*) fn
->data
;
1496 pw
->reason
= F_PW_NO_REMOTE_LABEL
;
1504 lde_send_delete_klabel(fn
, fnh
);
1505 fnh
->remote_label
= NO_LABEL
;
1509 lde_address_list_free(ln
);
1511 fec_clear(&ln
->recv_map
, lde_map_free
);
1512 fec_clear(&ln
->sent_map
, lde_map_free
);
1513 fec_clear(&ln
->sent_map_pending
, free
);
1514 fec_clear(&ln
->recv_req
, free
);
1515 fec_clear(&ln
->sent_req
, free
);
1516 fec_clear(&ln
->sent_wdraw
, free
);
1518 RB_REMOVE(nbr_tree
, &lde_nbrs
, ln
);
1523 static struct lde_nbr
*
1524 lde_nbr_find(uint32_t peerid
)
1530 return (RB_FIND(nbr_tree
, &lde_nbrs
, &ln
));
1534 lde_nbr_find_by_lsrid(struct in_addr addr
)
1538 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
1539 if (ln
->id
.s_addr
== addr
.s_addr
)
1546 lde_nbr_find_by_addr(int af
, union ldpd_addr
*addr
)
1550 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
1551 if (lde_address_find(ln
, af
, addr
) != NULL
)
1562 while (!RB_EMPTY(nbr_tree
, &lde_nbrs
)) {
1563 ln
= RB_ROOT(nbr_tree
, &lde_nbrs
);
1570 lde_nbr_addr_update(struct lde_nbr
*ln
, struct lde_addr
*lde_addr
, int removed
)
1573 struct fec_node
*fn
;
1577 RB_FOREACH(fec
, fec_tree
, &ln
->recv_map
) {
1578 switch (fec
->type
) {
1580 if (lde_addr
->af
!= AF_INET
)
1584 if (lde_addr
->af
!= AF_INET6
)
1591 fn
= (struct fec_node
*)fec_find(&ft
, fec
);
1593 /* shouldn't happen */
1596 LIST_FOREACH(fnh
, &fn
->nexthops
, entry
) {
1597 if (ldp_addrcmp(fnh
->af
, &fnh
->nexthop
,
1602 lde_send_delete_klabel(fn
, fnh
);
1603 fnh
->remote_label
= NO_LABEL
;
1605 me
= (struct lde_map
*)fec
;
1606 fnh
->remote_label
= me
->map
.label
;
1607 lde_send_change_klabel(fn
, fnh
);
1615 lde_allow_broken_lsp_update(int new_config
)
1617 struct fec_node
*fn
;
1621 RB_FOREACH(f
, fec_tree
, &ft
) {
1622 fn
= (struct fec_node
*)f
;
1624 LIST_FOREACH(fnh
, &fn
->nexthops
, entry
) {
1625 /* allow-broken-lsp config is changing so
1626 * we need to reprogram labeled routes to
1627 * have proper top-level label
1629 if (!(new_config
& F_LDPD_ALLOW_BROKEN_LSP
))
1630 lde_send_delete_klabel(fn
, fnh
);
1632 if (fn
->local_label
!= NO_LABEL
)
1633 lde_send_change_klabel(fn
, fnh
);
1639 lde_map_compare(const struct lde_map
*a
, const struct lde_map
*b
)
1641 return (ldp_addrcmp(AF_INET
, (union ldpd_addr
*)&a
->nexthop
->id
,
1642 (union ldpd_addr
*)&b
->nexthop
->id
));
1646 lde_map_add(struct lde_nbr
*ln
, struct fec_node
*fn
, int sent
)
1650 me
= calloc(1, sizeof(*me
));
1658 RB_INSERT(lde_map_head
, &fn
->upstream
, me
);
1659 me
->head
= &fn
->upstream
;
1660 if (fec_insert(&ln
->sent_map
, &me
->fec
))
1661 log_warnx("failed to add %s to sent map",
1663 /* XXX on failure more cleanup is needed */
1665 RB_INSERT(lde_map_head
, &fn
->downstream
, me
);
1666 me
->head
= &fn
->downstream
;
1667 if (fec_insert(&ln
->recv_map
, &me
->fec
))
1668 log_warnx("failed to add %s to recv map",
1676 lde_map_del(struct lde_nbr
*ln
, struct lde_map
*me
, int sent
)
1679 fec_remove(&ln
->sent_map
, &me
->fec
);
1681 fec_remove(&ln
->recv_map
, &me
->fec
);
1687 lde_map_free(void *ptr
)
1689 struct lde_map
*map
= ptr
;
1691 RB_REMOVE(lde_map_head
, map
->head
, map
);
1696 lde_map_pending_add(struct lde_nbr
*ln
, struct fec_node
*fn
)
1700 map
= calloc(1, sizeof(*map
));
1705 if (fec_insert(&ln
->sent_map_pending
, map
))
1706 log_warnx("failed to add %s to sent map (pending)",
1713 lde_map_pending_del(struct lde_nbr
*ln
, struct fec
*map
)
1715 fec_remove(&ln
->sent_map_pending
, map
);
1720 lde_req_add(struct lde_nbr
*ln
, struct fec
*fec
, int sent
)
1723 struct lde_req
*lre
;
1725 t
= sent
? &ln
->sent_req
: &ln
->recv_req
;
1727 lre
= calloc(1, sizeof(*lre
));
1731 if (fec_insert(t
, &lre
->fec
)) {
1732 log_warnx("failed to add %s to %s req",
1733 log_fec(&lre
->fec
), sent
? "sent" : "recv");
1743 lde_req_del(struct lde_nbr
*ln
, struct lde_req
*lre
, int sent
)
1746 fec_remove(&ln
->sent_req
, &lre
->fec
);
1748 fec_remove(&ln
->recv_req
, &lre
->fec
);
1754 lde_wdraw_add(struct lde_nbr
*ln
, struct fec_node
*fn
)
1756 struct lde_wdraw
*lw
;
1758 lw
= calloc(1, sizeof(*lw
));
1764 if (fec_insert(&ln
->sent_wdraw
, &lw
->fec
))
1765 log_warnx("failed to add %s to sent wdraw",
1772 lde_wdraw_del(struct lde_nbr
*ln
, struct lde_wdraw
*lw
)
1774 fec_remove(&ln
->sent_wdraw
, &lw
->fec
);
1779 lde_change_egress_label(int af
)
1783 struct fec_node
*fn
;
1785 /* explicitly withdraw all null labels */
1786 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
) {
1787 lde_send_labelwithdraw_wcard(ln
, MPLS_LABEL_IMPLICIT_NULL
);
1789 lde_send_labelwithdraw_wcard(
1791 MPLS_LABEL_IPV4_EXPLICIT_NULL
);
1793 lde_send_labelwithdraw_wcard(
1795 MPLS_LABEL_IPV6_EXPLICIT_NULL
);
1798 /* update label of connected routes */
1799 RB_FOREACH(f
, fec_tree
, &ft
) {
1800 fn
= (struct fec_node
*)f
;
1801 if (fn
->local_label
> MPLS_LABEL_RESERVED_MAX
)
1806 if (fn
->fec
.type
!= FEC_TYPE_IPV4
)
1810 if (fn
->fec
.type
!= FEC_TYPE_IPV6
)
1814 fatalx("lde_change_egress_label: unknown af");
1817 fn
->local_label
= lde_update_label(fn
);
1818 if (fn
->local_label
!= NO_LABEL
)
1819 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
1820 lde_send_labelmapping(ln
, fn
, 0);
1822 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
1823 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END
, ln
->peerid
, 0,
1828 lde_change_allocate_filter(int af
)
1832 struct fec_node
*fn
;
1835 /* reallocate labels for fecs that match this filter */
1836 RB_FOREACH(f
, fec_tree
, &ft
) {
1837 fn
= (struct fec_node
*)f
;
1841 if (fn
->fec
.type
!= FEC_TYPE_IPV4
)
1845 if (fn
->fec
.type
!= FEC_TYPE_IPV6
)
1849 fatalx("lde_change_allocate_filter: unknown af");
1853 * If the local label has changed to NO_LABEL, send a label
1854 * withdraw to all peers.
1855 * If the local label has changed and it's different from
1856 * NO_LABEL, send a label mapping to all peers advertising
1858 * If the local label hasn't changed, do nothing
1860 new_label
= lde_update_label(fn
);
1861 if (fn
->local_label
!= new_label
) {
1862 if (new_label
== NO_LABEL
)
1863 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
1864 lde_send_labelwithdraw(ln
, fn
,
1867 fn
->local_label
= new_label
;
1868 if (fn
->local_label
!= NO_LABEL
)
1869 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
1870 lde_send_labelmapping(ln
, fn
, 0);
1873 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
1874 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END
, ln
->peerid
, 0,
1879 lde_change_advertise_filter(int af
)
1883 struct fec_node
*fn
;
1884 char *acl_to_filter
;
1885 char *acl_for_filter
;
1886 union ldpd_addr
*prefix
;
1890 /* advertise label for fecs to neighbors if matches advertise filters */
1893 acl_to_filter
= ldeconf
->ipv4
.acl_label_advertise_to
;
1894 acl_for_filter
= ldeconf
->ipv4
.acl_label_advertise_for
;
1897 acl_to_filter
= ldeconf
->ipv6
.acl_label_advertise_to
;
1898 acl_for_filter
= ldeconf
->ipv6
.acl_label_advertise_for
;
1901 fatalx("lde_change_advertise_filter: unknown af");
1904 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
) {
1905 if (lde_acl_check(acl_to_filter
, af
, (union ldpd_addr
*)&ln
->id
,
1906 IPV4_MAX_BITLEN
) != FILTER_PERMIT
)
1907 lde_send_labelwithdraw_wcard(ln
, NO_LABEL
);
1909 /* This neighbor is allowed in to_filter, so
1910 * send labels if fec also matches for_filter
1912 RB_FOREACH(f
, fec_tree
, &ft
) {
1913 fn
= (struct fec_node
*)f
;
1916 if (fn
->fec
.type
!= FEC_TYPE_IPV4
)
1918 prefix
= (union ldpd_addr
*)
1919 &fn
->fec
.u
.ipv4
.prefix
;
1920 plen
= fn
->fec
.u
.ipv4
.prefixlen
;
1923 if (fn
->fec
.type
!= FEC_TYPE_IPV6
)
1925 prefix
= (union ldpd_addr
*)
1926 &fn
->fec
.u
.ipv6
.prefix
;
1927 plen
= fn
->fec
.u
.ipv6
.prefixlen
;
1932 if (lde_acl_check(acl_for_filter
, af
,
1933 prefix
, plen
) != FILTER_PERMIT
) {
1934 me
= (struct lde_map
*)fec_find(
1935 &ln
->sent_map
, &fn
->fec
);
1937 /* fec filtered withdraw */
1938 lde_send_labelwithdraw(ln
, fn
,
1941 /* fec allowed send map */
1942 lde_send_labelmapping(ln
, fn
, 0);
1944 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END
,
1945 ln
->peerid
, 0, NULL
, 0);
1952 lde_change_accept_filter(int af
)
1956 struct fec_node
*fn
;
1957 char *acl_for_filter
;
1958 char *acl_from_filter
;
1959 union ldpd_addr
*prefix
;
1964 /* accept labels from neighbors specified in the from_filter and for
1965 * fecs defined in the for_filter
1969 acl_for_filter
= ldeconf
->ipv4
.acl_label_accept_for
;
1970 acl_from_filter
= ldeconf
->ipv4
.acl_label_accept_from
;
1971 type
= FEC_TYPE_IPV4
;
1974 acl_for_filter
= ldeconf
->ipv6
.acl_label_accept_for
;
1975 acl_from_filter
= ldeconf
->ipv6
.acl_label_accept_from
;
1976 type
= FEC_TYPE_IPV6
;
1979 fatalx("lde_change_accept_filter: unknown af");
1982 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
) {
1983 if (lde_acl_check(acl_from_filter
, AF_INET
, (union ldpd_addr
*)
1984 &ln
->id
, IPV4_MAX_BITLEN
) != FILTER_PERMIT
) {
1985 /* This neighbor is now filtered so remove fecs from
1988 RB_FOREACH(f
, fec_tree
, &ft
) {
1989 fn
= (struct fec_node
*)f
;
1990 if (fn
->fec
.type
== type
) {
1991 me
= (struct lde_map
*)fec_find(
1992 &ln
->recv_map
, &fn
->fec
);
1994 lde_map_del(ln
, me
, 0);
1997 } else if (ln
->flags
& F_NBR_CAP_TWCARD
) {
1998 /* This neighbor is allowed and supports type
1999 * wildcard so send a labelrequest
2000 * to get any new labels from neighbor
2001 * and make sure any fecs we currently have
2004 RB_FOREACH(f
, fec_tree
, &ft
) {
2005 fn
= (struct fec_node
*)f
;
2008 if (fn
->fec
.type
!= FEC_TYPE_IPV4
)
2010 prefix
= (union ldpd_addr
*)
2011 &fn
->fec
.u
.ipv4
.prefix
;
2012 plen
= fn
->fec
.u
.ipv4
.prefixlen
;
2015 if (fn
->fec
.type
!= FEC_TYPE_IPV6
)
2017 prefix
= (union ldpd_addr
*)
2018 &fn
->fec
.u
.ipv6
.prefix
;
2019 plen
= fn
->fec
.u
.ipv6
.prefixlen
;
2024 if (lde_acl_check(acl_for_filter
, af
,
2025 prefix
, plen
) != FILTER_PERMIT
) {
2026 me
= (struct lde_map
*)fec_find(
2027 &ln
->recv_map
, &fn
->fec
);
2029 lde_map_del(ln
, me
, 0);
2032 lde_send_labelrequest_wcard(ln
, af
);
2034 /* Type Wildcard is not supported so restart session */
2035 lde_imsg_compose_ldpe(IMSG_NBR_SHUTDOWN
, ln
->peerid
, 0,
2041 lde_change_expnull_for_filter(int af
)
2045 struct fec_node
*fn
;
2048 union ldpd_addr
*prefix
;
2051 /* Configure explicit-null advertisement for all fecs in this filter */
2052 RB_FOREACH(f
, fec_tree
, &ft
) {
2053 fn
= (struct fec_node
*)f
;
2057 if (fn
->fec
.type
!= FEC_TYPE_IPV4
)
2059 acl_name
= ldeconf
->ipv4
.acl_label_expnull_for
;
2060 prefix
= (union ldpd_addr
*)&fn
->fec
.u
.ipv4
.prefix
;
2061 plen
= fn
->fec
.u
.ipv4
.prefixlen
;
2062 exp_label
= MPLS_LABEL_IPV4_EXPLICIT_NULL
;
2065 if (fn
->fec
.type
!= FEC_TYPE_IPV6
)
2067 acl_name
= ldeconf
->ipv6
.acl_label_expnull_for
;
2068 prefix
= (union ldpd_addr
*)&fn
->fec
.u
.ipv6
.prefix
;
2069 plen
= fn
->fec
.u
.ipv6
.prefixlen
;
2070 exp_label
= MPLS_LABEL_IPV6_EXPLICIT_NULL
;
2073 fatalx("lde_change_expnull_for_filter: unknown af");
2076 if (lde_acl_check(acl_name
, af
, prefix
, plen
) == FILTER_PERMIT
) {
2077 /* for this fec change any imp-null to exp-null */
2078 if (fn
->local_label
== MPLS_LABEL_IMPLICIT_NULL
) {
2079 fn
->local_label
= lde_update_label(fn
);
2080 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
2081 lde_send_labelmapping(ln
, fn
, 0);
2084 /* for this fec change any exp-null back to imp-null */
2085 if (fn
->local_label
== exp_label
) {
2086 fn
->local_label
= lde_update_label(fn
);
2087 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
2088 lde_send_labelmapping(ln
, fn
, 0);
2092 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
2093 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END
, ln
->peerid
, 0,
2098 lde_address_add(struct lde_nbr
*ln
, struct lde_addr
*lde_addr
)
2100 struct lde_addr
*new;
2102 if (lde_address_find(ln
, lde_addr
->af
, &lde_addr
->addr
) != NULL
)
2105 if ((new = calloc(1, sizeof(*new))) == NULL
)
2108 new->af
= lde_addr
->af
;
2109 new->addr
= lde_addr
->addr
;
2110 TAILQ_INSERT_TAIL(&ln
->addr_list
, new, entry
);
2112 /* reevaluate the previously received mappings from this neighbor */
2113 lde_nbr_addr_update(ln
, lde_addr
, 0);
2119 lde_address_del(struct lde_nbr
*ln
, struct lde_addr
*lde_addr
)
2121 lde_addr
= lde_address_find(ln
, lde_addr
->af
, &lde_addr
->addr
);
2122 if (lde_addr
== NULL
)
2125 /* reevaluate the previously received mappings from this neighbor */
2126 lde_nbr_addr_update(ln
, lde_addr
, 1);
2128 TAILQ_REMOVE(&ln
->addr_list
, lde_addr
, entry
);
2135 lde_address_find(struct lde_nbr
*ln
, int af
, union ldpd_addr
*addr
)
2137 struct lde_addr
*lde_addr
;
2139 TAILQ_FOREACH(lde_addr
, &ln
->addr_list
, entry
)
2140 if (lde_addr
->af
== af
&&
2141 ldp_addrcmp(af
, &lde_addr
->addr
, addr
) == 0)
2148 lde_address_list_free(struct lde_nbr
*ln
)
2150 struct lde_addr
*lde_addr
;
2152 while ((lde_addr
= TAILQ_POP_FIRST(&ln
->addr_list
, entry
)) != NULL
)
2157 * Event callback used to retry the label-manager sync zapi session.
2159 static void zclient_sync_retry(struct thread
*thread
)
2161 zclient_sync_init();
2165 * Initialize and open a synchronous zapi session. This is used by label chunk
2166 * management code, which acquires and releases blocks of labels from the
2167 * zebra label-manager module.
2169 static void zclient_sync_init(void)
2171 struct zclient_options options
= zclient_options_default
;
2173 options
.synchronous
= true;
2175 /* Initialize special zclient for synchronous message exchanges. */
2176 zclient_sync
= zclient_new(master
, &options
, NULL
, 0);
2177 zclient_sync
->sock
= -1;
2178 zclient_sync
->redist_default
= ZEBRA_ROUTE_LDP
;
2179 zclient_sync
->session_id
= 1; /* Distinguish from main session */
2180 zclient_sync
->privs
= &lde_privs
;
2182 if (zclient_socket_connect(zclient_sync
) < 0) {
2183 log_warnx("Error connecting synchronous zclient!");
2186 /* make socket non-blocking */
2187 sock_set_nonblock(zclient_sync
->sock
);
2189 /* Send hello to notify zebra this is a synchronous client */
2190 if (zclient_send_hello(zclient_sync
) == ZCLIENT_SEND_FAILURE
) {
2191 log_warnx("Error sending hello for synchronous zclient!");
2195 /* Connect to label manager */
2196 if (lm_label_manager_connect(zclient_sync
, 0) != 0) {
2197 log_warnx("Error connecting to label manager!");
2201 /* Finish label-manager init once the LM session is running */
2202 lde_label_list_init();
2208 /* Discard failed zclient object */
2209 zclient_stop(zclient_sync
);
2210 zclient_free(zclient_sync
);
2211 zclient_sync
= NULL
;
2213 /* Retry using a timer */
2214 thread_add_timer(master
, zclient_sync_retry
, NULL
, 1, NULL
);
2218 lde_del_label_chunk(void *val
)
2224 lde_release_label_chunk(uint32_t start
, uint32_t end
)
2228 ret
= lm_release_label_chunk(zclient_sync
, start
, end
);
2230 log_warnx("Error releasing label chunk!");
2237 lde_get_label_chunk(void)
2240 uint32_t start
, end
;
2242 debug_labels("getting label chunk (size %u)", CHUNK_SIZE
);
2243 ret
= lm_get_label_chunk(zclient_sync
, 0, MPLS_LABEL_BASE_ANY
,
2244 CHUNK_SIZE
, &start
, &end
);
2246 log_warnx("Error getting label chunk!");
2250 on_get_label_chunk_response(start
, end
);
2256 lde_label_list_init(void)
2258 label_chunk_list
= list_new();
2259 label_chunk_list
->del
= lde_del_label_chunk
;
2261 /* get first chunk */
2262 while (lde_get_label_chunk () != 0) {
2263 log_warnx("Error getting first label chunk!");
2269 on_get_label_chunk_response(uint32_t start
, uint32_t end
)
2271 struct label_chunk
*new_label_chunk
;
2273 debug_labels("label chunk assign: %u - %u", start
, end
);
2275 new_label_chunk
= calloc(1, sizeof(struct label_chunk
));
2276 if (!new_label_chunk
) {
2277 log_warn("Error trying to allocate label chunk %u - %u", start
, end
);
2281 new_label_chunk
->start
= start
;
2282 new_label_chunk
->end
= end
;
2283 new_label_chunk
->used_mask
= 0;
2285 listnode_add(label_chunk_list
, (void *)new_label_chunk
);
2287 /* let's update current if needed */
2288 if (!current_label_chunk
)
2289 current_label_chunk
= listtail(label_chunk_list
);
2293 lde_free_label(uint32_t label
)
2295 struct listnode
*node
;
2296 struct label_chunk
*label_chunk
;
2299 for (ALL_LIST_ELEMENTS_RO(label_chunk_list
, node
, label_chunk
)) {
2300 if (label
<= label_chunk
->end
&& label
>= label_chunk
->start
) {
2301 pos
= 1ULL << (label
- label_chunk
->start
);
2302 label_chunk
->used_mask
&= ~pos
;
2303 /* if nobody is using this chunk and it's not current_label_chunk, then free it */
2304 if (!label_chunk
->used_mask
&& (current_label_chunk
!= node
)) {
2305 if (lde_release_label_chunk(label_chunk
->start
, label_chunk
->end
) != 0)
2306 log_warnx("%s: Error releasing label chunk!", __func__
);
2308 listnode_delete(label_chunk_list
, label_chunk
);
2309 lde_del_label_chunk(label_chunk
);
2319 lde_get_next_label(void)
2321 struct label_chunk
*label_chunk
;
2324 uint32_t label
= NO_LABEL
;
2326 while (current_label_chunk
) {
2327 label_chunk
= listgetdata(current_label_chunk
);
2331 /* try to get next free label in currently used label chunk */
2332 size
= label_chunk
->end
- label_chunk
->start
+ 1;
2333 for (i
= 0, pos
= 1; i
< size
; i
++, pos
<<= 1) {
2334 if (!(pos
& label_chunk
->used_mask
)) {
2335 label_chunk
->used_mask
|= pos
;
2336 label
= label_chunk
->start
+ i
;
2340 current_label_chunk
= listnextnode(current_label_chunk
);
2344 /* we moved till the last chunk, or were not able to find a label,
2345 so let's ask for another one */
2346 if (!current_label_chunk
||
2347 current_label_chunk
== listtail(label_chunk_list
) ||
2348 label
== NO_LABEL
) {
2349 if (lde_get_label_chunk() != 0)
2350 log_warn("%s: Error getting label chunk!", __func__
);
2358 lde_check_filter_af(int af
, struct ldpd_af_conf
*af_conf
,
2359 const char *filter_name
)
2361 if (strcmp(af_conf
->acl_label_allocate_for
, filter_name
) == 0)
2362 lde_change_allocate_filter(af
);
2363 if ((strcmp(af_conf
->acl_label_advertise_to
, filter_name
) == 0)
2364 || (strcmp(af_conf
->acl_label_advertise_for
, filter_name
) == 0))
2365 lde_change_advertise_filter(af
);
2366 if ((strcmp(af_conf
->acl_label_accept_for
, filter_name
) == 0)
2367 || (strcmp(af_conf
->acl_label_accept_from
, filter_name
) == 0))
2368 lde_change_accept_filter(af
);
2369 if (strcmp(af_conf
->acl_label_expnull_for
, filter_name
) == 0)
2370 lde_change_expnull_for_filter(af
);
2373 void lde_route_update(struct iface
*iface
, int af
)
2376 struct fec_node
*fn
;
2380 /* update label of non-connected routes */
2381 log_debug("update labels for interface %s", iface
->name
);
2382 RB_FOREACH(f
, fec_tree
, &ft
) {
2383 fn
= (struct fec_node
*)f
;
2384 if (IS_MPLS_UNRESERVED_LABEL(fn
->local_label
))
2389 if (fn
->fec
.type
!= FEC_TYPE_IPV4
)
2393 if (fn
->fec
.type
!= FEC_TYPE_IPV6
)
2397 /* unspecified so process both address families */
2401 LIST_FOREACH(fnh
, &fn
->nexthops
, entry
) {
2403 * If connected leave existing label. If LDP
2404 * configured on interface or a static route
2405 * may need new label. If no LDP configured
2406 * treat fec as a connected route
2408 if (fnh
->flags
& F_FEC_NH_CONNECTED
)
2411 if (fnh
->ifindex
!= iface
->ifindex
)
2414 fnh
->flags
&= ~F_FEC_NH_NO_LDP
;
2415 if (IS_MPLS_RESERVED_LABEL(fn
->local_label
)) {
2416 fn
->local_label
= NO_LABEL
;
2417 fn
->local_label
= lde_update_label(fn
);
2418 if (fn
->local_label
!= NO_LABEL
)
2419 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
2420 lde_send_labelmapping(
2426 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
2427 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END
, ln
->peerid
,
2431 void lde_route_update_release(struct iface
*iface
, int af
)
2435 struct fec_node
*fn
;
2438 /* update label of interfaces no longer running LDP */
2439 log_debug("release all labels for interface %s af %s", iface
->name
,
2440 af
== AF_INET
? "ipv4" : "ipv6");
2441 RB_FOREACH(f
, fec_tree
, &ft
) {
2442 fn
= (struct fec_node
*)f
;
2446 if (fn
->fec
.type
!= FEC_TYPE_IPV4
)
2450 if (fn
->fec
.type
!= FEC_TYPE_IPV6
)
2454 fatalx("lde_route_update_release: unknown af");
2457 if (fn
->local_label
== NO_LABEL
)
2460 LIST_FOREACH(fnh
, &fn
->nexthops
, entry
) {
2462 * If connected leave existing label. If LDP
2463 * removed from interface may need new label
2464 * and would be treated as a connected route
2466 if (fnh
->flags
& F_FEC_NH_CONNECTED
)
2469 if (fnh
->ifindex
!= iface
->ifindex
)
2472 fnh
->flags
|= F_FEC_NH_NO_LDP
;
2473 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
2474 lde_send_labelwithdraw(ln
, fn
, NULL
, NULL
);
2475 lde_free_label(fn
->local_label
);
2476 fn
->local_label
= NO_LABEL
;
2477 fn
->local_label
= lde_update_label(fn
);
2478 if (fn
->local_label
!= NO_LABEL
)
2479 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
2480 lde_send_labelmapping(ln
, fn
, 0);
2484 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
2485 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END
, ln
->peerid
,
2489 void lde_route_update_release_all(int af
)
2493 struct fec_node
*fn
;
2496 /* remove labels from all interfaces as LDP is no longer running for
2497 * this address family
2499 log_debug("release all labels for address family %s",
2500 af
== AF_INET
? "ipv4" : "ipv6");
2501 RB_FOREACH(f
, fec_tree
, &ft
) {
2502 fn
= (struct fec_node
*)f
;
2505 if (fn
->fec
.type
!= FEC_TYPE_IPV4
)
2509 if (fn
->fec
.type
!= FEC_TYPE_IPV6
)
2513 fatalx("lde_route_update_release: unknown af");
2516 RB_FOREACH(ln
, nbr_tree
, &lde_nbrs
)
2517 lde_send_labelwithdraw(ln
, fn
, NULL
, NULL
);
2519 LIST_FOREACH(fnh
, &fn
->nexthops
, entry
) {
2520 fnh
->flags
|= F_FEC_NH_NO_LDP
;
2521 lde_send_delete_klabel(fn
, fnh
);