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