]> git.proxmox.com Git - mirror_frr.git/blob - ldpd/lde.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #870 from chiragshah6/mdev
[mirror_frr.git] / ldpd / lde.c
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2013, 2016 Renato Westphal <renato@openbsd.org>
5 * Copyright (c) 2004, 2005 Claudio Jeker <claudio@openbsd.org>
6 * Copyright (c) 2004 Esben Norby <norby@openbsd.org>
7 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
8 *
9 * Permission to use, copy, modify, and distribute this software for any
10 * purpose with or without fee is hereby granted, provided that the above
11 * copyright notice and this permission notice appear in all copies.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 */
21
22 #include <zebra.h>
23
24 #include "ldp.h"
25 #include "ldpd.h"
26 #include "ldpe.h"
27 #include "log.h"
28 #include "lde.h"
29 #include "ldp_debug.h"
30
31 #include <lib/log.h>
32 #include "memory.h"
33 #include "privs.h"
34 #include "sigevent.h"
35 #include "mpls.h"
36 #include <lib/linklist.h>
37 #include "zclient.h"
38 #include "stream.h"
39 #include "network.h"
40
41 static void lde_shutdown(void);
42 static int lde_dispatch_imsg(struct thread *);
43 static int lde_dispatch_parent(struct thread *);
44 static __inline int lde_nbr_compare(const struct lde_nbr *,
45 const struct lde_nbr *);
46 static struct lde_nbr *lde_nbr_new(uint32_t, struct lde_nbr *);
47 static void lde_nbr_del(struct lde_nbr *);
48 static struct lde_nbr *lde_nbr_find(uint32_t);
49 static void lde_nbr_clear(void);
50 static void lde_nbr_addr_update(struct lde_nbr *,
51 struct lde_addr *, int);
52 static __inline int lde_map_compare(const struct lde_map *,
53 const struct lde_map *);
54 static void lde_map_free(void *);
55 static int lde_address_add(struct lde_nbr *, struct lde_addr *);
56 static int lde_address_del(struct lde_nbr *, struct lde_addr *);
57 static void lde_address_list_free(struct lde_nbr *);
58 static void zclient_sync_init(u_short instance);
59 static void lde_label_list_init(void);
60 static int lde_get_label_chunk(void);
61 static void on_get_label_chunk_response(uint32_t start, uint32_t end);
62 static uint32_t lde_get_next_label(void);
63
64 RB_GENERATE(nbr_tree, lde_nbr, entry, lde_nbr_compare)
65 RB_GENERATE(lde_map_head, lde_map, entry, lde_map_compare)
66
67 struct ldpd_conf *ldeconf;
68 struct nbr_tree lde_nbrs = RB_INITIALIZER(&lde_nbrs);
69
70 static struct imsgev *iev_ldpe;
71 static struct imsgev *iev_main, *iev_main_sync;
72
73 /* Master of threads. */
74 struct thread_master *master;
75
76 /* lde privileges */
77 static zebra_capabilities_t _caps_p [] =
78 {
79 /* none */
80 };
81
82 static struct zebra_privs_t lde_privs =
83 {
84 #if defined(VTY_GROUP)
85 .vty_group = VTY_GROUP,
86 #endif
87 .caps_p = _caps_p,
88 .cap_num_p = array_size(_caps_p),
89 .cap_num_i = 0
90 };
91
92 /* List of chunks of labels externally assigned by Zebra */
93 static struct list *label_chunk_list;
94 static struct listnode *current_label_chunk;
95
96 /* Synchronous zclient to request labels */
97 static struct zclient *zclient_sync;
98
99 /* SIGINT / SIGTERM handler. */
100 static void
101 sigint(void)
102 {
103 lde_shutdown();
104 }
105
106 static struct quagga_signal_t lde_signals[] =
107 {
108 {
109 .signal = SIGHUP,
110 /* ignore */
111 },
112 {
113 .signal = SIGINT,
114 .handler = &sigint,
115 },
116 {
117 .signal = SIGTERM,
118 .handler = &sigint,
119 },
120 };
121
122 /* label decision engine */
123 void
124 lde(void)
125 {
126 struct thread thread;
127
128 #ifdef HAVE_SETPROCTITLE
129 setproctitle("label decision engine");
130 #endif
131 ldpd_process = PROC_LDE_ENGINE;
132 log_procname = log_procnames[PROC_LDE_ENGINE];
133
134 master = thread_master_create(NULL);
135
136 /* setup signal handler */
137 signal_init(master, array_size(lde_signals), lde_signals);
138
139 /* setup pipes and event handlers to the parent process */
140 if ((iev_main = calloc(1, sizeof(struct imsgev))) == NULL)
141 fatal(NULL);
142 imsg_init(&iev_main->ibuf, LDPD_FD_ASYNC);
143 iev_main->handler_read = lde_dispatch_parent;
144 iev_main->ev_read = NULL;
145 thread_add_read(master, iev_main->handler_read, iev_main, iev_main->ibuf.fd,
146 &iev_main->ev_read);
147 iev_main->handler_write = ldp_write_handler;
148
149 if ((iev_main_sync = calloc(1, sizeof(struct imsgev))) == NULL)
150 fatal(NULL);
151 imsg_init(&iev_main_sync->ibuf, LDPD_FD_SYNC);
152
153 /* create base configuration */
154 ldeconf = config_new_empty();
155
156 /* Fetch next active thread. */
157 while (thread_fetch(master, &thread))
158 thread_call(&thread);
159 }
160
161 void
162 lde_init(struct ldpd_init *init)
163 {
164 /* drop privileges */
165 lde_privs.user = init->user;
166 lde_privs.group = init->group;
167 zprivs_init(&lde_privs);
168
169 /* start the LIB garbage collector */
170 lde_gc_start_timer();
171
172 /* Init synchronous zclient and label list */
173 zclient_serv_path_set(init->zclient_serv_path);
174 zclient_sync_init(init->instance);
175 lde_label_list_init();
176 }
177
178 static void
179 lde_shutdown(void)
180 {
181 /* close pipes */
182 if (iev_ldpe) {
183 msgbuf_clear(&iev_ldpe->ibuf.w);
184 close(iev_ldpe->ibuf.fd);
185 }
186 msgbuf_clear(&iev_main->ibuf.w);
187 close(iev_main->ibuf.fd);
188 msgbuf_clear(&iev_main_sync->ibuf.w);
189 close(iev_main_sync->ibuf.fd);
190
191 lde_gc_stop_timer();
192 lde_nbr_clear();
193 fec_tree_clear();
194
195 config_clear(ldeconf);
196
197 if (iev_ldpe)
198 free(iev_ldpe);
199 free(iev_main);
200 free(iev_main_sync);
201
202 log_info("label decision engine exiting");
203 exit(0);
204 }
205
206 /* imesg */
207 int
208 lde_imsg_compose_parent(int type, pid_t pid, void *data, uint16_t datalen)
209 {
210 return (imsg_compose_event(iev_main, type, 0, pid, -1, data, datalen));
211 }
212
213 void
214 lde_imsg_compose_parent_sync(int type, pid_t pid, void *data, uint16_t datalen)
215 {
216 imsg_compose_event(iev_main_sync, type, 0, pid, -1, data, datalen);
217 imsg_flush(&iev_main_sync->ibuf);
218 }
219
220 int
221 lde_imsg_compose_ldpe(int type, uint32_t peerid, pid_t pid, void *data,
222 uint16_t datalen)
223 {
224 return (imsg_compose_event(iev_ldpe, type, peerid, pid,
225 -1, data, datalen));
226 }
227
228 /* ARGSUSED */
229 static int
230 lde_dispatch_imsg(struct thread *thread)
231 {
232 struct imsgev *iev = THREAD_ARG(thread);
233 struct imsgbuf *ibuf = &iev->ibuf;
234 struct imsg imsg;
235 struct lde_nbr *ln;
236 struct map *map;
237 struct lde_addr *lde_addr;
238 struct notify_msg *nm;
239 ssize_t n;
240 int shut = 0;
241
242 iev->ev_read = NULL;
243
244 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
245 fatal("imsg_read error");
246 if (n == 0) /* connection closed */
247 shut = 1;
248
249 for (;;) {
250 if ((n = imsg_get(ibuf, &imsg)) == -1)
251 fatal("lde_dispatch_imsg: imsg_get error");
252 if (n == 0)
253 break;
254
255 switch (imsg.hdr.type) {
256 case IMSG_LABEL_MAPPING_FULL:
257 ln = lde_nbr_find(imsg.hdr.peerid);
258 if (ln == NULL) {
259 log_debug("%s: cannot find lde neighbor",
260 __func__);
261 break;
262 }
263
264 fec_snap(ln);
265 break;
266 case IMSG_LABEL_MAPPING:
267 case IMSG_LABEL_REQUEST:
268 case IMSG_LABEL_RELEASE:
269 case IMSG_LABEL_WITHDRAW:
270 case IMSG_LABEL_ABORT:
271 if (imsg.hdr.len - IMSG_HEADER_SIZE !=
272 sizeof(struct map))
273 fatalx("lde_dispatch_imsg: wrong imsg len");
274 map = imsg.data;
275
276 ln = lde_nbr_find(imsg.hdr.peerid);
277 if (ln == NULL) {
278 log_debug("%s: cannot find lde neighbor",
279 __func__);
280 break;
281 }
282
283 switch (imsg.hdr.type) {
284 case IMSG_LABEL_MAPPING:
285 lde_check_mapping(map, ln);
286 break;
287 case IMSG_LABEL_REQUEST:
288 lde_check_request(map, ln);
289 break;
290 case IMSG_LABEL_RELEASE:
291 lde_check_release(map, ln);
292 break;
293 case IMSG_LABEL_WITHDRAW:
294 lde_check_withdraw(map, ln);
295 break;
296 case IMSG_LABEL_ABORT:
297 /* not necessary */
298 break;
299 }
300 break;
301 case IMSG_ADDRESS_ADD:
302 if (imsg.hdr.len - IMSG_HEADER_SIZE !=
303 sizeof(struct lde_addr))
304 fatalx("lde_dispatch_imsg: wrong imsg len");
305 lde_addr = imsg.data;
306
307 ln = lde_nbr_find(imsg.hdr.peerid);
308 if (ln == NULL) {
309 log_debug("%s: cannot find lde neighbor",
310 __func__);
311 break;
312 }
313 if (lde_address_add(ln, lde_addr) < 0) {
314 log_debug("%s: cannot add address %s, it "
315 "already exists", __func__,
316 log_addr(lde_addr->af, &lde_addr->addr));
317 }
318 break;
319 case IMSG_ADDRESS_DEL:
320 if (imsg.hdr.len - IMSG_HEADER_SIZE !=
321 sizeof(struct lde_addr))
322 fatalx("lde_dispatch_imsg: wrong imsg len");
323 lde_addr = imsg.data;
324
325 ln = lde_nbr_find(imsg.hdr.peerid);
326 if (ln == NULL) {
327 log_debug("%s: cannot find lde neighbor",
328 __func__);
329 break;
330 }
331 if (lde_address_del(ln, lde_addr) < 0) {
332 log_debug("%s: cannot delete address %s, it "
333 "does not exist", __func__,
334 log_addr(lde_addr->af, &lde_addr->addr));
335 }
336 break;
337 case IMSG_NOTIFICATION:
338 if (imsg.hdr.len - IMSG_HEADER_SIZE !=
339 sizeof(struct notify_msg))
340 fatalx("lde_dispatch_imsg: wrong imsg len");
341 nm = imsg.data;
342
343 ln = lde_nbr_find(imsg.hdr.peerid);
344 if (ln == NULL) {
345 log_debug("%s: cannot find lde neighbor",
346 __func__);
347 break;
348 }
349
350 switch (nm->status_code) {
351 case S_PW_STATUS:
352 l2vpn_recv_pw_status(ln, nm);
353 break;
354 case S_ENDOFLIB:
355 /*
356 * Do nothing for now. Should be useful in
357 * the future when we implement LDP-IGP
358 * Synchronization (RFC 5443) and Graceful
359 * Restart (RFC 3478).
360 */
361 default:
362 break;
363 }
364 break;
365 case IMSG_NEIGHBOR_UP:
366 if (imsg.hdr.len - IMSG_HEADER_SIZE !=
367 sizeof(struct lde_nbr))
368 fatalx("lde_dispatch_imsg: wrong imsg len");
369
370 if (lde_nbr_find(imsg.hdr.peerid))
371 fatalx("lde_dispatch_imsg: "
372 "neighbor already exists");
373 lde_nbr_new(imsg.hdr.peerid, imsg.data);
374 break;
375 case IMSG_NEIGHBOR_DOWN:
376 lde_nbr_del(lde_nbr_find(imsg.hdr.peerid));
377 break;
378 case IMSG_CTL_SHOW_LIB:
379 rt_dump(imsg.hdr.pid);
380
381 lde_imsg_compose_ldpe(IMSG_CTL_END, 0,
382 imsg.hdr.pid, NULL, 0);
383 break;
384 case IMSG_CTL_SHOW_L2VPN_PW:
385 l2vpn_pw_ctl(imsg.hdr.pid);
386
387 lde_imsg_compose_ldpe(IMSG_CTL_END, 0,
388 imsg.hdr.pid, NULL, 0);
389 break;
390 case IMSG_CTL_SHOW_L2VPN_BINDING:
391 l2vpn_binding_ctl(imsg.hdr.pid);
392
393 lde_imsg_compose_ldpe(IMSG_CTL_END, 0,
394 imsg.hdr.pid, NULL, 0);
395 break;
396 default:
397 log_debug("%s: unexpected imsg %d", __func__,
398 imsg.hdr.type);
399 break;
400 }
401 imsg_free(&imsg);
402 }
403 if (!shut)
404 imsg_event_add(iev);
405 else {
406 /* this pipe is dead, so remove the event handlers and exit */
407 THREAD_READ_OFF(iev->ev_read);
408 THREAD_WRITE_OFF(iev->ev_write);
409 lde_shutdown();
410 }
411
412 return (0);
413 }
414
415 /* ARGSUSED */
416 static int
417 lde_dispatch_parent(struct thread *thread)
418 {
419 static struct ldpd_conf *nconf;
420 struct iface *iface, *niface;
421 struct tnbr *ntnbr;
422 struct nbr_params *nnbrp;
423 static struct l2vpn *l2vpn, *nl2vpn;
424 struct l2vpn_if *lif, *nlif;
425 struct l2vpn_pw *pw, *npw;
426 struct imsg imsg;
427 struct kif *kif;
428 struct kroute *kr;
429 int fd = THREAD_FD(thread);
430 struct imsgev *iev = THREAD_ARG(thread);
431 struct imsgbuf *ibuf = &iev->ibuf;
432 ssize_t n;
433 int shut = 0;
434 struct fec fec;
435
436 iev->ev_read = NULL;
437
438 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
439 fatal("imsg_read error");
440 if (n == 0) /* connection closed */
441 shut = 1;
442
443 for (;;) {
444 if ((n = imsg_get(ibuf, &imsg)) == -1)
445 fatal("lde_dispatch_parent: imsg_get error");
446 if (n == 0)
447 break;
448
449 switch (imsg.hdr.type) {
450 case IMSG_IFSTATUS:
451 if (imsg.hdr.len != IMSG_HEADER_SIZE +
452 sizeof(struct kif))
453 fatalx("IFSTATUS imsg with wrong len");
454 kif = imsg.data;
455
456 iface = if_lookup_name(ldeconf, kif->ifname);
457 if (iface) {
458 if_update_info(iface, kif);
459 break;
460 }
461
462 RB_FOREACH(l2vpn, l2vpn_head, &ldeconf->l2vpn_tree) {
463 lif = l2vpn_if_find(l2vpn, kif->ifname);
464 if (lif) {
465 l2vpn_if_update_info(lif, kif);
466 break;
467 }
468 pw = l2vpn_pw_find(l2vpn, kif->ifname);
469 if (pw) {
470 l2vpn_pw_update_info(pw, kif);
471 break;
472 }
473 }
474 break;
475 case IMSG_NETWORK_ADD:
476 case IMSG_NETWORK_UPDATE:
477 if (imsg.hdr.len != IMSG_HEADER_SIZE +
478 sizeof(struct kroute)) {
479 log_warnx("%s: wrong imsg len", __func__);
480 break;
481 }
482 kr = imsg.data;
483
484 switch (kr->af) {
485 case AF_INET:
486 fec.type = FEC_TYPE_IPV4;
487 fec.u.ipv4.prefix = kr->prefix.v4;
488 fec.u.ipv4.prefixlen = kr->prefixlen;
489 break;
490 case AF_INET6:
491 fec.type = FEC_TYPE_IPV6;
492 fec.u.ipv6.prefix = kr->prefix.v6;
493 fec.u.ipv6.prefixlen = kr->prefixlen;
494 break;
495 default:
496 fatalx("lde_dispatch_parent: unknown af");
497 }
498
499 switch (imsg.hdr.type) {
500 case IMSG_NETWORK_ADD:
501 lde_kernel_insert(&fec, kr->af, &kr->nexthop,
502 kr->ifindex, kr->priority,
503 kr->flags & F_CONNECTED, NULL);
504 break;
505 case IMSG_NETWORK_UPDATE:
506 lde_kernel_update(&fec);
507 break;
508 }
509 break;
510 case IMSG_SOCKET_IPC:
511 if (iev_ldpe) {
512 log_warnx("%s: received unexpected imsg fd "
513 "to ldpe", __func__);
514 break;
515 }
516 if ((fd = imsg.fd) == -1) {
517 log_warnx("%s: expected to receive imsg fd to "
518 "ldpe but didn't receive any", __func__);
519 break;
520 }
521
522 if ((iev_ldpe = malloc(sizeof(struct imsgev))) == NULL)
523 fatal(NULL);
524 imsg_init(&iev_ldpe->ibuf, fd);
525 iev_ldpe->handler_read = lde_dispatch_imsg;
526 iev_ldpe->ev_read = NULL;
527 thread_add_read(master, iev_ldpe->handler_read, iev_ldpe, iev_ldpe->ibuf.fd,
528 &iev_ldpe->ev_read);
529 iev_ldpe->handler_write = ldp_write_handler;
530 iev_ldpe->ev_write = NULL;
531 break;
532 case IMSG_INIT:
533 if (imsg.hdr.len != IMSG_HEADER_SIZE +
534 sizeof(struct ldpd_init))
535 fatalx("INIT imsg with wrong len");
536
537 memcpy(&init, imsg.data, sizeof(init));
538 lde_init(&init);
539 break;
540 case IMSG_RECONF_CONF:
541 if ((nconf = malloc(sizeof(struct ldpd_conf))) ==
542 NULL)
543 fatal(NULL);
544 memcpy(nconf, imsg.data, sizeof(struct ldpd_conf));
545
546 RB_INIT(iface_head, &nconf->iface_tree);
547 RB_INIT(tnbr_head, &nconf->tnbr_tree);
548 RB_INIT(nbrp_head, &nconf->nbrp_tree);
549 RB_INIT(l2vpn_head, &nconf->l2vpn_tree);
550 break;
551 case IMSG_RECONF_IFACE:
552 if ((niface = malloc(sizeof(struct iface))) == NULL)
553 fatal(NULL);
554 memcpy(niface, imsg.data, sizeof(struct iface));
555
556 RB_INSERT(iface_head, &nconf->iface_tree, niface);
557 break;
558 case IMSG_RECONF_TNBR:
559 if ((ntnbr = malloc(sizeof(struct tnbr))) == NULL)
560 fatal(NULL);
561 memcpy(ntnbr, imsg.data, sizeof(struct tnbr));
562
563 RB_INSERT(tnbr_head, &nconf->tnbr_tree, ntnbr);
564 break;
565 case IMSG_RECONF_NBRP:
566 if ((nnbrp = malloc(sizeof(struct nbr_params))) == NULL)
567 fatal(NULL);
568 memcpy(nnbrp, imsg.data, sizeof(struct nbr_params));
569
570 RB_INSERT(nbrp_head, &nconf->nbrp_tree, nnbrp);
571 break;
572 case IMSG_RECONF_L2VPN:
573 if ((nl2vpn = malloc(sizeof(struct l2vpn))) == NULL)
574 fatal(NULL);
575 memcpy(nl2vpn, imsg.data, sizeof(struct l2vpn));
576
577 RB_INIT(l2vpn_if_head, &nl2vpn->if_tree);
578 RB_INIT(l2vpn_pw_head, &nl2vpn->pw_tree);
579 RB_INIT(l2vpn_pw_head, &nl2vpn->pw_inactive_tree);
580
581 RB_INSERT(l2vpn_head, &nconf->l2vpn_tree, nl2vpn);
582 break;
583 case IMSG_RECONF_L2VPN_IF:
584 if ((nlif = malloc(sizeof(struct l2vpn_if))) == NULL)
585 fatal(NULL);
586 memcpy(nlif, imsg.data, sizeof(struct l2vpn_if));
587
588 RB_INSERT(l2vpn_if_head, &nl2vpn->if_tree, nlif);
589 break;
590 case IMSG_RECONF_L2VPN_PW:
591 if ((npw = malloc(sizeof(struct l2vpn_pw))) == NULL)
592 fatal(NULL);
593 memcpy(npw, imsg.data, sizeof(struct l2vpn_pw));
594
595 RB_INSERT(l2vpn_pw_head, &nl2vpn->pw_tree, npw);
596 break;
597 case IMSG_RECONF_L2VPN_IPW:
598 if ((npw = malloc(sizeof(struct l2vpn_pw))) == NULL)
599 fatal(NULL);
600 memcpy(npw, imsg.data, sizeof(struct l2vpn_pw));
601
602 RB_INSERT(l2vpn_pw_head, &nl2vpn->pw_inactive_tree, npw);
603 break;
604 case IMSG_RECONF_END:
605 merge_config(ldeconf, nconf);
606 ldp_clear_config(nconf);
607 nconf = NULL;
608 break;
609 case IMSG_DEBUG_UPDATE:
610 if (imsg.hdr.len != IMSG_HEADER_SIZE +
611 sizeof(ldp_debug)) {
612 log_warnx("%s: wrong imsg len", __func__);
613 break;
614 }
615 memcpy(&ldp_debug, imsg.data, sizeof(ldp_debug));
616 break;
617 default:
618 log_debug("%s: unexpected imsg %d", __func__,
619 imsg.hdr.type);
620 break;
621 }
622 imsg_free(&imsg);
623 }
624 if (!shut)
625 imsg_event_add(iev);
626 else {
627 /* this pipe is dead, so remove the event handlers and exit */
628 THREAD_READ_OFF(iev->ev_read);
629 THREAD_WRITE_OFF(iev->ev_write);
630 lde_shutdown();
631 }
632
633 return (0);
634 }
635
636 int
637 lde_acl_check(char *acl_name, int af, union ldpd_addr *addr, uint8_t prefixlen)
638 {
639 return ldp_acl_request(iev_main_sync, acl_name, af, addr, prefixlen);
640 }
641
642 uint32_t
643 lde_update_label(struct fec_node *fn)
644 {
645 struct fec_nh *fnh;
646 int connected = 0;
647
648 LIST_FOREACH(fnh, &fn->nexthops, entry) {
649 if (fnh->flags & F_FEC_NH_CONNECTED) {
650 connected = 1;
651 break;
652 }
653 }
654
655 /* should we allocate a label for this fec? */
656 switch (fn->fec.type) {
657 case FEC_TYPE_IPV4:
658 if ((ldeconf->ipv4.flags & F_LDPD_AF_ALLOCHOSTONLY) &&
659 fn->fec.u.ipv4.prefixlen != 32)
660 return (NO_LABEL);
661 if (lde_acl_check(ldeconf->ipv4.acl_label_allocate_for,
662 AF_INET, (union ldpd_addr *)&fn->fec.u.ipv4.prefix,
663 fn->fec.u.ipv4.prefixlen) != FILTER_PERMIT)
664 return (NO_LABEL);
665 break;
666 case FEC_TYPE_IPV6:
667 if ((ldeconf->ipv6.flags & F_LDPD_AF_ALLOCHOSTONLY) &&
668 fn->fec.u.ipv6.prefixlen != 128)
669 return (NO_LABEL);
670 if (lde_acl_check(ldeconf->ipv6.acl_label_allocate_for,
671 AF_INET6, (union ldpd_addr *)&fn->fec.u.ipv6.prefix,
672 fn->fec.u.ipv6.prefixlen) != FILTER_PERMIT)
673 return (NO_LABEL);
674 break;
675 default:
676 break;
677 }
678
679 if (connected) {
680 /* choose implicit or explicit-null depending on configuration */
681 switch (fn->fec.type) {
682 case FEC_TYPE_IPV4:
683 if (!(ldeconf->ipv4.flags & F_LDPD_AF_EXPNULL))
684 return (MPLS_LABEL_IMPLNULL);
685 if (lde_acl_check(ldeconf->ipv4.acl_label_expnull_for,
686 AF_INET, (union ldpd_addr *)&fn->fec.u.ipv4.prefix,
687 fn->fec.u.ipv4.prefixlen) != FILTER_PERMIT)
688 return (MPLS_LABEL_IMPLNULL);
689 return (MPLS_LABEL_IPV4NULL);
690 case FEC_TYPE_IPV6:
691 if (!(ldeconf->ipv6.flags & F_LDPD_AF_EXPNULL))
692 return (MPLS_LABEL_IMPLNULL);
693 if (lde_acl_check(ldeconf->ipv6.acl_label_expnull_for,
694 AF_INET6, (union ldpd_addr *)&fn->fec.u.ipv6.prefix,
695 fn->fec.u.ipv6.prefixlen) != FILTER_PERMIT)
696 return (MPLS_LABEL_IMPLNULL);
697 return (MPLS_LABEL_IPV6NULL);
698 default:
699 fatalx("lde_update_label: unexpected fec type");
700 break;
701 }
702 }
703
704 /* preserve current label if there's no need to update it */
705 if (fn->local_label != NO_LABEL &&
706 fn->local_label > MPLS_LABEL_RESERVED_MAX)
707 return (fn->local_label);
708
709 return (lde_get_next_label());
710 }
711
712 void
713 lde_send_change_klabel(struct fec_node *fn, struct fec_nh *fnh)
714 {
715 struct kroute kr;
716 struct kpw kpw;
717 struct l2vpn_pw *pw;
718
719 switch (fn->fec.type) {
720 case FEC_TYPE_IPV4:
721 memset(&kr, 0, sizeof(kr));
722 kr.af = AF_INET;
723 kr.prefix.v4 = fn->fec.u.ipv4.prefix;
724 kr.prefixlen = fn->fec.u.ipv4.prefixlen;
725 kr.nexthop.v4 = fnh->nexthop.v4;
726 kr.ifindex = fnh->ifindex;
727 kr.local_label = fn->local_label;
728 kr.remote_label = fnh->remote_label;
729 kr.priority = fnh->priority;
730
731 lde_imsg_compose_parent(IMSG_KLABEL_CHANGE, 0, &kr,
732 sizeof(kr));
733 break;
734 case FEC_TYPE_IPV6:
735 memset(&kr, 0, sizeof(kr));
736 kr.af = AF_INET6;
737 kr.prefix.v6 = fn->fec.u.ipv6.prefix;
738 kr.prefixlen = fn->fec.u.ipv6.prefixlen;
739 kr.nexthop.v6 = fnh->nexthop.v6;
740 kr.ifindex = fnh->ifindex;
741 kr.local_label = fn->local_label;
742 kr.remote_label = fnh->remote_label;
743 kr.priority = fnh->priority;
744
745 lde_imsg_compose_parent(IMSG_KLABEL_CHANGE, 0, &kr,
746 sizeof(kr));
747 break;
748 case FEC_TYPE_PWID:
749 if (fn->local_label == NO_LABEL ||
750 fnh->remote_label == NO_LABEL)
751 return;
752
753 pw = (struct l2vpn_pw *) fn->data;
754 pw->flags |= F_PW_STATUS_UP;
755
756 memset(&kpw, 0, sizeof(kpw));
757 kpw.ifindex = pw->ifindex;
758 kpw.pw_type = fn->fec.u.pwid.type;
759 kpw.af = pw->af;
760 kpw.nexthop = pw->addr;
761 kpw.local_label = fn->local_label;
762 kpw.remote_label = fnh->remote_label;
763 kpw.flags = pw->flags;
764
765 lde_imsg_compose_parent(IMSG_KPWLABEL_CHANGE, 0, &kpw,
766 sizeof(kpw));
767 break;
768 }
769 }
770
771 void
772 lde_send_delete_klabel(struct fec_node *fn, struct fec_nh *fnh)
773 {
774 struct kroute kr;
775 struct kpw kpw;
776 struct l2vpn_pw *pw;
777
778 switch (fn->fec.type) {
779 case FEC_TYPE_IPV4:
780 memset(&kr, 0, sizeof(kr));
781 kr.af = AF_INET;
782 kr.prefix.v4 = fn->fec.u.ipv4.prefix;
783 kr.prefixlen = fn->fec.u.ipv4.prefixlen;
784 kr.nexthop.v4 = fnh->nexthop.v4;
785 kr.ifindex = fnh->ifindex;
786 kr.local_label = fn->local_label;
787 kr.remote_label = fnh->remote_label;
788 kr.priority = fnh->priority;
789
790 lde_imsg_compose_parent(IMSG_KLABEL_DELETE, 0, &kr,
791 sizeof(kr));
792 break;
793 case FEC_TYPE_IPV6:
794 memset(&kr, 0, sizeof(kr));
795 kr.af = AF_INET6;
796 kr.prefix.v6 = fn->fec.u.ipv6.prefix;
797 kr.prefixlen = fn->fec.u.ipv6.prefixlen;
798 kr.nexthop.v6 = fnh->nexthop.v6;
799 kr.ifindex = fnh->ifindex;
800 kr.local_label = fn->local_label;
801 kr.remote_label = fnh->remote_label;
802 kr.priority = fnh->priority;
803
804 lde_imsg_compose_parent(IMSG_KLABEL_DELETE, 0, &kr,
805 sizeof(kr));
806 break;
807 case FEC_TYPE_PWID:
808 pw = (struct l2vpn_pw *) fn->data;
809 if (!(pw->flags & F_PW_STATUS_UP))
810 return;
811 pw->flags &= ~F_PW_STATUS_UP;
812
813 memset(&kpw, 0, sizeof(kpw));
814 kpw.ifindex = pw->ifindex;
815 kpw.pw_type = fn->fec.u.pwid.type;
816 kpw.af = pw->af;
817 kpw.nexthop = pw->addr;
818 kpw.local_label = fn->local_label;
819 kpw.remote_label = fnh->remote_label;
820 kpw.flags = pw->flags;
821
822 lde_imsg_compose_parent(IMSG_KPWLABEL_DELETE, 0, &kpw,
823 sizeof(kpw));
824 break;
825 }
826 }
827
828 void
829 lde_fec2map(struct fec *fec, struct map *map)
830 {
831 memset(map, 0, sizeof(*map));
832
833 switch (fec->type) {
834 case FEC_TYPE_IPV4:
835 map->type = MAP_TYPE_PREFIX;
836 map->fec.prefix.af = AF_INET;
837 map->fec.prefix.prefix.v4 = fec->u.ipv4.prefix;
838 map->fec.prefix.prefixlen = fec->u.ipv4.prefixlen;
839 break;
840 case FEC_TYPE_IPV6:
841 map->type = MAP_TYPE_PREFIX;
842 map->fec.prefix.af = AF_INET6;
843 map->fec.prefix.prefix.v6 = fec->u.ipv6.prefix;
844 map->fec.prefix.prefixlen = fec->u.ipv6.prefixlen;
845 break;
846 case FEC_TYPE_PWID:
847 map->type = MAP_TYPE_PWID;
848 map->fec.pwid.type = fec->u.pwid.type;
849 map->fec.pwid.group_id = 0;
850 map->flags |= F_MAP_PW_ID;
851 map->fec.pwid.pwid = fec->u.pwid.pwid;
852 break;
853 }
854 }
855
856 void
857 lde_map2fec(struct map *map, struct in_addr lsr_id, struct fec *fec)
858 {
859 memset(fec, 0, sizeof(*fec));
860
861 switch (map->type) {
862 case MAP_TYPE_PREFIX:
863 switch (map->fec.prefix.af) {
864 case AF_INET:
865 fec->type = FEC_TYPE_IPV4;
866 fec->u.ipv4.prefix = map->fec.prefix.prefix.v4;
867 fec->u.ipv4.prefixlen = map->fec.prefix.prefixlen;
868 break;
869 case AF_INET6:
870 fec->type = FEC_TYPE_IPV6;
871 fec->u.ipv6.prefix = map->fec.prefix.prefix.v6;
872 fec->u.ipv6.prefixlen = map->fec.prefix.prefixlen;
873 break;
874 default:
875 fatalx("lde_map2fec: unknown af");
876 break;
877 }
878 break;
879 case MAP_TYPE_PWID:
880 fec->type = FEC_TYPE_PWID;
881 fec->u.pwid.type = map->fec.pwid.type;
882 fec->u.pwid.pwid = map->fec.pwid.pwid;
883 fec->u.pwid.lsr_id = lsr_id;
884 break;
885 }
886 }
887
888 void
889 lde_send_labelmapping(struct lde_nbr *ln, struct fec_node *fn, int single)
890 {
891 struct lde_wdraw *lw;
892 struct lde_map *me;
893 struct lde_req *lre;
894 struct map map;
895 struct l2vpn_pw *pw;
896
897 /*
898 * We shouldn't send a new label mapping if we have a pending
899 * label release to receive. In this case, schedule to send a
900 * label mapping as soon as a label release is received.
901 */
902 lw = (struct lde_wdraw *)fec_find(&ln->sent_wdraw, &fn->fec);
903 if (lw) {
904 if (!fec_find(&ln->sent_map_pending, &fn->fec))
905 lde_map_pending_add(ln, fn);
906 return;
907 }
908
909 /*
910 * This function skips SL.1 - 3 and SL.9 - 14 because the label
911 * allocation is done way earlier (because of the merging nature of
912 * ldpd).
913 */
914
915 lde_fec2map(&fn->fec, &map);
916 switch (fn->fec.type) {
917 case FEC_TYPE_IPV4:
918 if (!ln->v4_enabled)
919 return;
920 if (lde_acl_check(ldeconf->ipv4.acl_label_advertise_to,
921 AF_INET, (union ldpd_addr *)&ln->id, 32) != FILTER_PERMIT)
922 return;
923 if (lde_acl_check(ldeconf->ipv4.acl_label_advertise_for,
924 AF_INET, (union ldpd_addr *)&fn->fec.u.ipv4.prefix,
925 fn->fec.u.ipv4.prefixlen) != FILTER_PERMIT)
926 return;
927 break;
928 case FEC_TYPE_IPV6:
929 if (!ln->v6_enabled)
930 return;
931 if (lde_acl_check(ldeconf->ipv6.acl_label_advertise_to,
932 AF_INET, (union ldpd_addr *)&ln->id, 32) != FILTER_PERMIT)
933 return;
934 if (lde_acl_check(ldeconf->ipv6.acl_label_advertise_for,
935 AF_INET6, (union ldpd_addr *)&fn->fec.u.ipv6.prefix,
936 fn->fec.u.ipv6.prefixlen) != FILTER_PERMIT)
937 return;
938 break;
939 case FEC_TYPE_PWID:
940 pw = (struct l2vpn_pw *) fn->data;
941 if (pw == NULL || pw->lsr_id.s_addr != ln->id.s_addr)
942 /* not the remote end of the pseudowire */
943 return;
944
945 map.flags |= F_MAP_PW_IFMTU;
946 map.fec.pwid.ifmtu = pw->l2vpn->mtu;
947 if (pw->flags & F_PW_CWORD)
948 map.flags |= F_MAP_PW_CWORD;
949 if (pw->flags & F_PW_STATUSTLV) {
950 map.flags |= F_MAP_PW_STATUS;
951 /* VPLS are always up */
952 map.pw_status = PW_FORWARDING;
953 }
954 break;
955 }
956 map.label = fn->local_label;
957
958 /* SL.6: is there a pending request for this mapping? */
959 lre = (struct lde_req *)fec_find(&ln->recv_req, &fn->fec);
960 if (lre) {
961 /* set label request msg id in the mapping response. */
962 map.requestid = lre->msg_id;
963 map.flags = F_MAP_REQ_ID;
964
965 /* SL.7: delete record of pending request */
966 lde_req_del(ln, lre, 0);
967 }
968
969 /* SL.4: send label mapping */
970 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD, ln->peerid, 0,
971 &map, sizeof(map));
972 if (single)
973 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END, ln->peerid, 0,
974 NULL, 0);
975
976 /* SL.5: record sent label mapping */
977 me = (struct lde_map *)fec_find(&ln->sent_map, &fn->fec);
978 if (me == NULL)
979 me = lde_map_add(ln, fn, 1);
980 me->map = map;
981 }
982
983 void
984 lde_send_labelwithdraw(struct lde_nbr *ln, struct fec_node *fn,
985 struct map *wcard, struct status_tlv *st)
986 {
987 struct lde_wdraw *lw;
988 struct map map;
989 struct fec *f;
990 struct l2vpn_pw *pw;
991
992 if (fn) {
993 lde_fec2map(&fn->fec, &map);
994 switch (fn->fec.type) {
995 case FEC_TYPE_IPV4:
996 if (!ln->v4_enabled)
997 return;
998 break;
999 case FEC_TYPE_IPV6:
1000 if (!ln->v6_enabled)
1001 return;
1002 break;
1003 case FEC_TYPE_PWID:
1004 pw = (struct l2vpn_pw *) fn->data;
1005 if (pw == NULL || pw->lsr_id.s_addr != ln->id.s_addr)
1006 /* not the remote end of the pseudowire */
1007 return;
1008
1009 if (pw->flags & F_PW_CWORD)
1010 map.flags |= F_MAP_PW_CWORD;
1011 break;
1012 }
1013 map.label = fn->local_label;
1014 } else
1015 memcpy(&map, wcard, sizeof(map));
1016
1017 if (st) {
1018 map.st.status_code = st->status_code;
1019 map.st.msg_id = st->msg_id;
1020 map.st.msg_type = st->msg_type;
1021 map.flags |= F_MAP_STATUS;
1022 }
1023
1024 /* SWd.1: send label withdraw. */
1025 lde_imsg_compose_ldpe(IMSG_WITHDRAW_ADD, ln->peerid, 0,
1026 &map, sizeof(map));
1027 lde_imsg_compose_ldpe(IMSG_WITHDRAW_ADD_END, ln->peerid, 0, NULL, 0);
1028
1029 /* SWd.2: record label withdraw. */
1030 if (fn) {
1031 lw = (struct lde_wdraw *)fec_find(&ln->sent_wdraw, &fn->fec);
1032 if (lw == NULL)
1033 lw = lde_wdraw_add(ln, fn);
1034 lw->label = map.label;
1035 } else {
1036 struct lde_map *me;
1037
1038 RB_FOREACH(f, fec_tree, &ft) {
1039 fn = (struct fec_node *)f;
1040 me = (struct lde_map *)fec_find(&ln->sent_map, &fn->fec);
1041 if (lde_wildcard_apply(wcard, &fn->fec, me) == 0)
1042 continue;
1043
1044 lw = (struct lde_wdraw *)fec_find(&ln->sent_wdraw,
1045 &fn->fec);
1046 if (lw == NULL)
1047 lw = lde_wdraw_add(ln, fn);
1048 lw->label = map.label;
1049 }
1050 }
1051 }
1052
1053 void
1054 lde_send_labelwithdraw_wcard(struct lde_nbr *ln, uint32_t label)
1055 {
1056 struct map wcard;
1057
1058 memset(&wcard, 0, sizeof(wcard));
1059 wcard.type = MAP_TYPE_WILDCARD;
1060 wcard.label = label;
1061 lde_send_labelwithdraw(ln, NULL, &wcard, NULL);
1062 }
1063
1064 void
1065 lde_send_labelwithdraw_twcard_prefix(struct lde_nbr *ln, uint16_t af,
1066 uint32_t label)
1067 {
1068 struct map wcard;
1069
1070 memset(&wcard, 0, sizeof(wcard));
1071 wcard.type = MAP_TYPE_TYPED_WCARD;
1072 wcard.fec.twcard.type = MAP_TYPE_PREFIX;
1073 wcard.fec.twcard.u.prefix_af = af;
1074 wcard.label = label;
1075 lde_send_labelwithdraw(ln, NULL, &wcard, NULL);
1076 }
1077
1078 void
1079 lde_send_labelwithdraw_twcard_pwid(struct lde_nbr *ln, uint16_t pw_type,
1080 uint32_t label)
1081 {
1082 struct map wcard;
1083
1084 memset(&wcard, 0, sizeof(wcard));
1085 wcard.type = MAP_TYPE_TYPED_WCARD;
1086 wcard.fec.twcard.type = MAP_TYPE_PWID;
1087 wcard.fec.twcard.u.pw_type = pw_type;
1088 wcard.label = label;
1089 lde_send_labelwithdraw(ln, NULL, &wcard, NULL);
1090 }
1091
1092 void
1093 lde_send_labelwithdraw_pwid_wcard(struct lde_nbr *ln, uint16_t pw_type,
1094 uint32_t group_id)
1095 {
1096 struct map wcard;
1097
1098 memset(&wcard, 0, sizeof(wcard));
1099 wcard.type = MAP_TYPE_PWID;
1100 wcard.fec.pwid.type = pw_type;
1101 wcard.fec.pwid.group_id = group_id;
1102 /* we can not append a Label TLV when using PWid group wildcards. */
1103 wcard.label = NO_LABEL;
1104 lde_send_labelwithdraw(ln, NULL, &wcard, NULL);
1105 }
1106
1107 void
1108 lde_send_labelrelease(struct lde_nbr *ln, struct fec_node *fn,
1109 struct map *wcard, uint32_t label)
1110 {
1111 struct map map;
1112 struct l2vpn_pw *pw;
1113
1114 if (fn) {
1115 lde_fec2map(&fn->fec, &map);
1116 switch (fn->fec.type) {
1117 case FEC_TYPE_IPV4:
1118 if (!ln->v4_enabled)
1119 return;
1120 break;
1121 case FEC_TYPE_IPV6:
1122 if (!ln->v6_enabled)
1123 return;
1124 break;
1125 case FEC_TYPE_PWID:
1126 pw = (struct l2vpn_pw *) fn->data;
1127 if (pw == NULL || pw->lsr_id.s_addr != ln->id.s_addr)
1128 /* not the remote end of the pseudowire */
1129 return;
1130
1131 if (pw->flags & F_PW_CWORD)
1132 map.flags |= F_MAP_PW_CWORD;
1133 break;
1134 }
1135 } else
1136 memcpy(&map, wcard, sizeof(map));
1137 map.label = label;
1138
1139 lde_imsg_compose_ldpe(IMSG_RELEASE_ADD, ln->peerid, 0,
1140 &map, sizeof(map));
1141 lde_imsg_compose_ldpe(IMSG_RELEASE_ADD_END, ln->peerid, 0, NULL, 0);
1142 }
1143
1144 void
1145 lde_send_notification(struct lde_nbr *ln, uint32_t status_code, uint32_t msg_id,
1146 uint16_t msg_type)
1147 {
1148 struct notify_msg nm;
1149
1150 memset(&nm, 0, sizeof(nm));
1151 nm.status_code = status_code;
1152 /* 'msg_id' and 'msg_type' should be in network byte order */
1153 nm.msg_id = msg_id;
1154 nm.msg_type = msg_type;
1155
1156 lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND, ln->peerid, 0,
1157 &nm, sizeof(nm));
1158 }
1159
1160 void
1161 lde_send_notification_eol_prefix(struct lde_nbr *ln, int af)
1162 {
1163 struct notify_msg nm;
1164
1165 memset(&nm, 0, sizeof(nm));
1166 nm.status_code = S_ENDOFLIB;
1167 nm.fec.type = MAP_TYPE_TYPED_WCARD;
1168 nm.fec.fec.twcard.type = MAP_TYPE_PREFIX;
1169 nm.fec.fec.twcard.u.prefix_af = af;
1170 nm.flags |= F_NOTIF_FEC;
1171
1172 lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND, ln->peerid, 0,
1173 &nm, sizeof(nm));
1174 }
1175
1176 void
1177 lde_send_notification_eol_pwid(struct lde_nbr *ln, uint16_t pw_type)
1178 {
1179 struct notify_msg nm;
1180
1181 memset(&nm, 0, sizeof(nm));
1182 nm.status_code = S_ENDOFLIB;
1183 nm.fec.type = MAP_TYPE_TYPED_WCARD;
1184 nm.fec.fec.twcard.type = MAP_TYPE_PWID;
1185 nm.fec.fec.twcard.u.pw_type = pw_type;
1186 nm.flags |= F_NOTIF_FEC;
1187
1188 lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND, ln->peerid, 0,
1189 &nm, sizeof(nm));
1190 }
1191
1192 static __inline int
1193 lde_nbr_compare(const struct lde_nbr *a, const struct lde_nbr *b)
1194 {
1195 return (a->peerid - b->peerid);
1196 }
1197
1198 static struct lde_nbr *
1199 lde_nbr_new(uint32_t peerid, struct lde_nbr *new)
1200 {
1201 struct lde_nbr *ln;
1202
1203 if ((ln = calloc(1, sizeof(*ln))) == NULL)
1204 fatal(__func__);
1205
1206 ln->id = new->id;
1207 ln->v4_enabled = new->v4_enabled;
1208 ln->v6_enabled = new->v6_enabled;
1209 ln->flags = new->flags;
1210 ln->peerid = peerid;
1211 fec_init(&ln->recv_map);
1212 fec_init(&ln->sent_map);
1213 fec_init(&ln->sent_map_pending);
1214 fec_init(&ln->recv_req);
1215 fec_init(&ln->sent_req);
1216 fec_init(&ln->sent_wdraw);
1217
1218 TAILQ_INIT(&ln->addr_list);
1219
1220 if (RB_INSERT(nbr_tree, &lde_nbrs, ln) != NULL)
1221 fatalx("lde_nbr_new: RB_INSERT failed");
1222
1223 return (ln);
1224 }
1225
1226 static void
1227 lde_nbr_del(struct lde_nbr *ln)
1228 {
1229 struct fec *f;
1230 struct fec_node *fn;
1231 struct fec_nh *fnh;
1232 struct l2vpn_pw *pw;
1233
1234 if (ln == NULL)
1235 return;
1236
1237 /* uninstall received mappings */
1238 RB_FOREACH(f, fec_tree, &ft) {
1239 fn = (struct fec_node *)f;
1240
1241 LIST_FOREACH(fnh, &fn->nexthops, entry) {
1242 switch (f->type) {
1243 case FEC_TYPE_IPV4:
1244 case FEC_TYPE_IPV6:
1245 if (!lde_address_find(ln, fnh->af,
1246 &fnh->nexthop))
1247 continue;
1248 break;
1249 case FEC_TYPE_PWID:
1250 if (f->u.pwid.lsr_id.s_addr != ln->id.s_addr)
1251 continue;
1252 pw = (struct l2vpn_pw *) fn->data;
1253 if (pw)
1254 l2vpn_pw_reset(pw);
1255 break;
1256 default:
1257 break;
1258 }
1259
1260 lde_send_delete_klabel(fn, fnh);
1261 fnh->remote_label = NO_LABEL;
1262 }
1263 }
1264
1265 lde_address_list_free(ln);
1266
1267 fec_clear(&ln->recv_map, lde_map_free);
1268 fec_clear(&ln->sent_map, lde_map_free);
1269 fec_clear(&ln->sent_map_pending, free);
1270 fec_clear(&ln->recv_req, free);
1271 fec_clear(&ln->sent_req, free);
1272 fec_clear(&ln->sent_wdraw, free);
1273
1274 RB_REMOVE(nbr_tree, &lde_nbrs, ln);
1275
1276 free(ln);
1277 }
1278
1279 static struct lde_nbr *
1280 lde_nbr_find(uint32_t peerid)
1281 {
1282 struct lde_nbr ln;
1283
1284 ln.peerid = peerid;
1285
1286 return (RB_FIND(nbr_tree, &lde_nbrs, &ln));
1287 }
1288
1289 struct lde_nbr *
1290 lde_nbr_find_by_lsrid(struct in_addr addr)
1291 {
1292 struct lde_nbr *ln;
1293
1294 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1295 if (ln->id.s_addr == addr.s_addr)
1296 return (ln);
1297
1298 return (NULL);
1299 }
1300
1301 struct lde_nbr *
1302 lde_nbr_find_by_addr(int af, union ldpd_addr *addr)
1303 {
1304 struct lde_nbr *ln;
1305
1306 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1307 if (lde_address_find(ln, af, addr) != NULL)
1308 return (ln);
1309
1310 return (NULL);
1311 }
1312
1313 static void
1314 lde_nbr_clear(void)
1315 {
1316 struct lde_nbr *ln;
1317
1318 while ((ln = RB_ROOT(nbr_tree, &lde_nbrs)) != NULL)
1319 lde_nbr_del(ln);
1320 }
1321
1322 static void
1323 lde_nbr_addr_update(struct lde_nbr *ln, struct lde_addr *lde_addr, int removed)
1324 {
1325 struct fec *fec;
1326 struct fec_node *fn;
1327 struct fec_nh *fnh;
1328 struct lde_map *me;
1329
1330 RB_FOREACH(fec, fec_tree, &ln->recv_map) {
1331 switch (fec->type) {
1332 case FEC_TYPE_IPV4:
1333 if (lde_addr->af != AF_INET)
1334 continue;
1335 break;
1336 case FEC_TYPE_IPV6:
1337 if (lde_addr->af != AF_INET6)
1338 continue;
1339 break;
1340 default:
1341 continue;
1342 }
1343
1344 fn = (struct fec_node *)fec_find(&ft, fec);
1345 if (fn == NULL)
1346 /* shouldn't happen */
1347 continue;
1348
1349 LIST_FOREACH(fnh, &fn->nexthops, entry) {
1350 if (ldp_addrcmp(fnh->af, &fnh->nexthop,
1351 &lde_addr->addr))
1352 continue;
1353
1354 if (removed) {
1355 lde_send_delete_klabel(fn, fnh);
1356 fnh->remote_label = NO_LABEL;
1357 } else {
1358 me = (struct lde_map *)fec;
1359 fnh->remote_label = me->map.label;
1360 lde_send_change_klabel(fn, fnh);
1361 }
1362 break;
1363 }
1364 }
1365 }
1366
1367 static __inline int
1368 lde_map_compare(const struct lde_map *a, const struct lde_map *b)
1369 {
1370 return (ldp_addrcmp(AF_INET, (union ldpd_addr *)&a->nexthop->id,
1371 (union ldpd_addr *)&b->nexthop->id));
1372 }
1373
1374 struct lde_map *
1375 lde_map_add(struct lde_nbr *ln, struct fec_node *fn, int sent)
1376 {
1377 struct lde_map *me;
1378
1379 me = calloc(1, sizeof(*me));
1380 if (me == NULL)
1381 fatal(__func__);
1382
1383 me->fec = fn->fec;
1384 me->nexthop = ln;
1385
1386 if (sent) {
1387 RB_INSERT(lde_map_head, &fn->upstream, me);
1388 me->head = &fn->upstream;
1389 if (fec_insert(&ln->sent_map, &me->fec))
1390 log_warnx("failed to add %s to sent map",
1391 log_fec(&me->fec));
1392 /* XXX on failure more cleanup is needed */
1393 } else {
1394 RB_INSERT(lde_map_head, &fn->downstream, me);
1395 me->head = &fn->downstream;
1396 if (fec_insert(&ln->recv_map, &me->fec))
1397 log_warnx("failed to add %s to recv map",
1398 log_fec(&me->fec));
1399 }
1400
1401 return (me);
1402 }
1403
1404 void
1405 lde_map_del(struct lde_nbr *ln, struct lde_map *me, int sent)
1406 {
1407 if (sent)
1408 fec_remove(&ln->sent_map, &me->fec);
1409 else
1410 fec_remove(&ln->recv_map, &me->fec);
1411
1412 lde_map_free(me);
1413 }
1414
1415 static void
1416 lde_map_free(void *ptr)
1417 {
1418 struct lde_map *map = ptr;
1419
1420 RB_REMOVE(lde_map_head, map->head, map);
1421 free(map);
1422 }
1423
1424 struct fec *
1425 lde_map_pending_add(struct lde_nbr *ln, struct fec_node *fn)
1426 {
1427 struct fec *map;
1428
1429 map = calloc(1, sizeof(*map));
1430 if (map == NULL)
1431 fatal(__func__);
1432
1433 *map = fn->fec;
1434 if (fec_insert(&ln->sent_map_pending, map))
1435 log_warnx("failed to add %s to sent map (pending)",
1436 log_fec(map));
1437
1438 return (map);
1439 }
1440
1441 void
1442 lde_map_pending_del(struct lde_nbr *ln, struct fec *map)
1443 {
1444 fec_remove(&ln->sent_map_pending, map);
1445 free(map);
1446 }
1447
1448 struct lde_req *
1449 lde_req_add(struct lde_nbr *ln, struct fec *fec, int sent)
1450 {
1451 struct fec_tree *t;
1452 struct lde_req *lre;
1453
1454 t = sent ? &ln->sent_req : &ln->recv_req;
1455
1456 lre = calloc(1, sizeof(*lre));
1457 if (lre != NULL) {
1458 lre->fec = *fec;
1459
1460 if (fec_insert(t, &lre->fec)) {
1461 log_warnx("failed to add %s to %s req",
1462 log_fec(&lre->fec), sent ? "sent" : "recv");
1463 free(lre);
1464 return (NULL);
1465 }
1466 }
1467
1468 return (lre);
1469 }
1470
1471 void
1472 lde_req_del(struct lde_nbr *ln, struct lde_req *lre, int sent)
1473 {
1474 if (sent)
1475 fec_remove(&ln->sent_req, &lre->fec);
1476 else
1477 fec_remove(&ln->recv_req, &lre->fec);
1478
1479 free(lre);
1480 }
1481
1482 struct lde_wdraw *
1483 lde_wdraw_add(struct lde_nbr *ln, struct fec_node *fn)
1484 {
1485 struct lde_wdraw *lw;
1486
1487 lw = calloc(1, sizeof(*lw));
1488 if (lw == NULL)
1489 fatal(__func__);
1490
1491 lw->fec = fn->fec;
1492
1493 if (fec_insert(&ln->sent_wdraw, &lw->fec))
1494 log_warnx("failed to add %s to sent wdraw",
1495 log_fec(&lw->fec));
1496
1497 return (lw);
1498 }
1499
1500 void
1501 lde_wdraw_del(struct lde_nbr *ln, struct lde_wdraw *lw)
1502 {
1503 fec_remove(&ln->sent_wdraw, &lw->fec);
1504 free(lw);
1505 }
1506
1507 void
1508 lde_change_egress_label(int af)
1509 {
1510 struct lde_nbr *ln;
1511 struct fec *f;
1512 struct fec_node *fn;
1513
1514 /* explicitly withdraw all null labels */
1515 RB_FOREACH(ln, nbr_tree, &lde_nbrs) {
1516 lde_send_labelwithdraw_wcard(ln, MPLS_LABEL_IMPLNULL);
1517 if (ln->v4_enabled)
1518 lde_send_labelwithdraw_wcard(ln, MPLS_LABEL_IPV4NULL);
1519 if (ln->v6_enabled)
1520 lde_send_labelwithdraw_wcard(ln, MPLS_LABEL_IPV6NULL);
1521 }
1522
1523 /* update label of connected routes */
1524 RB_FOREACH(f, fec_tree, &ft) {
1525 fn = (struct fec_node *)f;
1526 if (fn->local_label > MPLS_LABEL_RESERVED_MAX)
1527 continue;
1528
1529 switch (af) {
1530 case AF_INET:
1531 if (fn->fec.type != FEC_TYPE_IPV4)
1532 continue;
1533 break;
1534 case AF_INET6:
1535 if (fn->fec.type != FEC_TYPE_IPV6)
1536 continue;
1537 break;
1538 default:
1539 fatalx("lde_change_egress_label: unknown af");
1540 }
1541
1542 fn->local_label = lde_update_label(fn);
1543 if (fn->local_label != NO_LABEL)
1544 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1545 lde_send_labelmapping(ln, fn, 0);
1546 }
1547 RB_FOREACH(ln, nbr_tree, &lde_nbrs)
1548 lde_imsg_compose_ldpe(IMSG_MAPPING_ADD_END, ln->peerid, 0,
1549 NULL, 0);
1550 }
1551
1552 static int
1553 lde_address_add(struct lde_nbr *ln, struct lde_addr *lde_addr)
1554 {
1555 struct lde_addr *new;
1556
1557 if (lde_address_find(ln, lde_addr->af, &lde_addr->addr) != NULL)
1558 return (-1);
1559
1560 if ((new = calloc(1, sizeof(*new))) == NULL)
1561 fatal(__func__);
1562
1563 new->af = lde_addr->af;
1564 new->addr = lde_addr->addr;
1565 TAILQ_INSERT_TAIL(&ln->addr_list, new, entry);
1566
1567 /* reevaluate the previously received mappings from this neighbor */
1568 lde_nbr_addr_update(ln, lde_addr, 0);
1569
1570 return (0);
1571 }
1572
1573 static int
1574 lde_address_del(struct lde_nbr *ln, struct lde_addr *lde_addr)
1575 {
1576 lde_addr = lde_address_find(ln, lde_addr->af, &lde_addr->addr);
1577 if (lde_addr == NULL)
1578 return (-1);
1579
1580 /* reevaluate the previously received mappings from this neighbor */
1581 lde_nbr_addr_update(ln, lde_addr, 1);
1582
1583 TAILQ_REMOVE(&ln->addr_list, lde_addr, entry);
1584 free(lde_addr);
1585
1586 return (0);
1587 }
1588
1589 struct lde_addr *
1590 lde_address_find(struct lde_nbr *ln, int af, union ldpd_addr *addr)
1591 {
1592 struct lde_addr *lde_addr;
1593
1594 TAILQ_FOREACH(lde_addr, &ln->addr_list, entry)
1595 if (lde_addr->af == af &&
1596 ldp_addrcmp(af, &lde_addr->addr, addr) == 0)
1597 return (lde_addr);
1598
1599 return (NULL);
1600 }
1601
1602 static void
1603 lde_address_list_free(struct lde_nbr *ln)
1604 {
1605 struct lde_addr *lde_addr;
1606
1607 while ((lde_addr = TAILQ_FIRST(&ln->addr_list)) != NULL) {
1608 TAILQ_REMOVE(&ln->addr_list, lde_addr, entry);
1609 free(lde_addr);
1610 }
1611 }
1612
1613 static void
1614 zclient_sync_init(u_short instance)
1615 {
1616 /* Initialize special zclient for synchronous message exchanges. */
1617 log_debug("Initializing synchronous zclient for label manager");
1618 zclient_sync = zclient_new(master);
1619 zclient_sync->sock = -1;
1620 zclient_sync->redist_default = ZEBRA_ROUTE_LDP;
1621 zclient_sync->instance = instance;
1622 while (zclient_socket_connect(zclient_sync) < 0) {
1623 log_warnx("Error connecting synchronous zclient!");
1624 sleep(1);
1625 }
1626 /* make socket non-blocking */
1627 sock_set_nonblock(zclient_sync->sock);
1628
1629 /* Connect to label manager */
1630 while (lm_label_manager_connect(zclient_sync) != 0) {
1631 log_warnx("Error connecting to label manager!");
1632 sleep(1);
1633 }
1634 }
1635
1636 static void
1637 lde_del_label_chunk(void *val)
1638 {
1639 free(val);
1640 }
1641
1642 static int
1643 lde_get_label_chunk(void)
1644 {
1645 int ret;
1646 uint32_t start, end;
1647
1648 log_debug("Getting label chunk");
1649 ret = lm_get_label_chunk(zclient_sync, 0, CHUNK_SIZE, &start, &end);
1650 if (ret < 0) {
1651 log_warnx("Error getting label chunk!");
1652 return -1;
1653 }
1654
1655 on_get_label_chunk_response(start, end);
1656
1657 return (0);
1658 }
1659
1660 static void
1661 lde_label_list_init(void)
1662 {
1663 label_chunk_list = list_new();
1664 label_chunk_list->del = lde_del_label_chunk;
1665
1666 /* get first chunk */
1667 while (lde_get_label_chunk () != 0) {
1668 log_warnx("Error getting first label chunk!");
1669 sleep(1);
1670 }
1671 }
1672
1673 static void
1674 on_get_label_chunk_response(uint32_t start, uint32_t end)
1675 {
1676 struct label_chunk *new_label_chunk;
1677
1678 log_debug("Label Chunk assign: %u - %u", start, end);
1679
1680 new_label_chunk = calloc(1, sizeof(struct label_chunk));
1681 if (!new_label_chunk) {
1682 log_warn("Error trying to allocate label chunk %u - %u", start, end);
1683 return;
1684 }
1685
1686 new_label_chunk->start = start;
1687 new_label_chunk->end = end;
1688 new_label_chunk->used_mask = 0;
1689
1690 listnode_add(label_chunk_list, (void *)new_label_chunk);
1691
1692 /* let's update current if needed */
1693 if (!current_label_chunk)
1694 current_label_chunk = listtail(label_chunk_list);
1695 }
1696
1697 static uint32_t
1698 lde_get_next_label(void)
1699 {
1700 struct label_chunk *label_chunk;
1701 uint32_t i, pos, size;
1702 uint32_t label = NO_LABEL;
1703
1704 while (current_label_chunk) {
1705 label_chunk = listgetdata(current_label_chunk);
1706 if (!label_chunk)
1707 goto end;
1708
1709 /* try to get next free label in currently used label chunk */
1710 size = label_chunk->end - label_chunk->start + 1;
1711 for (i = 0, pos = 1; i < size; i++, pos <<= 1) {
1712 if (!(pos & label_chunk->used_mask)) {
1713 label_chunk->used_mask |= pos;
1714 label = label_chunk->start + i;
1715 goto end;
1716 }
1717 }
1718 current_label_chunk = listnextnode(current_label_chunk);
1719 }
1720
1721 end:
1722 /* we moved till the last chunk, or were not able to find a label,
1723 so let's ask for another one */
1724 if (!current_label_chunk ||
1725 current_label_chunk == listtail(label_chunk_list) ||
1726 label == NO_LABEL) {
1727 if (lde_get_label_chunk() != 0)
1728 log_warn("%s: Error getting label chunk!", __func__);
1729
1730 }
1731
1732 return (label);
1733 }
FRRouting mirror